/** * Initialize the saga. If an identifier is provided it will be used, otherwise a random UUID will be generated. * * @param string $identifier */ public function __construct($identifier = null) { $this->identifier = null === $identifier ? Uuid::uuid1()->toString() : $identifier; $this->associationValues = new AssociationValuesImpl(); $this->inspector = new SagaMethodMessageHandlerInspector($this); $this->associationValues->add(new AssociationValue('sagaIdentifier', $this->identifier)); }
/** * Creates the requested UUID * * @param int $version * @param string $namespace * @param string $name * @return Uuid */ protected function createUuid($version, $namespace = null, $name = null) { switch ((int) $version) { case 1: $uuid = Uuid::uuid1(); break; case 4: $uuid = Uuid::uuid4(); break; case 3: case 5: $ns = $this->validateNamespace($namespace); if (empty($name)) { throw new Exception('The name argument is required for version 3 or 5 UUIDs'); } if ($version == 3) { $uuid = Uuid::uuid3($ns, $name); } else { $uuid = Uuid::uuid5($ns, $name); } break; default: throw new Exception('Invalid UUID version. Supported are version "1", "3", "4", and "5".'); } return $uuid; }
/** * @param mixed $payload * @param MetaData $metaData * @param string|null $id * @param string|null $commandName */ public function __construct($payload, MetaData $metaData = null, $id = null, $commandName = null) { $this->id = null === $id ? Uuid::uuid1()->toString() : $id; $this->commandName = null === $commandName ? get_class($payload) : $commandName; $this->payload = $payload; $this->metaData = null === $metaData ? MetaData::emptyInstance() : $metaData; }
public function login() { try { $passwordMatch = false; $userDeviceUpdated = false; $access_token = ''; $input = Request::all(); $user = User::where('email', $input['email'])->first(); if ($user) { if (crypt($input['password'], $user->password) == $user->password) { $passwordMatch = true; } } if ($passwordMatch) { $userDevice = UserDevice::where('device_id', $input['device_id'])->first(); $access_token = Uuid::uuid1()->toString(); if ($userDevice) { $userDeviceUpdated = $userDevice->update(['device_id' => $input['device_id'], 'rest_access_token' => $access_token, 'rest_access_token_expires' => Carbon::now()->addDays(360), 'rest_notification_id' => $input['notification_id'], 'os_type' => $input['os_type'], 'os_version' => $input['os_version'], 'hardware' => $input['hardware'], 'rest_app_version' => $input['app_version'], 'user_id' => $user->id]); } else { $userDeviceUpdated = UserDevice::create(['device_id' => $input['device_id'], 'rest_access_token' => $access_token, 'rest_access_token_expires' => Carbon::now()->addDays(360), 'rest_notification_id' => $input['notification_id'], 'os_type' => $input['os_type'], 'os_version' => $input['os_version'], 'hardware' => $input['hardware'], 'rest_app_version' => $input['app_version'], 'user_id' => $user->id]); } } if ($userDeviceUpdated) { $vendorLocationContact = VendorLocationContact::where('user_id', $user->id)->first(); $vendorLocation = VendorLocation::where('id', $vendorLocationContact->vendor_location_id)->first(); $vendor = Vendor::where('id', $vendorLocation->vendor_id)->first(); return response()->json(['id' => $user->id, 'access_token' => $access_token, 'full_name' => $user->full_name, 'email' => $user->email, 'phone_number' => $user->phone_number, 'role' => $user->role->name, 'vendor_name' => $vendor->name], 200); } else { return response()->json(['action' => 'Check if the email address and password match', 'message' => 'There is an email password mismatch. Please check and try again'], 227); } } catch (\Exception $e) { return response()->json(['message' => 'An application error occured.', 'error' => $e->getMessage()], 500); } }
public static function generate($ver = 4, $node = null, $clockSeq = null, $ns = null, $name = null) { $uuid = null; /* Create a new UUID based on provided data. */ switch ((int) $ver) { case 1: $uuid = Uuid::uuid1($node, $clockSeq); break; case 2: // Version 2 is not supported throw new \RuntimeException('UUID version 2 is unsupported.'); case 3: $uuid = Uuid::uuid3($ns, $name); break; case 4: $uuid = Uuid::uuid4(); break; case 5: $uuid = Uuid::uuid5($ns, $name); break; default: throw new \RuntimeException('Selected UUID version is invalid or unsupported.'); } if (function_exists('gmp_strval')) { return gmp_strval(gmp_init($uuid->getHex(), 16), 62); } return Base62::encode((string) $uuid->getInteger()); }
/** * Model boot method, sets guid on create. * * @return void */ public static function boot() { parent::boot(); static::creating(function ($model) { $model->guid = Uuid::uuid1(); }); }
/** * @expectedException \OutOfBoundsException */ public function testNextReadBeyondEnd() { $event1 = new GenericDomainEventMessage(Uuid::uuid1(), 0, new \stdClass(), new MetaData()); $testSubject = new SimpleDomainEventStream(array($event1)); $testSubject->next(); $testSubject->next(); }
public function testResolveTarget_WithAnnotatedFields() { $aggregateIdentifier = Uuid::uuid1(); $version = 1; $actual = $this->testSubject->resolveTarget(GenericCommandMessage::asCommandMessage(new FieldAnnotatedCommand($aggregateIdentifier, $version))); $this->assertEquals($aggregateIdentifier, $actual->getIdentifier()); $this->assertEquals($version, $actual->getVersion()); }
public function testRegisterCallbackInvokedWithAllRegisteredEvents() { $container = new EventContainer(Uuid::uuid1()->toString()); $container->addEvent(MetaData::emptyInstance(), new Event()); $this->assertFalse(current($container->getEventList())->getMetaData()->has("key")); $container->addEventRegistrationCallback(new TestEventRegistrationCallback()); $this->assertEquals("value", current($container->getEventList())->getMetadata()->get("key")); }
/** * schedule. * * Schedule $command for later execution * Returns a unique identifier for the scheduled execution * If an $id was passed it'll overwrite the scheduled execution * * @since 1.0 * * @param ScheduledCommandInterface $command * @param string $id - optional * * @return string */ public function schedule(ScheduledCommandInterface $command, $id = null) { $fileName = isset($id) ? $id : Uuid::uuid1()->toString(); file_put_contents($this->path . DIRECTORY_SEPARATOR . $fileName, serialize($command)); $this->register[$fileName] = $command->getTimestamp(); file_put_contents($this->path . DIRECTORY_SEPARATOR . 'register', serialize($this->register)); return $fileName; }
/** * createVoucher function. * * @access public * * @param string $campaignUrn * * @return Voucher */ public function createVoucher($campaignUrn) { // Check for valid campaign if ($campaign = $this->campaignRepo->loadCampaign($campaignUrn)) { $voucher = $this->model->create(['campaign_id' => $campaign->id, 'hash' => Uuid::uuid1()->toString()]); return $voucher; } return false; }
/** * @param mixed $payload * @param MetaData $metadata * @param string $id */ public function __construct($payload, MetaData $metadata = null, $id = null) { if (!is_object($payload)) { throw new \InvalidArgumentException("Payload needs to be an object."); } $this->id = isset($id) ? $id : Uuid::uuid1()->toString(); $this->metadata = isset($metadata) ? $metadata : MetaData::emptyInstance(); $this->payload = $payload; }
/** * Set object with Auto document_id * @param mixed $object Receive object to store * @return string Return string with $document_id */ public function set($object, $document_id = null) { if (is_null($document_id) || !Uuid::isValid($document_id)) { $document_id = strtoupper(Uuid::uuid1()); } $this->resolvePath($this->dataPath); file_put_contents($this->dataPath . DIRECTORY_SEPARATOR . $document_id, json_encode($object, JSON_PRETTY_PRINT), LOCK_EX); return $document_id; }
/** * UUID1,基于时间戳 * * @param int|string $node * @param int $clockSeq * @return string */ public static function v1($node = null, $clockSeq = null) { try { $uuid1 = VendorUUID::uuid1($node, $clockSeq); return $uuid1->toString(); } catch (UnsatisfiedDependencyException $e) { return false; } }
public function testCommandReply() { $commandId1 = Uuid::uuid1()->toString(); $commandId2 = Uuid::uuid1()->toString(); $this->testSubject->writeCommandReply($commandId1, $commandId1); $data = $this->testSubject->readCommandReply($commandId1); $this->assertEquals($commandId1, $data[1]); $data = $this->testSubject->readCommandReply($commandId2, 1); $this->assertNull($data); }
/** * @param Request $request * @param Closure $next * @return mixed */ public function handle(Request $request, Closure $next) { //Generate the request id $requestId = Uuid::uuid1()->toString(); //Add the request id processor to logger instance $this->log->addProcessors([new RequestIdProcessor($requestId)]); $response = $next($request); $response->headers->set('Request-Id', $requestId, false); return $response; }
public function testLoadAggregate_NotFound() { $aggregateIdentifier = Uuid::uuid1()->toString(); try { $this->testSubject->load($aggregateIdentifier); $this->fail("Expected AggregateNotFoundException"); } catch (AggregateNotFoundException $ex) { $this->assertEquals($aggregateIdentifier, $ex->getAggregateId()); } }
/** * Create a UUID v1 * */ public static function v1() { try { $uuid = RhumsaaUuid::uuid1(); $uuidString = $uuid->toString(); } catch (UnsatisfiedDependencyException $exc) { throw new \Exception(__METHOD__ . ': Some dependency was not met or the method cannot be called on a 32 bit system.', $exc); } return $uuidString; }
/** * @see Norm\Connection::persist() */ public function persist($collection, array $document) { if ($collection instanceof Collection) { $collection = $collection->getName(); } $this->data[$collection] = isset($this->data[$collection]) ? $this->data[$collection] : array(); // TODO change this to uuidv4 $document['id'] = Uuid::uuid1() . ''; $document = $this->marshall($document); $this->data[$collection][] = $document; return $this->unmarshall($document); }
public function getToken($user) { if (!$user) { return false; } $this->setUser($user); $attributes = ['user_id' => $this->users->getEntityKey($user)]; if (!($token = $this->findByAttributes($attributes))) { $attributes['token'] = (string) Uuid::uuid1(); $token = $this->create($attributes); } return $this->serializeToken($token); }
public function testLockFailsOnConcurrentModification() { $identifier = Uuid::uuid1()->toString(); $aggregate1 = new StubAggregate($identifier); $aggregate2 = new StubAggregate($identifier); $manager = new OptimisticLockManager(); $manager->obtainLock($aggregate1->getIdentifier()); $manager->obtainLock($aggregate2->getIdentifier()); $aggregate1->doSomething(); $aggregate2->doSomething(); $this->assertTrue($manager->validateLock($aggregate1)); $this->assertFalse($manager->validateLock($aggregate2)); }
public function testFixtureApi_WhenEventIsPublishedToEventBus() { $aggregate1 = Uuid::uuid1()->toString(); $aggregate2 = Uuid::uuid1()->toString(); $fixture = new AnnotatedSagaTestFixture(StubSaga::class); $validator = $fixture->givenAggregate($aggregate1)->published(array(new TriggerSagaStartEvent($aggregate1), new TriggerExistingSagaEvent($aggregate1)))->whenAggregate($aggregate1)->publishes(new TriggerExistingSagaEvent($aggregate1)); $validator->expectActiveSagas(1); $validator->expectAssociationWith("identifier", $aggregate1); $validator->expectNoAssociationWith("identifier", $aggregate2); //validator.expectScheduledEventMatching(Duration.standardMinutes(10), // Matchers.messageWithPayload(CoreMatchers.any(Object.class))); $validator->expectDispatchedCommandsEqualTo(array()); $validator->expectPublishedEventsMatching(Matchers::listWithAnyOf(array(Matchers::messageWithPayload(CoreMatchers::any(SagaWasTriggeredEvent::class))))); }
public function persist($collection, array $document) { if ($collection instanceof Collection) { $collection = $collection->getName(); } $id = isset($document['$id']) ? $document['$id'] : Uuid::uuid1() . ''; $document = $this->marshall($document); $document['id'] = $id; $collectionDir = $this->option('dataDir') . DIRECTORY_SEPARATOR . $collection . DIRECTORY_SEPARATOR; if (!is_dir($collectionDir)) { @unlink($collectionDir); mkdir($collectionDir, 0755, true); } file_put_contents($collectionDir . $document['id'] . '.json', json_encode($document, JSON_PRETTY_PRINT)); return $this->unmarshall($document); }
public function testStreamDomainEventMessage() { $serializer = new JMSSerializer(); $writer = new EventMessageWriter($serializer); $payload = new StreamPayload("string", 10, 15.5); $message = new GenericDomainEventMessage(Uuid::uuid1(), 1, $payload, new MetaData(array("metaKey" => "MetaValue"))); $data = $writer->writeEventMessage($message); $reader = new EventMessageReader($serializer); $serializedMessage = $reader->readEventMessage($data); $this->assertTrue($serializedMessage instanceof DomainEventMessageInterface); $this->assertEquals($message->getIdentifier(), $serializedMessage->getIdentifier()); $this->assertEquals($message->getPayloadType(), $serializedMessage->getPayloadType()); $this->assertEquals($message->getTimestamp(), $serializedMessage->getTimestamp()); $this->assertEquals($message->getMetaData(), $serializedMessage->getMetaData()); $this->assertEquals($message->getPayload(), $serializedMessage->getPayload()); $this->assertEquals($message->getAggregateIdentifier(), $serializedMessage->getAggregateIdentifier()); $this->assertEquals($message->getScn(), $serializedMessage->getScn()); }
public function testRead_FileNotReadable() { $mockEventFileResolver = $this->getMock('Governor\\Framework\\EventStore\\Filesystem\\EventFileResolverInterface'); $mockFile = $this->getMockBuilder('\\SplFileObject')->setConstructorArgs(array(tempnam(sys_get_temp_dir(), 'governormockfile'), 'ab+'))->getMock(); $mockEventFileResolver->expects($this->any())->method('eventFileExists')->will($this->returnValue(true)); $mockEventFileResolver->expects($this->any())->method('openEventFileForReading')->will($this->returnValue($mockFile)); $exception = new \Exception("Mock Exception"); $mockFile->expects($this->any())->method('fgetc')->will($this->throwException($exception)); $eventStore = new FileSystemEventStore($mockEventFileResolver, $this->serializer); try { $eventStore->readEvents("test", Uuid::uuid1()->toString()); $this->fail("Expected an exception"); } catch (EventStoreException $ex) { $this->assertSame($exception, $ex->getPrevious()); } }
public function __construct($identifier = null) { $this->identifier = null !== $identifier ? $identifier : Uuid::uuid1()->toString(); }
/** * Constructer. */ public function __construct() { $this->items = new ArrayCollection(); $this->users = new ArrayCollection(); $this->setUuid(Uuid::uuid1()); }
public static function uuid1($node = null, $clockSeq = null) { return BaseUuid::uuid1($node, $clockSeq); }
/** * generate time base uuid * * @return string */ protected function createIdVersion1() { return Uuid::uuid1()->toString(); }
/** * @inheritdoc */ protected function execute(InputInterface $input, OutputInterface $output) { /** * Check to see if this should run at all */ if (!$this->shouldRun($input->getOption("no-lock"))) { $output->writeLn("Error: There appears to be an instance of this script running already."); return; } /** * Add lock file if required */ if (!$input->getOption("no-lock")) { $this->setLockFile(); } $em = $this->deps["entityManager"]; $query = $em->createQuery("SELECT j from Iu\\Uits\\Webtech\\Clam\\Model\\Job j where j.state = 'waiting'"); $jobs = $query->getResult(); foreach ($jobs as $job) { /** * Set the job state to running, this may be excessive, but what the * heck. We can do it, and it would be good to know anyway. */ $job->state = "running"; $em->persist($job); $em->flush(); /** * Run the actual clam scan */ $process = new Process($this->buildJobCommand($job)); $process->setTimeout(36000); $process->run(); /** * Figure out if the program finished correctly and set the state * accordingly. * If it's not 0 it screwed up */ if ($process->isSuccessful()) { $job->state = "finished"; } else { $job->state = "failed"; } $em->persist($job); $em->flush(); /** * Parse the results into something useful */ $results = $this->parseOutput($process->getOutput()); /** * Create and store the results in the database */ $result = new Result(); $result->id = Uuid::uuid1(); $result->completedAt = new \DateTime("now", $this->deps["timezone"]); $result->scannedDirectories = $results["summary"]["Scanned directories"]; $result->scannedFiles = $results["summary"]["Scanned files"]; $result->infectedFiles = $results["summary"]["Infected files"]; $result->dataScanned = $results["summary"]["Data scanned"]; $result->dataRead = $results["summary"]["Data read"]; $result->executionTime = $results["summary"]["Time"]; $result->fileResults = $results["files"]; $em->persist($result); /** * Add the resultId to the job entry */ $job->result = $result->id; $em->persist($job); $em->flush(); /** * Send an email to the requested report address (if set) */ if (!is_null($job->reportAddress)) { $this->sendEmailReport($job, $result); } } /** * Delete the lock file if required */ if (!$input->getOption("no-lock")) { $this->unsetLockFile(); } }