PHP self::recordThat方法代碼示例

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