/**
* @param WorkflowDispatchEventInterface $value
*
* @return bool
*/
public function isValid($value)
{
if (!$value instanceof WorkflowDispatchEventInterface) {
$this->error(self::VALIDATE_VALUE_INVALID);
return false;
}
if (null === $this->getAllowedHttpMethods()) {
return true;
}
$request = $value->getMvcEvent()->getRequest();
if (!$request instanceof Request) {
$this->error(self::REQUEST_INVALID);
return false;
}
/** @var Request $request*/
$method = $request->getMethod();
$method = strtolower($method);
$allowedHttpMethods = $this->getAllowedHttpMethods();
if (!array_key_exists($method, $allowedHttpMethods)) {
$this->error(self::HTTP_METHOD_INVALID);
return false;
}
return true;
}
/**
* Проверка, на то нужно ли запускать workflow
*
* @param WorkflowDispatchEventInterface $e
*
* @return boolean|null
*
* @throws \Zend\Validator\Exception\InvalidArgumentException
* @throws Exception\PrepareDataException
*/
public function onCheckRunWorkflowHandler(WorkflowDispatchEventInterface $e)
{
$metadata = $e->getMetadata();
if (!$metadata->getFlagHasConditions()) {
return null;
}
try {
$conditions = $metadata->getConditions();
$validatorManager = $this->getValidatorManager();
/** @var ValidatorChain $validatorChains */
$validatorChains = $validatorManager->get(ValidatorChain::class);
} catch (\Exception $e) {
throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
}
$mvcEvent = $e->getMvcEvent();
$controller = $mvcEvent->getTarget();
if (!$controller instanceof AbstractController) {
$controller = null;
}
foreach ($conditions as $condition) {
try {
$type = $condition->getType();
$handler = $condition->getHandler();
switch ($type) {
case 'method':
if (null === $controller) {
$errMsg = 'Controller not specified';
throw new Exception\CheckRunWorkflowEventException($errMsg);
}
$callback = [$controller, $handler];
/** @var ValidatorInterface $callbackValidator */
$callbackValidator = $validatorManager->get('callback', $callback);
$validatorChains->attach($callbackValidator);
break;
case 'service':
$validatorParams = $condition->getParams();
/** @var ValidatorInterface $validator */
$validator = $validatorManager->get($handler, $validatorParams);
$validatorChains->attach($validator);
break;
default:
$errMsg = sprintf('Preparing data for Workflow will fail. Unknown handler type %s.', $type);
throw new Exception\PrepareDataException($errMsg);
}
} catch (\Exception $e) {
throw new Exception\PrepareDataException($e->getMessage(), $e->getCode(), $e);
}
}
return $validatorChains->isValid($e);
}
/**
* Получение метаданных для запуска workflow
*
* @param WorkflowDispatchEventInterface $e
*
* @return RunWorkflowParam|null
*
* @throws Exception\InvalidMetadataException
* @throws Exception\ResolveEntryIdEventException
* @throws Exception\InvalidWorkflowManagerAliasException
* @throws Exception\RuntimeException
*/
public function onMetadataWorkflowToRun(WorkflowDispatchEventInterface $e)
{
$mvcEvent = $e->getMvcEvent();
$controller = $mvcEvent->getTarget();
if (!$controller instanceof AbstractController) {
return null;
}
$routeMatch = $mvcEvent->getRouteMatch();
if (!$routeMatch) {
return null;
}
$action = $routeMatch->getParam('action', 'not-found');
$actionMethod = AbstractController::getMethodFromAction($action);
if (!method_exists($controller, $actionMethod)) {
return null;
}
$controllerClassName = get_class($controller);
$metadata = $this->getMetadataReader()->loadMetadataForAction($controllerClassName, $actionMethod);
if (!$metadata instanceof MetadataInterface) {
$errMsg = sprintf('Metadata not implement %s', MetadataInterface::class);
throw new Exception\InvalidMetadataException($errMsg);
}
$workflowManagerNameParam = $metadata->getWorkflowManagerNameRouterParam();
$workflowManagerNameFromRoute = $routeMatch->getParam($workflowManagerNameParam, null);
$workflowManagerAliasParam = $metadata->getWorkflowManagerAliasRouterParam();
$workflowManagerAlias = $routeMatch->getParam($workflowManagerAliasParam, null);
$workflowManagerName = $workflowManagerNameFromRoute;
if (null !== $workflowManagerAlias) {
$workflowService = $this->getWorkflowService();
if (!$workflowService->hasWorkflowManagerAlias($workflowManagerAlias)) {
$errMsg = sprintf('Invalid workflow manager alias: %s', $workflowManagerAlias);
throw new Exception\InvalidWorkflowManagerAliasException($errMsg);
}
$workflowManagerNameByAlias = $workflowService->getManagerNameByAlias($workflowManagerAlias);
if (null !== $workflowManagerNameFromRoute && $workflowManagerNameFromRoute !== $workflowManagerNameByAlias) {
$errMsg = sprintf('Name collision workflow manager.The name of the alias: %s. The name of the router: %s', $workflowManagerNameByAlias, $workflowManagerNameFromRoute);
throw new Exception\RuntimeException($errMsg);
}
$workflowManagerName = $workflowManagerNameByAlias;
}
$workflowActionNameParam = $metadata->getWorkflowActionNameRouterParam();
$workflowActionName = $routeMatch->getParam($workflowActionNameParam, null);
if (null === $workflowManagerName || null === $workflowActionName) {
$this->getLog()->debug('Metadata Workflow to start not found', ['workflowManagerNameFromRoute' => $workflowManagerNameFromRoute, 'workflowManagerAlias' => $workflowManagerAlias, 'workflowManagerName' => $workflowManagerName, 'workflowActionName' => $workflowActionName]);
return null;
}
$runType = $e->getMetadata()->getWorkflowRunType();
$workflowNameParam = $metadata->getWorkflowNameRouterParam();
$workflowName = $routeMatch->getParam($workflowNameParam, null);
$runWorkflowParam = new RunWorkflowParam();
$runWorkflowParam->setRunType($runType);
$runWorkflowParam->setManagerName($workflowManagerName);
$runWorkflowParam->setActionName($workflowActionName);
if (RunWorkflowParam::WORKFLOW_RUN_INITIALIZE === $runType && null !== $workflowName) {
$runWorkflowParam->setWorkflowName($workflowName);
return $runWorkflowParam;
}
if (RunWorkflowParam::WORKFLOW_RUN_TYPE_DO_ACTION === $runType) {
$event = $this->resolveEntryIdEventFactory();
$event->setWorkflowDispatchEvent($e);
$event->setRunType($runType);
$event->setActionName($workflowActionName);
$event->setManagerName($workflowManagerName);
$event->setWorkflowName($workflowName);
$event->setManagerAlias($workflowManagerAlias);
$resolveEntryIdResults = $this->getEventManager()->trigger(ResolveEntryIdEventInterface::RESOLVE_ENTRY_ID_EVENT, $event, function ($item) {
return is_numeric($item);
});
$resolveEntryIdResult = $resolveEntryIdResults->last();
if (is_numeric($resolveEntryIdResult)) {
$runWorkflowParam->setEntryId($resolveEntryIdResult);
return $runWorkflowParam;
}
}
return null;
}
