public function testGetSetWorkflowDefinition() { $this->assertNull($this->workflowDefinitionEntity->getWorkflowDefinition()); $value = new WorkflowDefinition(); $value->setName('test_workflow'); $this->workflowDefinitionEntity->setWorkflowDefinition($value); $this->assertEquals($value, $this->workflowDefinitionEntity->getWorkflowDefinition()); }
/** * Get Workflow by WorkflowDefinition * * @param WorkflowDefinition $definition * @return Workflow */ protected function getAssembledWorkflow(WorkflowDefinition $definition) { $workflowName = $definition->getName(); if (!isset($this->workflowByName[$workflowName])) { $workflow = $this->workflowAssembler->assemble($definition); $this->workflowByName[$workflowName] = $workflow; } return $this->refreshWorkflow($this->workflowByName[$workflowName]); }
/** * @expectedException \Oro\Bundle\WorkflowBundle\Exception\WorkflowException * @expectedExceptionMessage Cannot find workflow definition "test_workflow" */ public function testPrePersistFails() { $entity = new WorkflowItem(); $entity->setWorkflowName('test_workflow'); $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName('test_workflow'); $em = $this->getMockBuilder('Doctrine\\ORM\\EntityManager')->setMethods(array('find'))->disableOriginalConstructor()->getMock(); $em->expects($this->once())->method('find')->with('OroWorkflowBundle:WorkflowDefinition', 'test_workflow')->will($this->returnValue(null)); $this->subscriber->prePersist(new LifecycleEventArgs($entity, $em)); }
/** * @param array $inputOptions * @param array $expectedOptions * @dataProvider setDefaultOptionsDataProvider */ public function testSetDefaultOptions(array $inputOptions, array $expectedOptions) { $testWorkflowDefinition = new WorkflowDefinition(); $testWorkflowDefinition->setName(self::TEST_WORKFLOW_NAME)->setLabel(self::TEST_WORKFLOW_LABEL); $repository = $this->getMockBuilder('Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock(); $repository->expects($this->any())->method('findBy')->with(array('relatedEntity' => self::TEST_ENTITY_CLASS))->will($this->returnValue(array($testWorkflowDefinition))); $this->registry->expects($this->any())->method('getRepository')->with('OroWorkflowBundle:WorkflowDefinition')->will($this->returnValue($repository)); $form = $this->factory->create($this->type, null, $inputOptions); $actualOptions = $form->getConfig()->getOptions(); foreach ($expectedOptions as $name => $expectedValue) { $this->assertArrayHasKey($name, $actualOptions); $this->assertEquals($expectedValue, $actualOptions[$name]); } }
/** * @param string $workflowName * @param array $attributes * @param array $steps * @param string|null $relatedEntity * @return Workflow */ protected function createWorkflow($workflowName, array $attributes = array(), array $steps = array(), $relatedEntity = null) { $entityConnector = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Model\\EntityConnector')->disableOriginalConstructor()->getMock(); $aclManager = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Acl\\AclManager')->disableOriginalConstructor()->getMock(); $workflow = new Workflow($entityConnector, $aclManager); $workflow->setName($workflowName); foreach ($attributes as $name => $attribute) { $workflow->getAttributeManager()->getAttributes()->set($name, $attribute); } $workflow->getStepManager()->setSteps($steps); $definition = new WorkflowDefinition(); $definition->setRelatedEntity($relatedEntity); $workflow->setDefinition($definition); return $workflow; }
/** * @param array $configurationData * @return WorkflowDefinition[] */ public function buildFromConfiguration($configurationData) { $workflowDefinitions = array(); foreach ($configurationData as $workflowName => $workflowConfiguration) { $this->assertConfigurationOptions($workflowConfiguration, array('label', 'type')); $type = $this->getConfigurationOption($workflowConfiguration, 'type', Workflow::TYPE_ENTITY); $enabled = $this->getConfigurationOption($workflowConfiguration, 'enabled', true); $startStep = $this->getConfigurationOption($workflowConfiguration, 'start_step', null); $managedEntityClasses = $this->getManagedEntityClasses($workflowConfiguration); $definitionEntities = $this->buildDefinitionEntities($managedEntityClasses); $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($workflowName)->setLabel($workflowConfiguration['label'])->setType($type)->setEnabled($enabled)->setStartStep($startStep)->setConfiguration($workflowConfiguration)->setWorkflowDefinitionEntities($definitionEntities); $workflowDefinitions[] = $workflowDefinition; } return $workflowDefinitions; }
public function testBuildFromRawConfiguration() { $rawConfiguration = array('name' => 'test_workflow'); $handledConfiguration = array('name' => 'test_workflow', 'label' => 'Test Workflow'); $processedConfiguration = array('name' => 'test_workflow', 'label' => 'Test Workflow', 'is_system' => false); $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($processedConfiguration['name']); $handler = $this->getMock('Oro\\Bundle\\WorkflowBundle\\Configuration\\Handler\\ConfigurationHandlerInterface'); $handler->expects($this->once())->method('handle')->with($rawConfiguration)->will($this->returnValue($handledConfiguration)); $configuration = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Configuration\\WorkflowConfiguration')->disableOriginalConstructor()->getMock(); $configuration->expects($this->once())->method('processConfiguration')->with($handledConfiguration)->will($this->returnValue($processedConfiguration)); $configurationBuilder = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Configuration\\WorkflowDefinitionConfigurationBuilder')->disableOriginalConstructor()->getMock(); $configurationBuilder->expects($this->once())->method('buildOneFromConfiguration')->with($processedConfiguration['name'], $processedConfiguration)->will($this->returnValue($workflowDefinition)); $handleBuilder = new WorkflowDefinitionHandleBuilder($handler, $configuration, $configurationBuilder); $this->assertEquals($workflowDefinition, $handleBuilder->buildFromRawConfiguration($rawConfiguration)); }
/** * @expectedException \Oro\Bundle\WorkflowBundle\Exception\WorkflowException * @expectedExceptionMessage Value of attribute "attribute" must be an object */ public function testUpdateAclIdentitiesNotAnObjectException() { $workflowName = 'test_workflow'; $step = new WorkflowStep(); $step->setName('step'); $attribute = new Attribute(); $attribute->setName('attribute')->setOption('class', 'TestEntity'); $entityAcl = new WorkflowEntityAcl(); $entityAcl->setStep($step)->setAttribute($attribute->getName()); $definition = new WorkflowDefinition(); $definition->setName($workflowName)->setSteps(array($step))->setEntityAcls(array($entityAcl)); $this->setWorkflow($workflowName, array($attribute)); $workflowItem = new WorkflowItem(); $workflowItem->setWorkflowName($workflowName)->setDefinition($definition)->setCurrentStep($step); $workflowItem->getData()->set($attribute->getName(), 'not_an_object'); $this->manager->updateAclIdentities($workflowItem); }
/** * @param WorkflowDefinition $definition * @param string $name * @param array $options * @return Attribute */ protected function assembleAttribute(WorkflowDefinition $definition, $name, array $options) { if (!empty($options['property_path'])) { $options = $this->guessOptions($options, $definition->getRelatedEntity(), $options['property_path']); } $this->assertOptions($options, array('label', 'type')); $this->assertAttributeEntityAcl($options); $attribute = new Attribute(); $attribute->setName($name); $attribute->setLabel($options['label']); $attribute->setType($options['type']); $attribute->setEntityAcl($this->getOption($options, 'entity_acl', array())); $attribute->setPropertyPath($this->getOption($options, 'property_path')); $attribute->setOptions($this->getOption($options, 'options', array())); $this->validateAttribute($attribute); return $attribute; }
public function testGetWorkflowsByEntityClass() { $entityClass = '\\stdClass'; $workflowName = 'test_workflow'; $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($workflowName); /** @var Workflow $workflow */ $workflow = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Model\\Workflow')->disableOriginalConstructor()->getMock(); $workflowDefinitionRepository = $this->createWorkflowDefinitionRepositoryMock(); $workflowDefinitionRepository->expects($this->once())->method('findByEntityClass')->with($entityClass)->will($this->returnValue(array($workflowDefinition))); $managerRegistry = $this->createManagerRegistryMock($workflowDefinitionRepository); $workflowAssembler = $this->createWorkflowAssemblerMock($workflowDefinition, $workflow); $workflowRegistry = new WorkflowRegistry($managerRegistry, $workflowAssembler); $expectedWorkflows = array($workflowName => $workflow); $actualWorkflows = $workflowRegistry->getWorkflowsByEntityClass($entityClass); $this->assertEquals($expectedWorkflows, $actualWorkflows); }
/** * @param WorkflowDefinition $definition * @return array */ protected function getDataAsArray(WorkflowDefinition $definition) { $data = array('name' => $definition->getName(), 'label' => $definition->getLabel(), 'entity' => $definition->getRelatedEntity(), 'configuration' => $definition->getConfiguration()); if ($definition->getStartStep()) { $data['start_step'] = $definition->getStartStep()->getName(); } return $data; }
/** * @param WorkflowDefinition $definition * @return array */ protected function getDataAsArray(WorkflowDefinition $definition) { $entitiesData = array(); foreach ($definition->getWorkflowDefinitionEntities() as $entity) { $entitiesData[] = array('class' => $entity->getClassName()); } return array('name' => $definition->getName(), 'label' => $definition->getLabel(), 'enabled' => $definition->isEnabled(), 'start_step' => $definition->getStartStep(), 'configuration' => $definition->getConfiguration(), 'entities' => $entitiesData); }
public function testImport() { $step = new WorkflowStep(); $step->setName('step'); $definition = new WorkflowDefinition(); $definition->addStep($step); $this->entityAcl->setAttribute('attribute'); $this->entityAcl->setStep($step); $this->entityAcl->setEntityClass('TestEntity'); $this->entityAcl->setUpdatable(false); $this->entityAcl->setDeletable(false); $newEntityAcl = new WorkflowEntityAcl(); $newEntityAcl->setDefinition($definition); $this->assertEquals($newEntityAcl, $newEntityAcl->import($this->entityAcl)); $this->assertEquals('attribute', $newEntityAcl->getAttribute()); $this->assertEquals($step, $newEntityAcl->getStep()); $this->assertEquals('TestEntity', $newEntityAcl->getEntityClass()); $this->assertFalse($this->entityAcl->isUpdatable()); $this->assertFalse($this->entityAcl->isDeletable()); $this->assertEquals($this->entityAcl->getAttributeStepKey(), $newEntityAcl->getAttributeStepKey()); }
protected function generateEntities(ObjectManager $manager, WorkflowDefinition $definition) { // load entities /** @var WorkflowAwareEntity[] $entities */ $entities = array(); for ($i = 1; $i <= self::COUNT; $i++) { $entity = new WorkflowAwareEntity(); $entity->setName($definition->getName() . '_entity_' . $i); $entities[] = $entity; $manager->persist($entity); } $manager->flush(); // create workflow item manually (to make it faster) foreach ($entities as $entity) { $workflowItem = new WorkflowItem(); $workflowItem->setDefinition($definition)->setWorkflowName($definition->getName())->setEntity($entity)->setEntityId($entity->getId())->setCurrentStep($definition->getSteps()->first()); $manager->persist($workflowItem); $entity->setWorkflowItem($workflowItem)->setWorkflowStep($workflowItem->getCurrentStep()); } $manager->flush(); }
/** * @param WorkflowDefinition $workflowDefinition * @param Workflow $workflow */ protected function setEntityAcls(WorkflowDefinition $workflowDefinition, Workflow $workflow) { $entityAcls = array(); foreach ($workflow->getAttributeManager()->getEntityAttributes() as $attribute) { foreach ($workflow->getStepManager()->getSteps() as $step) { $updatable = $attribute->isEntityUpdateAllowed() && $step->isEntityUpdateAllowed($attribute->getName()); $deletable = $attribute->isEntityDeleteAllowed() && $step->isEntityDeleteAllowed($attribute->getName()); if (!$updatable || !$deletable) { $entityAcl = new WorkflowEntityAcl(); $entityAcl->setAttribute($attribute->getName())->setStep($workflowDefinition->getStepByName($step->getName()))->setEntityClass($attribute->getOption('class'))->setUpdatable($updatable)->setDeletable($deletable); $entityAcls[] = $entityAcl; } } } $workflowDefinition->setEntityAcls($entityAcls); }
/** * @param WorkflowDefinition $workflowDefinition */ public function resetWorkflowData(WorkflowDefinition $workflowDefinition) { $this->getWorkflowItemRepository()->resetWorkflowData($workflowDefinition->getRelatedEntity(), array($workflowDefinition->getName())); }
/** * @param WorkflowDefinition $workflowDefinition * @param array $configuration * @return array */ protected function prepareDefaultStartTransition(WorkflowDefinition $workflowDefinition, array $configuration) { if ($workflowDefinition->getStartStep() && !array_key_exists(TransitionManager::DEFAULT_START_TRANSITION_NAME, $configuration[WorkflowConfiguration::NODE_TRANSITIONS])) { $startTransitionDefinitionName = TransitionManager::DEFAULT_START_TRANSITION_NAME . '_definition'; if (!array_key_exists($startTransitionDefinitionName, $configuration[WorkflowConfiguration::NODE_TRANSITION_DEFINITIONS])) { $configuration[WorkflowConfiguration::NODE_TRANSITION_DEFINITIONS][$startTransitionDefinitionName] = array(); } $label = $this->translator->trans('oro.workflow.transition.start', array('%workflow%' => $workflowDefinition->getLabel())); $configuration[WorkflowConfiguration::NODE_TRANSITIONS][TransitionManager::DEFAULT_START_TRANSITION_NAME] = array('label' => $label, 'step_to' => $workflowDefinition->getStartStep()->getName(), 'is_start' => true, 'is_hidden' => true, 'is_unavailable_hidden' => true, 'transition_definition' => $startTransitionDefinitionName); } return $configuration; }
/** * @param WorkflowDefinition $definition * @return array */ protected function getDefinitionAsArray(WorkflowDefinition $definition) { return array('name' => $definition->getName(), 'label' => $definition->getLabel(), 'steps' => $definition->getSteps(), 'start_step' => $definition->getStartStep(), 'configuration' => $definition->getConfiguration()); }
protected function prepareDefaultStartTransition(WorkflowDefinition $workflowDefinition, $configuration) { if ($workflowDefinition->getStartStep()) { $startTransitionDefinitionName = Workflow::DEFAULT_START_TRANSITION_NAME . '_definition'; if (!array_key_exists($startTransitionDefinitionName, $configuration[WorkflowConfiguration::NODE_TRANSITION_DEFINITIONS])) { $configuration[WorkflowConfiguration::NODE_TRANSITION_DEFINITIONS][$startTransitionDefinitionName] = array(); } if (!array_key_exists(Workflow::DEFAULT_START_TRANSITION_NAME, $configuration[WorkflowConfiguration::NODE_TRANSITIONS])) { $configuration[WorkflowConfiguration::NODE_TRANSITIONS][Workflow::DEFAULT_START_TRANSITION_NAME] = array('label' => $workflowDefinition->getLabel(), 'step_to' => $workflowDefinition->getStartStep(), 'is_start' => true, 'transition_definition' => $startTransitionDefinitionName); } } return $configuration; }
public function testSetWorkflowDefinitionEntities() { $firstEntity = new WorkflowDefinitionEntity(); $firstEntity->setClassName('FirstClass'); $secondEntity = new WorkflowDefinitionEntity(); $secondEntity->setClassName('SecondClass'); $secondEntitySameClass = new WorkflowDefinitionEntity(); $secondEntitySameClass->setClassName('SecondClass'); $thirdEntity = new WorkflowDefinitionEntity(); $thirdEntity->setClassName('ThirdClass'); $newDefinition = new WorkflowDefinition(); $newDefinition->setWorkflowDefinitionEntities(array($firstEntity, $secondEntity)); $this->assertEquals(array($firstEntity, $secondEntity), array_values($newDefinition->getWorkflowDefinitionEntities()->toArray())); $newDefinition->setWorkflowDefinitionEntities(array($secondEntitySameClass, $thirdEntity)); $this->assertEquals(array($secondEntity, $thirdEntity), array_values($newDefinition->getWorkflowDefinitionEntities()->toArray())); }
public function testResetWorkflowData() { $name = 'testWorkflow'; $entityClass = 'Test:Entity'; $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($name)->setRelatedEntity($entityClass); $workflowItemsRepository = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Entity\\Repository\\WorkflowItemRepository')->disableOriginalConstructor()->setMethods(array('resetWorkflowData'))->getMock(); $workflowItemsRepository->expects($this->once())->method('resetWorkflowData')->with($entityClass, array($name)); $this->registry->expects($this->once())->method('getRepository')->with('OroWorkflowBundle:WorkflowItem')->will($this->returnValue($workflowItemsRepository)); $this->workflowManager->resetWorkflowData($workflowDefinition); }
/** * @param WorkflowDefinition $workflowDefinition * @return WorkflowConfiguration */ protected function createConfigurationTreeMock(WorkflowDefinition $workflowDefinition) { $configurationTree = $this->getMockBuilder('Oro\\Bundle\\WorkflowBundle\\Configuration\\WorkflowConfiguration')->disableOriginalConstructor()->setMethods(array('processConfiguration'))->getMock(); $configurationTree->expects($this->once())->method('processConfiguration')->with($workflowDefinition->getConfiguration())->will($this->returnValue($workflowDefinition->getConfiguration())); return $configurationTree; }
/** * @param WorkflowDefinition $definition * @return $this */ public function import(WorkflowDefinition $definition) { $this->setName($definition->getName())->setType($definition->getType())->setLabel($definition->getLabel())->setEnabled($definition->isEnabled())->setConfiguration($definition->getConfiguration())->setStartStep($definition->getStartStep())->setWorkflowDefinitionEntities($definition->getWorkflowDefinitionEntities()); return $this; }
/** * Delete workflow definition * * Returns * - HTTP_NO_CONTENT (204) * - HTTP_FORBIDDEN (403) * * @Rest\Delete( * "/api/rest/{version}/workflowdefinition/{workflowDefinition}", * defaults={"version"="latest", "_format"="json"} * ) * @ApiDoc(description="Delete workflow definition") * @Acl( * id="oro_workflow_definition_delete", * type="entity", * class="OroWorkflowBundle:WorkflowDefinition", * permission="DELETE" * ) * * @param WorkflowDefinition $workflowDefinition * @return Response */ public function deleteAction(WorkflowDefinition $workflowDefinition) { if ($workflowDefinition->isSystem()) { return $this->handleView($this->view(null, Codes::HTTP_FORBIDDEN)); } else { $entityManager = $this->getEntityManager(); $entityManager->remove($workflowDefinition); $entityManager->flush(); return $this->handleView($this->view(null, Codes::HTTP_NO_CONTENT)); } }
public function testGetActiveWorkflowByEntityClassNoWorkflow() { $entityClass = '\\stdClass'; $workflowName = 'test_workflow'; $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($workflowName); $workflowDefinitionRepository = $this->createWorkflowDefinitionRepositoryMock(); $workflowDefinitionRepository->expects($this->once())->method('find')->with($workflowName)->will($this->returnValue(null)); $managerRegistry = $this->createManagerRegistryMock($workflowDefinitionRepository); $workflowAssembler = $this->createWorkflowAssemblerMock(); $configProvider = $this->createConfigurationProviderMock(); $configProvider->expects($this->any())->method('hasConfig')->with($entityClass)->will($this->returnValue(true)); $config = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->getMock(); $config->expects($this->any())->method('get')->with('active_workflow')->will($this->returnValue($workflowName)); $configProvider->expects($this->any())->method('getConfig')->with($entityClass)->will($this->returnValue($config)); $workflowRegistry = new WorkflowRegistry($managerRegistry, $workflowAssembler, $configProvider); $this->assertNull($workflowRegistry->getActiveWorkflowByEntityClass($entityClass)); }
/** * @param WorkflowDefinition $definition * @return WorkflowDefinition */ public function import(WorkflowDefinition $definition) { $this->setName($definition->getName())->setLabel($definition->getLabel())->setRelatedEntity($definition->getRelatedEntity())->setEntityAttributeName($definition->getEntityAttributeName())->setConfiguration($definition->getConfiguration())->setSteps($definition->getSteps())->setStartStep($definition->getStartStep())->setStepsDisplayOrdered($definition->isStepsDisplayOrdered())->setEntityAcls($definition->getEntityAcls())->setSystem($definition->isSystem()); return $this; }
/** * @Route( * "/clone/{name}", * name="oro_workflow_definition_clone" * ) * @AclAncestor("oro_workflow_definition_create") * @Template("OroWorkflowBundle:WorkflowDefinition:update.html.twig") * * @param WorkflowDefinition $workflowDefinition * @return array */ public function cloneAction(WorkflowDefinition $workflowDefinition) { /** @var TranslatorInterface $translator */ $translator = $this->get('translator'); $clonePrefix = $translator->trans('oro.workflow.workflowdefinition.clone_label_prefix'); $clonedDefinition = new WorkflowDefinition(); $clonedDefinition->import($workflowDefinition)->setName($workflowDefinition->getName() . uniqid('_clone_'))->setLabel($clonePrefix . $workflowDefinition->getLabel())->setSystem(false); $response = $this->updateAction($clonedDefinition); $response['delete_allowed'] = false; return $response; }
/** * @param array $configuration * @return WorkflowDefinition */ protected function createWorkflowDefinition(array $configuration) { $workflowDefinition = new WorkflowDefinition(); $workflowDefinition->setName($this->workflowParameters['name'])->setLabel($this->workflowParameters['label'])->setConfiguration($configuration); return $workflowDefinition; }