/** * @see Command */ protected function execute(InputInterface $input, OutputInterface $output) { /** @var \Doctrine\ORM\EntityManager $em */ $em = $this->getContainer()->get('doctrine.orm.default_entity_manager'); $campaignRepo = $em->getRepository('VifeedCampaignBundle:Campaign'); $campaigns = new ArrayCollection($campaignRepo->getActiveCampaigns()); $hashes = []; foreach ($campaigns as $campaign) { /** @var Campaign $campaign */ $hashes[] = $campaign->getHash(); } $hashes = array_unique($hashes); $client = new \Google_Client(); $client->setDeveloperKey($this->getContainer()->getParameter('google.api.key')); $youtube = new \Google_Service_YouTube($client); /* Опытным путём выяснилось, что ютуб принимает не больше 50 хешей за раз */ $hash = 'TjvivnmWcn4'; $request = $youtube->videos->listVideos('status', ['id' => $hash]); foreach ($request as $video) { /** @var \Google_Service_YouTube_Video $video */ /** @var \Google_Service_YouTube_VideoStatistics $stats */ $stats = $video->getStatistics(); $hash = $video->getId(); /* не исключается ситуация, что может быть несколько кампаний с одинаковым hash */ $filteredCampaigns = $campaigns->filter(function (Campaign $campaign) use($hash) { return $campaign->getHash() == $hash; }); foreach ($filteredCampaigns as $campaign) { $campaign->setSocialData('youtubeViewCount', $stats->getViewCount())->setSocialData('youtubeCommentCount', $stats->getCommentCount())->setSocialData('youtubeFavoriteCount', $stats->getFavoriteCount())->setSocialData('youtubeLikeCount', $stats->getLikeCount())->setSocialData('youtubeDislikeCount', $stats->getDislikeCount()); $em->persist($campaign); } } $em->flush(); }
/** * @param TaskDescription $description * @return mixed * @throws DomainException */ public function getTaskByDescription(TaskDescription $description) { $tasksFound = $this->tasks->filter(function (Task $task) use($description) { return $description->equals($task->getDescription()); }); if ($tasksFound->isEmpty()) { throw new DomainException('Task ' . $description . ' does not exist in working day'); } return $tasksFound->first(); }
/** * Return the last oxford comma eligible word * in the sentence * * @return ArrayCollection|Word[] */ public function getOxfordItems() { $words = new ArrayCollection(); $conjunctions = $this->words->filter(function (Word $word) { return $word instanceof Conjunction; }); $conjunctions->map(function ($word) use($words) { if ($this->hasOxfordable($word)) { $index = $this->words->indexOf($word) - 1; $words->add($this->words->get($index)); } }); return $words; }
/** * @inheritdoc */ public function remove(AmountInterface $amount) { if (!$this->has($amount)) { return $this; } $a = $this->find($amount); if ($a->getBase() > $amount->getBase()) { $a->removeBase($amount->getBase()); } else { $this->amounts = $this->amounts->filter(function (AmountInterface $a) use($amount) { return !$a->equals($amount); }); } return $this; }
/** * configureSanbox method with not cached scenario */ public function testConfigureSandboxNotCached() { $entityClass = 'Oro\\Bundle\\UserBundle\\Entity\\User'; $configIdMock = $this->getMockForAbstractClass('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $configIdMock->expects($this->once())->method('getClassName')->will($this->returnValue($entityClass)); $configuredData = array($entityClass => array('getsomecode')); $this->cache->expects($this->once())->method('fetch')->with($this->cacheKey)->will($this->returnValue(false)); $this->cache->expects($this->once())->method('save')->with($this->cacheKey, serialize($configuredData)); $configurableEntities = array($configIdMock); $this->configProvider->expects($this->once())->method('getIds')->will($this->returnValue($configurableEntities)); $fieldsCollection = new ArrayCollection(); $this->configProvider->expects($this->once())->method('filter')->will($this->returnCallback(function ($callback) use($fieldsCollection) { return $fieldsCollection->filter($callback); })); $field1Id = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\FieldConfigId')->disableOriginalConstructor()->getMock(); $field1Id->expects($this->once())->method('getFieldName')->will($this->returnValue('someCode')); $field1 = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMockForAbstractClass(); $field2 = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMockForAbstractClass(); $field1->expects($this->once())->method('is')->with('available_in_template')->will($this->returnValue(true)); $field1->expects($this->once())->method('getId')->will($this->returnValue($field1Id)); $field2->expects($this->once())->method('is')->with('available_in_template')->will($this->returnValue(false)); $fieldsCollection->add($field1); $fieldsCollection->add($field2); $this->getRendererInstance(); }
/** * @param StaticSegment $staticSegment * @param string $segmentStateFilter * @param string $method * @param string $itemState * @param bool $deleteMember * @return array */ public function handleMembersUpdate(StaticSegment $staticSegment, $segmentStateFilter, $method, $itemState, $deleteMember = false) { $itemsToWrite = []; $items = $staticSegment->getSegmentMembers()->filter(function (StaticSegmentMember $segmentMember) use($segmentStateFilter) { return $segmentMember->getState() === $segmentStateFilter; })->toArray(); if (empty($items)) { return []; } $emails = array_map(function (StaticSegmentMember $segmentMember) { return $segmentMember->getMember()->getEmail(); }, $items); $response = $this->transport->{$method}(['id' => $staticSegment->getSubscribersList()->getOriginId(), 'seg_id' => (int) $staticSegment->getOriginId(), 'batch' => array_map(function ($email) { return ['email' => $email]; }, $emails), 'delete_member' => $deleteMember]); $this->handleResponse($response, function ($response, LoggerInterface $logger) use($staticSegment) { $logger->info(sprintf('Segment #%s [origin_id=%s] Members: [%s] add, [%s] error', $staticSegment->getId(), $staticSegment->getOriginId(), $response['success_count'], $response['error_count'])); }); $emailsWithErrors = $this->getArrayData($response, 'errors'); /** @var StaticSegmentMember[]|ArrayCollection $items */ $items = new ArrayCollection($items); $items->filter(function (StaticSegmentMember $segmentMember) use($emailsWithErrors) { return !in_array($segmentMember->getMember()->getEmail(), $emailsWithErrors, true); }); foreach ($items as $item) { $item->setState($itemState); $this->logger->debug(sprintf('Member with id "%s" and email "%s" got "%s" state', $item->getMember()->getOriginId(), $item->getMember()->getEmail(), $itemState)); $itemsToWrite[] = $item; } return $itemsToWrite; }
/** * @param string $service * @return Hash|false */ public function getTokenForService($service) { $token = $this->tokens->filter(function (Token $token) use($service) { return $token->getService() == $service; })->first(); return $token ? $token->getToken() : false; }
/** * @return ArrayCollection */ public function getEditors() { $editors = $this->users->filter(function (User $user) { return $user->isEditor(); }); return $editors; }
/** * @param array $filters * @param int $limit * @param int $offset * * @return array */ public function findBy(array $filters, $limit = null, $offset = 0) { $result = $this->result->filter(function ($item) use($filters) { // filter all non valid conditions foreach ($filters as $key => $value) { if (!array_key_exists($key, $item) || $item[$key] != $value) { return false; } } return true; }); if (empty($limit)) { return $result->toArray(); } return $result->slice($offset, $limit); }
/** * @param Permission|string $permission * * @return Permission|null */ protected function getPermission($permission) { $name = $permission instanceof Permission ? $permission->getName() : $permission; return $this->permissions->filter(function (Permission $current) use($name) { return $current->getName() == $name; })->first(); }
/** * @return Group */ public function getPreliminaryGroup() { $gos = $this->grouporder->filter(function (GroupOrder $grouporder) { return $grouporder->getGroup()->getClassification() == Group::$PRE; }); return $gos->count() == 1 ? $gos->first()->getGroup() : null; }
public function filter(Closure $p) { if (null === $this->entries) { $this->__load___(); } return $this->entries->filter($p); }
/** * @param SubscribersList $subscribersList * @param array|ArrayCollection $items * @return array */ protected function batchSubscribe(SubscribersList $subscribersList, array $items) { $itemsToWrite = []; $emails = array_map(function (Member $member) { return ['email' => ['email' => $member->getEmail()], 'merge_vars' => $member->getMergeVarValues()]; }, $items); $response = $this->transport->batchSubscribe(['id' => $subscribersList->getOriginId(), 'batch' => $emails, 'double_optin' => false, 'update_existing' => true]); $this->handleResponse($response, function ($response, LoggerInterface $logger) use($subscribersList) { $logger->info(sprintf('List #%s [origin_id=%s]: [%s] add, [%s] update, [%s] error', $subscribersList->getId(), $subscribersList->getOriginId(), $response['add_count'], $response['update_count'], $response['error_count'])); }); $emailsAdded = $this->getArrayData($response, 'adds'); $emailsUpdated = $this->getArrayData($response, 'updates'); $items = new ArrayCollection($items); foreach (array_merge($emailsAdded, $emailsUpdated) as $emailData) { /** @var Member $member */ $member = $items->filter(function (Member $member) use($emailData) { return $member->getEmail() === $emailData['email']; })->first(); if ($member) { $member->setEuid($emailData['euid'])->setLeid($emailData['leid'])->setStatus(Member::STATUS_SUBSCRIBED); $itemsToWrite[] = $member; $this->logger->debug(sprintf('Member with data "%s" successfully processed', json_encode($emailData))); } else { $this->logger->warning(sprintf('A member with "%s" email was not found', $emailData['email'])); } } return $itemsToWrite; }
/** * @internal * @param string $caseFilter * @return ArrayCollection */ protected function filterCases($caseFilter) { $this->initCases(); return $this->cases->filter(function ($item) use($caseFilter) { return $item instanceof $caseFilter; }); }
/** * @dataProvider fieldsDataProvider * @param $entityIsUser */ public function testGetTemplateVariables($entityIsUser) { $configId1Mock = $this->getMockForAbstractClass('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $configId1Mock->expects($this->once())->method('getClassName')->will($this->returnValue(get_class($this->user))); $configId2Mock = $this->getMockForAbstractClass('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $configId2Mock->expects($this->once())->method('getClassName')->will($this->returnValue(self::TEST_ENTITY_NAME)); $configId3Mock = $this->getMockForAbstractClass('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\ConfigIdInterface'); $configId3Mock->expects($this->once())->method('getClassName')->will($this->returnValue(self::TEST_NOT_NEEDED_ENTITY_NAME)); $configurableEntities = array($configId1Mock, $configId2Mock, $configId3Mock); $this->configProvider->expects($this->once())->method('getIds')->will($this->returnValue($configurableEntities)); $field1Id = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\FieldConfigId')->disableOriginalConstructor()->getMock(); $field1Id->expects($this->any())->method('getFieldName')->will($this->returnValue('someCode')); $field1 = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMockForAbstractClass(); $field2 = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigInterface')->disableOriginalConstructor()->getMockForAbstractClass(); $field1->expects($this->any())->method('is')->with('available_in_template')->will($this->returnValue(true)); $field1->expects($this->any())->method('getId')->will($this->returnValue($field1Id)); $field2->expects($this->any())->method('is')->with('available_in_template')->will($this->returnValue(false)); // fields for entity $fieldsCollection = new ArrayCollection(); $this->configProvider->expects($this->at(1))->method('filter')->will($this->returnCallback(function ($callback) use($fieldsCollection) { return $fieldsCollection->filter($callback)->toArray(); })); $fieldsCollection[] = $field1; $fieldsCollection[] = $field2; if (!$entityIsUser) { $field3Id = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\Id\\FieldConfigId')->disableOriginalConstructor()->getMock(); $field3Id->expects($this->any())->method('getFieldName')->will($this->returnValue('someAnotherCode')); $field3 = clone $field1; $field3->expects($this->atLeastOnce())->method('is')->with('available_in_template')->will($this->returnValue(true)); $field3->expects($this->atLeastOnce())->method('getId')->will($this->returnValue($field3Id)); $this->configProvider->expects($this->at(2))->method('filter')->will($this->returnCallback(function ($callback) use($fieldsCollection, $field3) { $fieldsCollection[] = $field3; return $fieldsCollection->filter($callback)->toArray(); })); $result = $this->provider->getTemplateVariables(self::TEST_ENTITY_NAME); } else { $result = $this->provider->getTemplateVariables(get_class($this->user)); } $this->assertArrayHasKey('user', $result); $this->assertArrayHasKey('entity', $result); $this->assertInternalType('array', $result['user']); $this->assertInternalType('array', $result['entity']); if ($entityIsUser) { $this->assertEquals($result['user'], $result['entity']); } }
/** * Getter for fields without the Backend scope * * @return Doctrine\Common\Collections\ArrayCollection */ public function getFieldsWithoutBackend() { return $this->fields->filter(function ($field) { if ($field->getFieldScope() == 'frontend') { return $field; } }); }
/** * Gets a (previously set) query parameter of the query being constructed. * * @param mixed $key The key (index or name) of the bound parameter. * * @return Query\Parameter|null The value of the bound parameter. */ public function getParameter($key) { $filteredParameters = $this->parameters->filter(function ($parameter) use($key) { // Must not be identical because of string to integer conversion return $key == $parameter->getName(); }); return count($filteredParameters) ? $filteredParameters->first() : null; }
/** * @param bool $includeOffline * * @return ArrayCollection */ public function getNodeTranslations($includeOffline = false) { return $this->nodeTranslations->filter(function (NodeTranslation $entry) use($includeOffline) { if ($includeOffline || $entry->isOnline()) { return true; } return false; }); }
/** * Retrieves Attachment * @param $attachmentId * @return Attachment */ public function getAttachment($attachmentId) { $attachment = $this->attachments->filter(function ($elm) use($attachmentId) { /** * @var $elm Attachment */ return $elm->getId() == $attachmentId; })->first(); return $attachment; }
/** * Remove person * * @param Person|EmbeddedPerson $person * @return boolean TRUE if this embedded person contained the specified person, FLASE otherwise. */ public function removePerson($person) { $embeddedPerson = $this->getEmbeddedPerson($person); $aux = $this->people->filter(function ($i) use($embeddedPerson) { return $i->getId() !== $embeddedPerson->getId(); }); $hasRemoved = count($aux) !== count($this->people); $this->people = $aux; return $hasRemoved; }
/** * {@inheritdoc} */ public function getActivatedAt() { $completed = $this->activations->filter(function (Activation $activation) { return $activation->isCompleted(); }); if ($completed->isEmpty()) { return null; } return $completed->first()->getCompletedAt(); }
/** * Apply menu filters to Menu. * * @param ArrayCollection $menuNodes Menu nodes * @param string $menuCode Menu code * @param string $stage Stage * * @return ArrayCollection Filtered collection */ private function applyFiltersToMenuNodes(ArrayCollection $menuNodes, $menuCode, $stage) { return $menuNodes->filter(function (NodeInterface $menuNode) use($menuCode, $stage) { if ($this->applyFiltersToMenuNode($menuNode, $menuCode, $stage)) { $menuNode->setSubnodes($this->applyFiltersToMenuNodes($menuNode->getSubnodes(), $menuCode, $stage)); return true; } return false; }); }
/** * Get email recipients * * @param null|string $recipientType null to get all recipients, * or 'to', 'cc' or 'bcc' if you need specific type of recipients * @return EmailRecipient[] */ public function getRecipients($recipientType = null) { if ($recipientType === null) { return $this->recipients; } return $this->recipients->filter(function ($recipient) use($recipientType) { /** @var EmailRecipient $recipient */ return $recipient->getType() === $recipientType; }); }
/** * @param AttorneyAbstract $attorney * @return ArrayCollection */ public function findAttorney(AttorneyAbstract $attorney) { $this->initAttorneys(); return $this->attorneys->filter(function ($item) use($attorney) { if ('' !== $attorney->getDobString()) { return $item->getTitle() === $attorney->getTitle() && $item->getFirstname() === $attorney->getFirstname() && $item->getMiddleName() === $attorney->getMiddlename() && $item->getSurname() === $attorney->getSurname() && $item->getDobString() === $attorney->getDobString(); } else { return $item->getTitle() === $attorney->getTitle() && $item->getFirstname() === $attorney->getFirstname() && $item->getMiddleName() === $attorney->getMiddlename() && $item->getSurname() === $attorney->getSurname(); } }); }
/** * @param string $siteId * * @return Collection */ public function getSubFoldersBySiteId($siteId) { return $this->subFolders->filter(function (FolderInterface $folder) use($siteId) { foreach ($folder->getSites() as $folderSite) { if ($folderSite['siteId'] === $siteId) { return true; } } return count($folder->getSites()) === 0; }); }
/** * Test if a collection of contracts are valid * * Valid contracts are <b>signed</b>, <b>not cancelled</b>, and * <b>co-signed</b> if necessary. * * @param ArrayCollection $signatures * @return bool */ public static function areValid(ArrayCollection $signatures) { $isActiveFilter = self::createIsActiveFilter(); $partitioned = $signatures->filter($isActiveFilter)->partition(function ($key, $signature) { // Signature does not require a co-signature if (!$signature->requires_cosigned) { return true; } return $signature->is_cosigned; }); return count($partitioned[0]) > 0; }
/** * @dataProvider newEntityFieldsProvider * @param ArrayCollection $fieldsCollection * @param $shouldClearCache */ public function testNewEntityConfig(ArrayCollection $fieldsCollection, $shouldClearCache) { $cmMock = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Config\\ConfigManager')->disableOriginalConstructor()->getMock(); $cpMock = $this->getMockBuilder('Oro\\Bundle\\EntityConfigBundle\\Provider\\ConfigProvider')->disableOriginalConstructor()->getMock(); $cpMock->expects($this->once())->method('filter')->will($this->returnCallback(function ($callback) use($fieldsCollection) { return $fieldsCollection->filter($callback); })); $cmMock->expects($this->once())->method('getProvider')->with('email')->will($this->returnValue($cpMock)); $event = new EntityConfigEvent('Test\\Class', $cmMock); $this->cache->expects($this->exactly((int) $shouldClearCache))->method('delete'); $this->subscriber->newEntityConfig($event); }
/** * Get media. * * @param bool $includeDeleted * * @return ArrayCollection */ public function getMedia($includeDeleted = false) { if ($includeDeleted) { return $this->media; } return $this->media->filter(function (Media $entry) { if ($entry->isDeleted()) { return false; } return true; }); }
/** * Get child folders * * @param bool $includeDeleted * * @return ArrayCollection */ public function getChildren($includeDeleted = false) { if ($includeDeleted) { return $this->children; } return $this->children->filter(function (Folder $entry) { if ($entry->isDeleted()) { return false; } return true; }); }
/** * @param string $type * * @return \Doctrine\Common\Collections\Collection * @throws \Exception */ private function getFieldMappingsOfType($type = self::FIELD_TYPE_COMMON) { if ($this->fieldMappings === NULL) { throw new \Exception("Field mapping needs to be set"); } return $this->fieldMappings->filter(function ($entry) use($type) { if ($type === self::FIELD_TYPE_COMMON && !$entry instanceof SearchAssociationFieldMapping || $type === self::FIELD_TYPE_ASSOCIATION && $entry instanceof SearchAssociationFieldMapping) { return $entry; } return false; }); }