/** * * Returns an ArrayCollection containing three keys : * - self::BASKETS : an ArrayCollection of the actives baskets * (Non Archived) * - self::STORIES : an ArrayCollection of working stories * - self::VALIDATIONS : the validation people are waiting from me * * @return \Doctrine\Common\Collections\ArrayCollection */ public function getContent($sort) { /* @var $repo_baskets Alchemy\Phrasea\Model\Repositories\BasketRepository */ $repo_baskets = $this->app['repo.baskets']; $sort = in_array($sort, ['date', 'name']) ? $sort : 'name'; $ret = new ArrayCollection(); $baskets = $repo_baskets->findActiveByUser($this->app['authentication']->getUser(), $sort); // force creation of a default basket if (0 === count($baskets)) { $basket = new BasketEntity(); $basket->setName($this->app->trans('Default basket')); $basket->setUser($this->app['authentication']->getUser()); $this->app['EM']->persist($basket); $this->app['EM']->flush(); $baskets = [$basket]; } $validations = $repo_baskets->findActiveValidationByUser($this->app['authentication']->getUser(), $sort); /* @var $repo_stories Alchemy\Phrasea\Model\Repositories\StoryWZRepository */ $repo_stories = $this->app['repo.story-wz']; $stories = $repo_stories->findByUser($this->app, $this->app['authentication']->getUser(), $sort); $ret->set(self::BASKETS, $baskets); $ret->set(self::VALIDATIONS, $validations); $ret->set(self::STORIES, $stories); return $ret; }
public function addToFilters(ArrayCollection $filters) { $upperBound = $this->fields . '_' . $this->options['upper_bound_suffix']; $lowerBound = $this->fields . '_' . $this->options['lower_bound_suffix']; $filters->set($lowerBound, $this->getGreaterThanFilter()); $filters->set($upperBound, $this->getLessThanFilter()); }
/** * @inheritdoc */ public function update(User $user) { if (!$this->collection->containsKey((string) $user->getId())) { throw new UserNotFoundException(); } $this->collection->set((string) $user->getId(), $user); }
/** * @param ProviderInterface $provider * * @return $this */ public function addProvider(ProviderInterface $provider) { if (!$this->providers->contains($provider)) { $this->providers->set($provider->getName(), $provider); } return $this; }
/** * @param string $type * @param array $options * @return $this */ protected function addAction($type, array $options = []) { $action = $this->actionFactory->get($type, $options); $suffix = $action->getOptions()['route_suffix']; $key = empty($suffix) ? $action->getName() : $suffix; $this->actions->set($key, $action); return $this; }
/** * @param string $type * @param array $options * @return ActionsProvider */ protected function addAction(string $type, array $options = []) : self { $action = $this->actionFactory->get($type, $options); $suffix = $action->getOptions()['route_suffix']; $key = empty($suffix) ? str_replace('Action', '', substr($type, strrpos($type, '\\') + 1)) : $suffix; $this->actions->set(strtolower($key), $action); return $this; }
public function add(IEntity $entity) { $this->errorOnInvalidEntityType($entity); if ($this->getIdentityValue($entity) < 1) { $this->setIdentityValue($entity, $this->collection->count() + 1); } $this->collection->set($entity->getId(), $entity); }
public function build(\SimplePie_Item $feed) { $data = new ArrayCollection(); $data->set('title', $feed->get_title()); $data->set('url', $feed->get_permalink()); $data->set('description', $feed->get_description()); return $data; }
public function addBundle(BaseBundle $bundle) { if (!$this->bundles->containsKey($bundle->name)) { $bundle->map = $this; $this->bundles->set($bundle->name, $bundle); } return $this; }
public function addModel(BaseModel $model) { if (!$this->models->containsKey($model->name)) { $model->bundle = $this; $this->models->set($model->name, $model); } return $this; }
public function setDefaultConfig($key, $value, $type, $section = "default") { $valueArray = new \Doctrine\Common\Collections\ArrayCollection(); $valueArray->set('value', $value); $valueArray->set('section', $section); $valueArray->set('key', $key); $valueArray->set('type', $type); $this->configList->set($section . '.' . $key, $valueArray); }
/** * @param Car $car * @return boolean */ public function add(Car $car) { if ($this->has($car)) { return false; } $this->cars->set($car->getId(), 1); $this->session->set('cart', $this->cars); return true; }
/** * Add activity * * @param Activity $activity * @return Student */ public function addActivity(Activity $activity) { $key = $activity->getMachineName(); if ($this->activities->containsKey($key)) { throw new \InvalidArgumentException('This Student already belongs to this Activity'); } $this->activities->set($key, $activity); return $this; }
/** * Constructor * * @param string $text * @param WordFactory $wordFactory */ public function __construct($text, WordFactory $wordFactory) { $this->text = $text; $this->words = new ArrayCollection(explode(' ', $text)); $this->words->forAll(function ($index, $word) use($wordFactory) { $this->words->set($index, $wordFactory->make($word)); return true; }); }
/** * Set registered types * * @param string $typeName * @param IntegrationInterface $type * * @throws \LogicException * @return $this */ public function addChannelType($typeName, IntegrationInterface $type) { if (!$this->integrationTypes->containsKey($typeName)) { $this->integrationTypes->set($typeName, $type); } else { throw new LogicException(sprintf('Trying to redeclare integration type "%s".', $typeName)); } return $this; }
/** * @param Ignored $ignored * * @return IgnoredRepository */ public function replace(Ignored $ignored) { foreach ($this->ignores as $key => $value) { if ($value->getId() === $ignored->getId()) { $this->ignores->set($key, $ignored); return $this; } } return $this; }
protected function _initSettings() { $this->_setSocialSetting($this->em->getRepository("AppBundle:SocialSetting")->findOneBySocialSettingStringId(self::STRING_ID)); $q = $this->em->createQuery("\n SELECT d FROM AppBundle\\Entity\\SocialSettingData d\n WHERE d.socialSettingId = :id\n ")->setParameter('id', $this->getSocialSetting()->getSocialSettingId()); $result = $q->getResult(); $this->_settings = new \Doctrine\Common\Collections\ArrayCollection(); /* @var $setting \AppBundle\Entity\SocialSettingData */ foreach ($result as $setting) { $this->_settings->set($setting->getSocialSettingDataKey(), $setting->getSocialSettingDataValue()); } }
/** * @param string $field * @param mixed $type * @param array $options * @return FilterProvider */ protected function addFilter(string $field, $type, array $options = []) : self { if (is_string($type) || $type instanceof FilterTypeInterface) { $filter = $this->factory->get($type, $options); } elseif (is_callable($type)) { $filter = $type; } else { throw new \InvalidArgumentException('Expected argument of type "callable", "string" or class Vardius\\Bundle\\ListBundle\\Filter\\Types\\FilterTypeInterface, ' . get_class($type) . ' given'); } $this->filters->set($field, $filter); return $this; }
public function set($key, $value) { if (null === $this->entries) { $this->__load___(); } $this->entries->set($key, $value); }
public function addKey($name, $value) { if (!$this->keys->containsKey($name)) { $this->keys->set($name, $value); } return $this; }
/** * Add a parameter to the class * * @param ParameterModel $parameterModel * @return $this */ public function addParameter(ParameterModel $parameterModel) { $parameterName = $parameterModel->getName(); Tebru\assertArrayKeyNotExists($parameterName, $this->parameters->toArray(), 'Parameter "%s" already exists in method', $parameterName); $this->parameters->set($parameterName, $parameterModel); return $this; }
static function load(Config $config) { $scenes = new ArrayCollection(); // Start with the entry scene $stack = array(); $scene = $config['entry_scene']; array_push($stack, $scene); // Loop until our stack is empty while (count($stack)) { // Load a scene from the stack $scenePath = array_pop($stack); $data = Yaml::load($config['base_directory'] . '/' . $scenePath . '.yml'); // Create a scene from the data $newScene = new Scene($scenePath, $data); $scenes->set($scenePath, $newScene); // If we have exit-scenes, add them to the stack so we can load them foreach ($data['scene']['exit'] as $direction => $exitScene) { $tmp['exit'][strtolower($direction)] = $exitScene; // Only add to stack when we haven't already processed that scene if (!$scenes->containsKey($exitScene)) { array_push($stack, $exitScene); } } } return $scenes; }
/** * {@inheritDoc} * * @throws \UnexpectedValueException */ public function set($key, $value) { if (!$this->checkType($value)) { throw new \UnexpectedValueException(sprintf(self::$exceptionErrorMessage, 2, __CLASS__, 'set', $this->getType(), $this->getItemType($value))); } parent::set($key, $value); }
/** * Collect all order subtotals * * @param Order $order * * @return ArrayCollection|Subtotal[] */ public function getSubtotals(Order $order) { $subtotals = new ArrayCollection(); $subtotal = $this->getSubtotal($order); $subtotals->set($subtotal->getType(), $subtotal); return $subtotals; }
/** * Add a property to the class * * @param PropertyModel $propertyModel * @return $this */ public function addProperty(PropertyModel $propertyModel) { $propertyName = $propertyModel->getName(); Tebru\assertArrayKeyNotExists($propertyName, $this->properties->toArray(), 'Property "%s" already exists on class', $propertyName); $this->properties->set($propertyName, $propertyModel); return $this; }
/** * {@inheritdoc} */ public function set($key, $value) { foreach ($this->fields as $managerName => $method) { call_user_func(array(self::getElementMethod($this->model, $managerName, $method), 'set'), $key, call_user_func(array($value, $managerName))); } parent::set($key, $value); }
/** * @return mixed */ public function addAttribute($name, $value) { if (!$this->attributes->offsetExists($name)) { $this->attributes->set($name, $value); } return $this; }
public function addQuestion(SurveyQuestion $question) { if (!$this->questions->contains($question)) { $this->questions->set($question->getField()->getName(), $question); $question->setSurvey($this); } }
public function addMedia(Media $media) { if (!$this->medias->contains($media)) { $media->setProduct($this); $this->medias->set($media->getLocale(), $media); } return $this; }
/** * @param $name * @param Command $command * @param $arguments * @param $priority */ public function addCommand($name, Command $command, $arguments, $priority) { if (!$this->commands->containsKey($name)) { $this->commands->set($name, new ArrayCollection()); } $meta = new CommandMeta($command, $arguments, $priority); $this->commands->get($name)->add($meta); }