public static function create() { $id = DocumentId::generate(); $document = new self($id); $document->recordThat(new DocumentCreated($id)); return $document; }
public static function write(PostId $id, PostContent $content, $author = '') { $post = new self(); $post->id = $id; $post->recordThat(new Events\NewPostWasWritten($id->getId(), $content->getTitle(), $content->getBody(), $author)); return $post; }
/** * @param UserId $userId * @param string $name * @param EmailAddress $emailAddress * @return User */ public static function registerWithData(UserId $userId, $name, EmailAddress $emailAddress) { $self = new self(); $self->assertName($name); $self->recordThat(UserWasRegistered::withData($userId, $name, $emailAddress)); return $self; }
public static function nameNew($name) { $id = Uuid::uuid4()->toString(); $instance = new self(); $instance->recordThat(UserCreated::occur($id, ['id' => $id, 'name' => $name])); return $instance; }
/** * @param string $text * @param UserId $assigneeId * @param TodoId $todoId * @return Todo */ public static function post($text, UserId $assigneeId, TodoId $todoId) { $self = new self(); $self->assertText($text); $self->recordThat(TodoWasPosted::byUser($assigneeId, $text, $todoId, TodoStatus::open())); return $self; }
public static function register($name) { $id = PersonId::generate(); $person = new self($id, $name); $person->recordThat(new PersonRegistered($id, $name)); return $person; }
public static function create($description) { $id = TaskId::generate(); $task = new self($id, $description); $task->recordThat(new TaskCreatedEvent($id, $description)); return $task; }
public static function create($name) { $id = MenuId::generate(); $name = MenuName::fromString($name); $menu = new self($id); $menu->recordThat(new MenuCreated($id, $name)); return $menu; }
/** * @param SqliteDbFile $sqliteDbFile * @param ConfigLocation $configLocation * @param ConfigWriter $configWriter * @return EventStoreConfig */ public static function initializeWithSqliteDb(SqliteDbFile $sqliteDbFile, ConfigLocation $configLocation, ConfigWriter $configWriter) { $config = ['proophessor' => ['event_store' => ['adapter' => ['type' => 'Prooph\\EventStore\\Adapter\\Doctrine\\DoctrineEventStoreAdapter', 'options' => ['connection' => ['driver' => 'pdo_sqlite', 'path' => $sqliteDbFile->toString()], 'serializer_adapter' => 'json']]]]]; $instance = new self($config, $configLocation); $configWriter->writeNewConfigToDirectory($config, $configLocation->toString() . DIRECTORY_SEPARATOR . $instance->configFileName()); $instance->recordThat(EventStoreWasInitialized::withSqliteDb($sqliteDbFile, $configLocation, $instance->configFileName())); return $instance; }
/** * ARs should be created via static factory methods * * @param string $username * @return User */ public static function nameNew($username) { //Perform assertions before raising a event \Assert\that($username)->notEmpty()->string(); $uuid = Uuid::uuid4(); //AggregateRoot::__construct is defined as protected so it can be called in a static factory of //an extending class $instance = new self(); //Use AggregateRoot::recordThat method to apply a new Event $instance->recordThat(UserWasCreated::occur($uuid->toString(), ['name' => $username])); return $instance; }
/** * Uses Prooph\Processing\Environment to initialize with its defaults */ public static function initializeWithDefaultsIn(ConfigLocation $configLocation, ConfigWriter $configWriter) { $env = Environment::setUp(); $instance = new self(['processing' => array_merge($env->getConfig()->toArray(), ["connectors" => [], "js_ticker" => ['enabled' => false, 'interval' => 3]])], $configLocation); $configFilePath = $configLocation->toString() . DIRECTORY_SEPARATOR . self::$configFileName; if (file_exists($configFilePath)) { throw new \RuntimeException("Processing config already exists: " . $configFilePath); } $configWriter->writeNewConfigToDirectory($instance->toArray(), $configFilePath); $instance->recordThat(ProcessingConfigFileWasCreated::in($configLocation, self::$configFileName)); return $instance; }
/** * @param StoryName $storyName * @param Message $startMessage * @param ChapterTemplate[] $chapterTemplates * @param MessageConverter $messageConverter * @throws Exception\Story * @return Story */ public static function start(StoryName $storyName, Message $startMessage, array $chapterTemplates, MessageConverter $messageConverter) { self::assertChapterTemplates($chapterTemplates, $storyName); $storyId = StoryId::fromString($startMessage->uuid()->toString()); $self = new self(); $self->recordThat(StoryWasStarted::withStoryIdAndName($storyId, $storyName)); $nextCommands = $self->startNextChapters($storyName, $startMessage, $chapterTemplates, $storyId, $messageConverter); if (empty($nextCommands)) { throw Exception\Story::cannotBeStartedForMessage($startMessage); } $self->nextCommands = $nextCommands; return $self; }
/** * @param MessageHandler $messageHandler * @param TaskType $taskType * @param Prototype $processingType * @param ProcessingMetadata $metadata * @return Task */ public static function setUp(MessageHandler $messageHandler, TaskType $taskType, Prototype $processingType, ProcessingMetadata $metadata) { $instance = new self(); $instance->recordThat(TaskWasSetUp::with(TaskId::generate(), $taskType, $messageHandler, $processingType, $metadata)); return $instance; }
/** * @param NodeName $nodeName * @param WorkflowId $workflowId * @param string $workflowName * @return Workflow */ public static function locatedOn(NodeName $nodeName, WorkflowId $workflowId, $workflowName) { Assertion::string($workflowName); Assertion::notEmpty($workflowName); $instance = new self(); $instance->recordThat(WorkflowWasCreated::on($nodeName, $workflowId, $workflowName)); return $instance; }
/** * @param string $name * @param string $email * @return User */ public static function create($name, $email) { $self = new self(); $self->recordThat(UserCreated::with(['user_id' => Uuid::uuid4()->toString(), 'name' => $name, 'email' => $email], $self->nextVersion())); return $self; }
/** * @param MessageHandlerId $id * @param string $name * @param NodeName $nodeName * @param MessageHandler\HandlerType $handlerType * @param MessageHandler\DataDirection $dataDirection * @param MessageHandler\ProcessingTypes $supportedProcessingTypes * @param ProcessingMetadata $metadata * @param string $metadataRiotTag * @param string $icon * @param string $iconType * @param null|Prototype $preferredProcessingType * @param null|MessageHandler\ProcessingId $processingId * @param array $additionalData * @return MessageHandler */ public static function fromDefinition(MessageHandlerId $id, $name, NodeName $nodeName, HandlerType $handlerType, DataDirection $dataDirection, ProcessingTypes $supportedProcessingTypes, ProcessingMetadata $metadata, $metadataRiotTag, $icon, $iconType, Prototype $preferredProcessingType = null, ProcessingId $processingId = null, array $additionalData = []) { Assertion::string($name); Assertion::notEmpty($name); Assertion::string($metadataRiotTag); Assertion::notEmpty($metadataRiotTag); Assertion::string($icon); Assertion::notEmpty($icon); Assertion::string($iconType); Assertion::notEmpty($iconType); $instance = new self(); $instance->recordThat(MessageHandlerWasInstalled::record($id, $name, $nodeName, $handlerType, $dataDirection, $supportedProcessingTypes, $metadata, $metadataRiotTag, $icon, $iconType, $preferredProcessingType, $processingId, $additionalData)); return $instance; }
/** * @param string $text * @param string $email * @return Post */ public static function create($text, $email) { $self = new self(); $self->recordThat(PostCreated::with(['post_id' => Uuid::uuid4()->toString(), 'text' => $text, 'email' => $email], $self->nextVersion())); return $self; }
/** * @param string $title * @param string $content * @return Post */ public static function create($title, $content) { $post = new self($postId = PostId::generate()); $post->setTitle($title); $post->setContent($content); $post->setPublishingDate($publishingDate = new \DateTime()); $post->recordThat(new PostWasPublished($postId, $title, $content, $publishingDate)); return $post; }
/** * @param PostId $postId * @param string $author * @param string $content * @return Comment */ public static function create(PostId $postId, $author, $content) { $comment = new self($commentId = CommentId::generate()); $comment->setPostId($postId); $comment->setAuthor($author); $comment->setContent($content); $comment->setCreatingDate($creatingDate = new \DateTime()); $comment->recordThat(new CommentWasAdded($commentId, $postId, $author, $content, $creatingDate)); return $comment; }