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;
}