Assert that the class implements the interface
/**
* @param mixed $value
*/
protected function setValue($value)
{
//We use the string assertion first
parent::setValue($value);
//and then check, if we really got an item class
Assertion::implementsInterface($value, 'Prooph\\Processing\\Type\\Type');
}
public function create($data)
{
if (!array_key_exists("collect_data_trigger", $data)) {
return new ApiProblemResponse(new ApiProblem(422, 'Root key collect_data_trigger missing in request data'));
}
$data = $data["collect_data_trigger"];
if (!array_key_exists('processing_type', $data)) {
return new ApiProblemResponse(new ApiProblem(422, 'Key processing_type is missing'));
}
$processingType = $data['processing_type'];
if (!class_exists($processingType)) {
return new ApiProblemResponse(new ApiProblem(422, 'Provided processing type is unknown'));
}
try {
Assertion::implementsInterface($processingType, 'Prooph\\Processing\\Type\\Type');
} catch (\InvalidArgumentException $ex) {
return new ApiProblemResponse(new ApiProblem(422, 'Provided processing type is not valid'));
}
$wfMessage = WorkflowMessage::collectDataOf($processingType::prototype(), __CLASS__, $this->ProcessingConfig->getNodeName());
$this->messageLogger->logIncomingMessage($wfMessage);
$this->workflowEngine->dispatch($wfMessage);
/** @var $response Response */
$response = $this->getResponse();
$response->getHeaders()->addHeaderLine('Location', $this->url()->fromRoute('prooph.link/processor_proxy/api/messages', ['id' => $wfMessage->uuid()->toString()]));
$response->setStatusCode(201);
return $response;
}
/**
* Create a new value object
* @param array $value
*/
public function __construct($value)
{
Assertion::isArray($value);
foreach ($value as $object) {
Assertion::implementsInterface($object, EventInterface::class);
}
$this->value = SplFixedArray::fromArray($value);
}
private function createContainer()
{
$container = new ContainerBuilder();
// retrieve security class
$values = \Parameters::get('security');
$class = $values['security']['classes'];
$session_name = $values['session']['name'];
// test if class exist and implement interface
try {
Assertion::ClassExists($class);
Assertion::implementsInterface($class, '\\GL\\Core\\Security\\AuthenticationServiceInterface');
} catch (AssertionFailedException $e) {
echo $e->getMessage();
die;
}
// Inject mailer
$container->register('mailer', 'GL\\Core\\Tools\\Mailer');
// Inject Request
$container->register('request', 'Symfony\\Component\\HttpFoundation\\Request')->setFactory("Symfony\\Component\\HttpFoundation\\Request::createFromGlobals");
// Inject Request helper
$container->register('request_helper', 'GL\\Core\\Helpers\\RequestHelper')->addMethodCall('setRequest', array(new Reference('request')));
// Inject Twig Service
$container->register('template', 'GL\\Core\\Templating\\TemplateProvider');
// Inject RouteCollection
$container->register('routes', 'Symfony\\Component\\Routing\\RouteCollection')->setFactory("GL\\Core\\Routing\\RouteProvider::GetRouteCollection");
if (class_exists("\\PHPExcel")) {
// Inject PHPExcel Wrapper
$container->register('excel', 'GL\\Core\\Tools\\Excel');
}
if (class_exists("\\TCPDF")) {
// Inject FPDF Wrapper
$container->register('pdf', 'GL\\Core\\Tools\\PDF');
}
// Inject Session
$container->register('session', 'Symfony\\Component\\HttpFoundation\\Session\\Session')->addMethodCall('setName', array($session_name))->addMethodCall('start');
// Inject Crsf verifier
$container->register('crsf', 'GL\\Core\\Security\\FormCrsf')->addArgument(new Reference('session'))->addArgument(new Reference('request'));
// Inject translator service
$container->register('translator', 'GL\\Core\\Config\\Translator');
// Inject Security Service
$container->register('security', $class)->addArgument(new Reference('session'))->addArgument(new Reference('request'))->addMethodCall('autologin');
// Inject DebugBar
$container->register('debug', 'GL\\Core\\Debug\\KLDebugBar');
// Inject Pdo Object
$container->register('pdo', 'PDO')->setFactory("GL\\Core\\Helpers\\DbHelper::getPdo");
// Inject Config
$container->register('config', 'GL\\Core\\Config\\Config');
// Inject DbHelper
$container->register('db', 'GL\\Core\\Helpers\\DbHelper');
// Inject Redis
$container->register('redis', 'GL\\Core\\Tools\\Redis');
// Inject services defined in config/services.yml
$loader = new YamlFileLoader($container, new FileLocator(SERVICEPATH));
$loader->load('services.yml');
$container->compile();
return $container;
}
/**
* @param string $relatedTypeClass
* @param Description $descriptionOfType
* @param PrototypeProperty[] $typeProperties
*/
public function __construct($relatedTypeClass, Description $descriptionOfType, array $typeProperties)
{
Assertion::implementsInterface($relatedTypeClass, 'Prooph\\Processing\\Type\\Type');
foreach ($typeProperties as $propertyOfType) {
Assertion::isInstanceOf($propertyOfType, 'Prooph\\Processing\\Type\\PrototypeProperty');
}
$this->relatedTypeClass = $relatedTypeClass;
$this->descriptionOfType = $descriptionOfType;
$this->typeProperties = $typeProperties;
PrototypeRegistry::registerPrototype($this);
}
/**
* @param string $workflowId
* @param array $startMessage
* @param string $firstMessageHandlerId
* @return ScheduleFirstTasksForWorkflow
*/
public static function withData($workflowId, $startMessage, $firstMessageHandlerId)
{
Assertion::uuid($workflowId);
Assertion::uuid($firstMessageHandlerId);
Assertion::isArray($startMessage);
Assertion::keyExists($startMessage, 'message_type');
Assertion::keyExists($startMessage, 'processing_type');
$processingType = $startMessage['processing_type'];
Assertion::implementsInterface($processingType, Type::class);
return new self(__CLASS__, ['workflow_id' => $workflowId, 'start_message' => $startMessage, 'first_message_handler' => $firstMessageHandlerId]);
}
/**
* Supported processing types can be given as processing prototypes or a list of type classes
*
* @param Prototype[]|array $processingTypes
* @return ProcessingTypes
*/
public static function support(array $processingTypes)
{
$prototypes = [];
foreach ($processingTypes as $typeClassOrPrototype) {
if ($typeClassOrPrototype instanceof Prototype) {
$prototypes[] = $typeClassOrPrototype;
} else {
Assertion::string($typeClassOrPrototype);
Assertion::classExists($typeClassOrPrototype);
Assertion::implementsInterface($typeClassOrPrototype, Type::class);
$prototypes[] = $typeClassOrPrototype::prototype();
}
}
return new self($prototypes, false);
}
private function __construct($target, array $allowedTypes, $preferredType = null, array $metadata)
{
Assertion::notEmpty($target);
Assertion::string($target);
Assertion::notEmpty($allowedTypes);
$this->assertMetadata($metadata);
foreach ($allowedTypes as $allowedType) {
Assertion::classExists($allowedType);
Assertion::implementsInterface($allowedType, 'Prooph\\Processing\\Type\\Type');
}
if (!is_null($preferredType)) {
Assertion::inArray($preferredType, $allowedTypes);
}
$this->target = $target;
$this->allowedTypes = $allowedTypes;
$this->preferredType = $preferredType;
$this->metadata = $metadata;
}
/**
* @param string $messageHandlerId
* @param string $name
* @param string $nodeName
* @param string $handlerType
* @param string $dataDirection
* @param array|string $supportedProcessingTypes
* @param array $processingMetadata
* @param string $metadataRiotTag
* @param string $icon
* @param string $iconType
* @param null|string $preferredProcessingType
* @param null|string $handlerProcessingId
* @param array $additionalData
* @return InstallMessageHandler
*/
public static function withData($messageHandlerId, $name, $nodeName, $handlerType, $dataDirection, $supportedProcessingTypes, array $processingMetadata, $metadataRiotTag, $icon, $iconType, $preferredProcessingType = null, $handlerProcessingId = null, array $additionalData = [])
{
Assertion::uuid($messageHandlerId);
Assertion::string($name);
Assertion::notEmpty($name);
Assertion::string($nodeName);
Assertion::notEmpty($nodeName);
Assertion::string($handlerType);
Assertion::string($dataDirection);
Assertion::string($metadataRiotTag);
Assertion::string($icon);
Assertion::string($iconType);
if (!is_null($preferredProcessingType)) {
Assertion::string($preferredProcessingType);
Assertion::implementsInterface($preferredProcessingType, Type::class);
}
if (!is_null($handlerProcessingId)) {
Assertion::string($handlerProcessingId);
}
if (!is_string($supportedProcessingTypes)) {
Assertion::isArray($supportedProcessingTypes);
}
return new self(__CLASS__, ['message_handler_id' => $messageHandlerId, 'name' => $name, 'node_name' => $nodeName, 'handler_type' => $handlerType, 'data_direction' => $dataDirection, 'supported_processing_types' => $supportedProcessingTypes, 'processing_metadata' => $processingMetadata, 'metadata_riot_tag' => $metadataRiotTag, 'icon' => $icon, 'icon_type' => $iconType, 'preferred_processing_type' => $preferredProcessingType, 'handler_processing_id' => $handlerProcessingId, 'additional_data' => $additionalData]);
}
public function testImplementsInterfaceWithClassObject()
{
$class = new \ArrayObject();
Assertion::implementsInterface($class, '\\Traversable');
$this->setExpectedException('Assert\\AssertionFailedException', null, Assertion::INTERFACE_NOT_IMPLEMENTED);
Assertion::implementsInterface($class, '\\SplObserver');
}
private function collectDataFromMultipleFiles($fileNames, WorkflowMessage $workflowMessage, FileTypeAdapter $fileHandler)
{
$metadata = $workflowMessage->metadata();
$fileDataType = isset($metadata[self::META_FILE_DATA_TYPE]) ? $metadata[self::META_FILE_DATA_TYPE] : $workflowMessage->payload()->getTypeClass();
Assertion::implementsInterface($fileDataType, 'Prooph\\Processing\\Type\\Type');
$fileDataPrototype = $fileDataType::prototype();
$fileDataCollection = [];
$collectedData = null;
$typeClass = $workflowMessage->payload()->getTypeClass();
foreach ($fileNames as $filename) {
$fileDataCollection[] = $fileHandler->readDataForType($filename, $fileDataPrototype, $metadata);
}
if (isset($metadata[self::META_MERGE_FILES]) && $metadata[self::META_MERGE_FILES]) {
$mergedFileData = [];
foreach ($fileDataCollection as $fileData) {
if (!is_array($fileData)) {
$fileData = [$fileData];
}
$mergedFileData = ArrayUtils::merge($mergedFileData, $fileData);
}
$collectedData = $typeClass::fromNativeValue($mergedFileData);
} else {
if ($typeClass::prototype()->typeDescription()->nativeType() !== NativeType::COLLECTION) {
throw new \InvalidArgumentException(sprintf("Filename pattern %s matches multiple files but the requested processing type %s is not a collection.", $metadata['filename_pattern'], $typeClass));
}
$metadata[self::META_TOTAL_ITEMS] = count($fileDataCollection);
$collectedData = $typeClass::fromNativeValue($fileDataCollection);
}
return $workflowMessage->answerWith($collectedData, $metadata);
}
/**
* @param Column $column
* @return string
* @throws \RuntimeException
*/
private function doctrineColumnToProcessingType(Column $column)
{
if (!isset($this->doctrineProcessingTypeMap[$column->getType()->getName()])) {
throw new \RuntimeException(sprintf("No processing type mapping for doctrine type %s", $column->getType()->getName()));
}
$processingType = $this->doctrineProcessingTypeMap[$column->getType()->getName()];
if (!$column->getNotnull() || $column->getAutoincrement()) {
$processingType .= "OrNull";
if (!class_exists($processingType)) {
throw new \RuntimeException("Missing null type: for nullable column: " . $column->getName());
}
}
Assertion::implementsInterface($processingType, 'Prooph\\Processing\\Type\\Type');
return $processingType;
}
private function run($instance, $type = "up")
{
// test if class exist and implement interface
try {
$class = get_class($instance);
Assertion::ClassExists($class);
Assertion::implementsInterface($class, '\\GL\\Core\\Migration\\MigrationInterface');
$max = 0;
// get all migrations in db
$migrations = MigrationModel::all();
// find max batch id version
if (count($migrations) > 0) {
$max = $migrations->max('db_version');
}
$batchid = $max + 1;
// retrieve className
$id = $instance->getUniqueTag();
// find if this instance was not executed
$exec = MigrationModel::where('migration', '=', $id)->first();
$bExec = true;
if ($exec != null) {
if ($exec->status == $type) {
// always executed
$bExec = false;
}
}
if ($bExec) {
$instance->{$type}();
// insert in db
if ($exec == null) {
$exec = new MigrationModel();
}
$exec->class = $class;
$exec->migration = $id;
$exec->status = $type;
$exec->db_version = $batchid;
$exec->save();
}
} catch (\Exception $ex) {
echo $ex;
} catch (AssertionFailedException $e) {
echo $e;
}
}
/**
* Function execute before action execute
* @param string $route actual route
* @return boolean
*/
public function executeBefores($route)
{
$ret = false;
$fnArray = \Functions::getAll();
if (isset($fnArray)) {
foreach ($fnArray as $key => $value) {
if ($value["type"] == "before") {
// for each global function defined
$arrRoutes = isset($value["routes"]) ? $value["routes"] : null;
$scope = isset($value["scope"]) ? $value["scope"] : "all";
$class = $value["class"];
// test if class exist and implements interface
Assertion::ClassExists($class);
Assertion::implementsInterface($class, '\\GL\\Core\\Controller\\BeforeFunctionInterface');
$bExecute = $this->IsAllowed($arrRoutes, $route, $scope);
if ($bExecute) {
$exc = new $class($this->_container);
$ret = $exc->execute();
}
}
}
}
return $ret;
}
/**
* @param string $newTypeClass
*/
public function changeTypeClass($newTypeClass)
{
Assertion::string($newTypeClass);
Assertion::implementsInterface($newTypeClass, 'Prooph\\Processing\\Type\\Type');
$this->typeClass = $newTypeClass;
if (is_null($this->data) && !is_null($this->type)) {
$this->data = $this->extractTypeData();
}
$this->type = null;
}
/**
* @param array $taskDefinition
* @return CollectData
*/
private function createCollectDataTaskFromDefinition(array $taskDefinition)
{
Assertion::keyExists($taskDefinition, "source");
Assertion::notEmpty($taskDefinition["source"]);
Assertion::string($taskDefinition["source"]);
Assertion::keyExists($taskDefinition, "processing_type");
Assertion::implementsInterface($taskDefinition["processing_type"], 'Prooph\\Processing\\Type\\Type');
$processingType = $taskDefinition["processing_type"];
$prototype = $processingType::prototype();
$metadata = isset($taskDefinition['metadata']) ? $taskDefinition['metadata'] : array();
return CollectData::from($taskDefinition["source"], $prototype, $metadata);
}