public function retrieveUsers($date)
 {
     $users = new \Doctrine\Common\Collections\ArrayCollection();
     $articleRepo = $this->getManager()->getRepository('AppBundle:Article');
     $articles = $articleRepo->findWithNotifications($date);
     foreach ($articles as $article) {
         if ($article->getAnswers()->count()) {
             foreach ($article->getAnswers() as $answer) {
                 if ($answer->getCreated() < $date && !$answer->getEmailSent()) {
                     if (!$users->contains($answer->getUser())) {
                         $users->add($answer->getUser());
                     }
                     $answer->setEmailSent(true);
                     $this->getEntityManager()->persist($answer);
                     $this->getEntityManager()->flush($answer);
                 }
             }
         }
         if ($article->getRatings()->count()) {
             foreach ($article->getRatings() as $rating) {
                 if ($rating->getCreated() < $date && $rating->getEmailSent()) {
                     if (!$users->contains($rating->getUser())) {
                         $users->add($rating->getUser());
                     }
                     $rating->setEmailSent(true);
                     $this->getEntityManager()->persist($rating);
                     $this->getEntityManager()->flush($rating);
                 }
             }
         }
     }
     return $users;
 }
Exemple #2
0
 public function testGetAddRemoveRoles()
 {
     $roles = new \Doctrine\Common\Collections\ArrayCollection();
     $roles->add($this->getMock('Usermanager\\Entity\\Role'));
     $roles->add($this->getMock('Usermanager\\Entity\\Role'));
     $this->assertCount(0, $this->entity->getRoles());
     $this->entity->addRoles($roles);
     $this->assertCount(2, $this->entity->getRoles());
     $this->entity->removeRoles($roles);
     $this->assertCount(0, $this->entity->getRoles());
 }
 private function mockRepository()
 {
     $productRepository = $this->getMockBuilder('\\Doctrine\\ORM\\EntityRepository')->disableOriginalConstructor()->getMock();
     $productRepository->expects($this->any())->method('find')->will($this->returnValue($this->mockProduct()));
     $products = new Doctrine\Common\Collections\ArrayCollection();
     $products->add($this->mockProduct());
     $products->add($this->mockProduct());
     $products->add($this->mockProduct());
     $productRepository->expects($this->any())->method('findAll')->will($this->returnValue($products));
     return $productRepository;
 }
Exemple #4
0
 public function testGetAddRemovePermissions()
 {
     $permissions = new \Doctrine\Common\Collections\ArrayCollection();
     $permissions->add($this->getMock('Usermanager\\Entity\\Permission'));
     $permissions->add($this->getMock('Usermanager\\Entity\\Permission'));
     $this->assertCount(0, $this->entity->getPermissions());
     $this->entity->addPermissions($permissions);
     $this->assertCount(2, $this->entity->getPermissions());
     $this->entity->removePermissions($permissions);
     $this->assertCount(0, $this->entity->getPermissions());
 }
 /**
  * @test
  */
 public function setQuestionsWorks()
 {
     $question1 = new MultipleChoiceQuestion();
     $question2 = new MultipleChoiceQuestion();
     $questions = new \Doctrine\Common\Collections\ArrayCollection();
     $questions->add($question1);
     $questions->add($question2);
     $exercise = new MultipleChoiceSameAnswerExercise();
     $exercise->setQuestions($questions);
     $this->assertEquals(2, $exercise->getMaxScore());
 }
Exemple #6
0
 /**
  * Tests if a returned collection of UserEntity objects is of the correct type and
  * of the correct length.
  */
 public function testGetUserEntityCollectionSucessful()
 {
     $expectedUserEntityCollection = new \Doctrine\Common\Collections\ArrayCollection();
     $expectedUserEntityCollection->add(new Entity\UserEntity());
     $expectedUserEntityCollection->add(new Entity\UserEntity());
     $expectedUserEntityCollection->add(new Entity\UserEntity());
     $mockUserRepository = $this->getMockUserRepository();
     $mockUserRepository->method('getUserEntityCollection')->will($this->returnValue($expectedUserEntityCollection));
     $userManager = new UserManager();
     $userManager->setUserRepository($mockUserRepository);
     $userEntityCollection = $userManager->getUserEntityCollection();
     $this->assertInstanceOf('Doctrine\\Common\\Collections\\ArrayCollection', $userEntityCollection);
     $this->assertEquals(count($userEntityCollection), count($expectedUserEntityCollection));
 }
 public function reverseTransform($string)
 {
     if ($this->options['multiple']) {
         if (!$string) {
             $result = new \Doctrine\Common\Collections\ArrayCollection();
         } else {
             $items = explode(',', $string);
             $result = new \Doctrine\Common\Collections\ArrayCollection();
             $repo = $this->repository;
             foreach ($items as $item) {
                 $id = preg_replace('/^([0-9]+)\\:.*/', '$1', $item);
                 $itemEntity = $repo->findOneById((int) $id);
                 if (is_object($itemEntity)) {
                     $result->add($itemEntity);
                 }
             }
         }
     } else {
         if (!$string) {
             $result = null;
         } else {
             $id = preg_replace('/^([0-9]+)\\:.*/', '$1', $string);
             $itemEntity = $this->repository->findOneById((int) $id);
             if (is_object($itemEntity)) {
                 $result = $itemEntity;
             }
         }
     }
     return $result;
 }
 /**
  *
  * @param string $string String to transform
  *
  * @return Tag $tag
  *
  */
 public function reverseTransform($string)
 {
     $tags = new \Doctrine\Common\Collections\ArrayCollection();
     $arrayOfTags = explode(",", $string);
     foreach ($arrayOfTags as $nameOfTag) {
         $result = $this->om->getRepository('AcmeBlogBundle:Tag')->findOneByName($nameOfTag);
         if (!$result) {
             //Action when tag don't exist
             $tag = new Tag();
             $tag->setName($nameOfTag);
             $tags->add($tag);
         } else {
             $tags->add($result);
         }
     }
     return $tags;
 }
Exemple #9
0
 /**
  * @return \Doctrine\Common\Collections\ArrayCollection
  */
 public function getRootMenuItems()
 {
     $rootItems = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($this->menuItems as &$m) {
         if ($m->parent == null) {
             $rootItems->add($m);
         }
     }
     return $rootItems;
 }
Exemple #10
0
 /**
  * Takes a pile of commits, then puts together all the repositories that are affected by
  * at least one of the given commits.
  *
  * @param \TYPO3\Flow\Persistence\QueryResultInterface the pile of commits
  * @return \Doctrine\Common\Collections\ArrayCollection the resulting stack of repositories
  */
 public function extractTheRepositoriesFromAStackOfCommits(\TYPO3\Flow\Persistence\QueryResultInterface $commits)
 {
     $result = new \Doctrine\Common\Collections\ArrayCollection();
     if ($commits->count()) {
         foreach ($commits as $commit) {
             if (!$result->contains($commit->getRepository())) {
                 $result->add($commit->getRepository());
             }
         }
     }
     return $result;
 }
Exemple #11
0
 /**
  * Transforms a string (number) to an object (issue).
  *
  * @param  string $number
  *
  * @return Issue|null
  *
  * @throws TransformationFailedException if object (issue) is not found.
  */
 public function reverseTransform($tags)
 {
     if (!$tags) {
         return null;
     }
     $tags = explode($this->separator, $tags);
     $ret = array();
     $collection = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($tags as $t) {
         if ($tmp = $this->om->getRepository(MyTag::class)->findOneBy(['name' => $t])) {
             $collection->add($tmp);
         } else {
             $tag = new MyTag();
             $tag->setName($t);
             $this->om->persist($tag);
             $this->om->flush();
             /*Add ne tag to collection*/
             $collection->add($tag);
         }
     }
     return $collection;
 }
 /**
  * @dataProvider questionDataProvider
  * @param array $data
  */
 public function testGetQuestions($data)
 {
     $exercise = new DragAndDropWordToQuestionExercise();
     $questions = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($data as $row) {
         $question = new DragAndDropQuestion();
         $question->setQuestion($row['question']);
         $question->setAnswer($row['answer']);
         $questions->add($question);
     }
     $this->assertNull($exercise->setQuestions($questions));
     $this->assertSame($questions, $exercise->getQuestions());
 }
 /**
  * @dataProvider questionsDataProvider
  * @param array $data
  */
 public function testSetQuestions($data)
 {
     $exercise = new SpellingAndGrammarCommaExercise();
     $questions = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($data as $row) {
         $question = new SpellingAndGrammarCommaQuestion();
         $question->setQuestionWithComma($row['questionWithComma']);
         $question->setQuestionWithoutComma($row['questionWithoutComma']);
         $questions->add($question);
     }
     $this->assertNull($exercise->setQuestions($questions));
     $this->assertSame($questions, $exercise->getQuestions());
 }
 /**
  * @test
  * @author Christopher Hlubek <*****@*****.**>
  */
 public function entityReferencesReturnsSimpleAndArrayReferences()
 {
     $baseEntity = new \TYPO3\CouchDB\Tests\Functional\Fixtures\Domain\Model\TestEntity();
     $simpleReferencedEntity = new \TYPO3\CouchDB\Tests\Functional\Fixtures\Domain\Model\TestEntity();
     $baseEntity->setRelatedEntity($simpleReferencedEntity);
     $arrayReferencedEntity = new \TYPO3\CouchDB\Tests\Functional\Fixtures\Domain\Model\TestEntity();
     $relatedEntities = new \Doctrine\Common\Collections\ArrayCollection();
     $relatedEntities->add($arrayReferencedEntity);
     $relatedEntities->add($baseEntity);
     $baseEntity->setRelatedEntities($relatedEntities);
     $this->persistenceManager->add($baseEntity);
     $baseIdentifier = $this->persistenceManager->getIdentifierByObject($baseEntity);
     $simpleReferenceIdentifier = $this->persistenceManager->getIdentifierByObject($simpleReferencedEntity);
     $arrayReferenceIdentifier = $this->persistenceManager->getIdentifierByObject($arrayReferencedEntity);
     $this->persistenceManager->persistAll();
     $identifiers = $this->design->entityReferences($simpleReferenceIdentifier);
     $this->assertEquals(1, count($identifiers));
     $this->assertEquals($baseIdentifier, $identifiers[0]);
     $identifiers = $this->design->entityReferences($arrayReferenceIdentifier);
     $this->assertEquals(1, count($identifiers));
     $this->assertEquals($baseIdentifier, $identifiers[0]);
     $identifiers = $this->design->entityReferences($baseIdentifier);
     $this->assertEquals(0, count($identifiers));
 }
 /**
  * Transforms a string (id) to an object (media).
  *
  * @param string $id
  *
  * @return Media|null
  *
  * @throws TransformationFailedException if object (media) is not found.
  */
 public function reverseTransform($array)
 {
     $medias = new \Doctrine\Common\Collections\ArrayCollection();
     if (!$array || !preg_match('#^[0-9]+(;[0-9])*$#', $array)) {
         return $medias;
     }
     $ids = explode(';', $array);
     foreach ($ids as $id) {
         $media = $this->objectManager->getRepository($this->mediaClass)->find($id);
         if (null === $media) {
             throw new TransformationFailedException(sprintf('Media "%s" is not found !', $id));
         }
         $medias->add($media);
     }
     return $medias;
 }
 /**
  * Transforms a string (id) to an object (PlaceImage).
  *
  * @param  string $ids
  *
  * @return PlaceImage[]|null
  *
  * @throws TransformationFailedException if object (PlaceImage) is not found.
  */
 public function reverseTransform($ids)
 {
     //var_dump($ids);die('transformer');
     if (!$ids) {
         return null;
     }
     $ids = explode($this->separator, $ids);
     $collection = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($ids as $id) {
         if ($tmp = $this->om->getRepository(PlaceHallImage::class)->findOneBy(['id' => $id])) {
             //var_dump($tmp);die();
             $collection->add($tmp);
         }
     }
     return $collection;
 }
 /**
  * @param \BoilerAppAccessControl\Entity\AuthAccessEntity $oAuthAccess
  * @return \Doctrine\Common\Collections\ArrayCollection
  */
 public function getLatestActivityLogs(\BoilerAppAccessControl\Entity\AuthAccessEntity $oAuthAccess)
 {
     $oLatestsActivityLogs = new \Doctrine\Common\Collections\ArrayCollection();
     while ($oLatestsActivityLogs->count() < 5) {
         $oCriteria = new \Doctrine\Common\Collections\Criteria(null, array('entity_create' => 'DESC'), null, 1);
         $aCriteria = array();
         if ($oLatestsActivityLogs->count()) {
             $oLastLog = $oLatestsActivityLogs->last();
             $oCriteria->andWhere(\Doctrine\Common\Collections\Criteria::expr()->neq('log_session_id', $oLastLog->getLogSessionId()))->andWhere(\Doctrine\Common\Collections\Criteria::expr()->lt('entity_create', $oLastLog->getEntityCreate()));
         }
         if (!($oLogs = $this->matching($oCriteria)) || !$oLogs->count()) {
             break;
         }
         $oLatestsActivityLogs->add($oLogs->current());
     }
     return $oLatestsActivityLogs;
 }
 /**
  * Count the total of rows
  *
  * @return int
  */
 public function getAdverts($start, $end, $section = null)
 {
     if ($count == 0) {
         $count2 = 0;
         $qb2 = $this->getQueryBuilder()->join('a.located', 'l')->where('l.name = :section')->andWhere('a.from <= :start')->andWhere('a.to >= :end')->andWhere('a.active = :active')->setParameters(array('section' => $section, 'start' => $start, 'end' => $end, 'active' => true));
         $query = $qb2->getQuery();
     }
     //->orderBy('s.day', 'ASC')
     $adverts = array();
     if (is_object($query)) {
         $adverts = $query->getResult();
     }
     $arr = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($adverts as $ad) {
         $arr->add($ad);
     }
     return $arr;
 }
 public function onFlush(OnFlushEventArgs $args)
 {
     if (PHP_SAPI === 'cli') {
         return;
     }
     $this->em = $args->getEntityManager();
     $eventManager = $this->em->getEventManager();
     $eventManager->removeEventListener('onFlush', $this);
     $this->uow = $this->em->getUnitOfWork();
     $histories = new \Doctrine\Common\Collections\ArrayCollection();
     $this->hmeta = $this->em->getClassMetadata('DLigo\\Animaltool\\Domain\\Model\\HistoryChange');
     $user = $this->session->getUser();
     $this->userId = $this->persistenceManager->getIdentifierByObject($user);
     $this->userLabel = $user->__toString();
     foreach ($this->uow->getScheduledEntityInsertions() as $entity) {
         $meta = $this->em->getClassMetadata(get_class($entity));
         $this->putAnimal($entity, $meta);
         $history = array('entity' => $entity, 'changes' => $this->uow->getEntityChangeSet($entity), 'meta' => $meta, 'type' => 'INSERT');
         $histories->add($history);
         $this->em->getUnitOfWork()->recomputeSingleEntityChangeSet($meta, $entity);
     }
     foreach ($this->uow->getScheduledEntityDeletions() as $entity) {
         $meta = $this->em->getClassMetadata(get_class($entity));
         $this->putAnimal($entity, $meta);
         $history = array('entity' => $entity, 'changes' => null, 'meta' => $meta, 'type' => 'DELETE');
         $histories->add($history);
     }
     foreach ($this->uow->getScheduledEntityUpdates() as $key => $entity) {
         $meta = $this->em->getClassMetadata(get_class($entity));
         $this->putAnimal($entity, $meta);
         $history = array('entity' => $entity, 'changes' => $this->uow->getEntityChangeSet($entity), 'meta' => $meta, 'type' => 'UPDATE');
         $histories->add($history);
         $this->uow->computeChangeSet($meta, $entity);
     }
     foreach ($histories as $h) {
         $this->processHistory($h);
     }
     $eventManager->addEventListener('onFlush', $this);
 }
Exemple #20
0
 public function __clone()
 {
     if ($this->id) {
         $this->id = null;
         $newWordResponses = new \Doctrine\Common\Collections\ArrayCollection();
         foreach ($this->wordResponses as $wordResponse) {
             $newWordResponse = clone $wordResponse;
             $newWordResponse->setHole($this);
             $newWordResponses->add($newWordResponse);
         }
         $this->wordResponses = $newWordResponses;
     }
 }
 /**
  * @covers Core\Entity\SubjectRound::addTeacher
  * @covers Core\Entity\SubjectRound::removeTeacher
  */
 public function testAddRemoveTeacher()
 {
     $sr = new SubjectRound();
     $this->assertEquals(0, $sr->getTeacher()->count());
     $mockTeacher = $this->getMockBuilder('Core\\Entity\\Teacher')->getMock();
     $teachers = new \Doctrine\Common\Collections\ArrayCollection();
     $teachers->add($mockTeacher);
     $sr->addTeacher($teachers);
     $this->assertEquals(1, $sr->getTeacher()->count());
     $this->assertEquals($mockTeacher, $sr->getTeacher()->first());
     $sr->removeTeacher($teachers);
     $this->assertEquals(0, $sr->getTeacher()->count());
 }
Exemple #22
0
 /**
  * Get exploitations
  *
  * @return \Doctrine\Common\Collections\Collection 
  */
 public function getExploitations()
 {
     $exploitations = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($this->apiculteurExploitations as $apiculteurExploitation) {
         $exploitations->add($apiculteurExploitation->getExploitation());
     }
     return $exploitations;
 }
 /**
  * @test
  */
 public function reconstituteCollectionWorks()
 {
     $mockObject1 = new \stdClass();
     $mockObject2 = new \stdClass();
     $objectsAsArray = ['some object' => ['object1 data'], 'some other object' => ['object2 data']];
     $objectSerializer = $this->getAccessibleMock(ObjectSerializer::class, ['reconstituteObject'], [], '', false);
     $objectSerializer->expects($this->at(0))->method('reconstituteObject')->with('some object', ['object1 data'])->will($this->returnValue($mockObject1));
     $objectSerializer->expects($this->at(1))->method('reconstituteObject')->with('some other object', ['object2 data'])->will($this->returnValue($mockObject2));
     $objectSerializer->_set('objectsAsArray', $objectsAsArray);
     $dataArray = ['some object', 'some other object'];
     $expectedResult = new \Doctrine\Common\Collections\ArrayCollection();
     $expectedResult->add($mockObject1);
     $expectedResult->add($mockObject2);
     $this->assertEquals($expectedResult, $objectSerializer->_call('reconstituteCollection', 'Doctrine\\Common\\Collections\\ArrayCollection', $dataArray), 'The Collection was not reconstituted correctly.');
 }
Exemple #24
0
 /**
  * Helper function to set the association data of a ORM\OneToMany association of doctrine.
  * <br><br>
  * The <b>$data</b> parameter contains the data for the collection property. It can contains an array of
  * models or data arrays. If the $data parameter is set to null the associated collection will cleared.
  * <br><br>
  * The <b>$model</b> parameter expects the full name of the associated model.
  * For example:
  * <ul>
  * <li>We are in the Customer model in the setOrders() function.</li>
  * <li>Here we want to set the Order objects over the "setOneToMany" function</li>
  * <li>So we passed as $model parameter: <b>"\Shopware\Models\Order\Order"</b></li>
  * </ul>
  * <br>
  * The <b>$property</b> parameter expect the name of the association property.
  * For example:
  * <ul>
  * <li>In the setOrders() function of the customer model we would expects <b>"orders"</b>.</li>
  * </ul>
  * <br>
  * The <b>$reference</b> property expect the name of the property on the other side of the association.
  * For example:
  * <ul>
  * <li>In the setOrders() function we want to fill the orders data.</li>
  * <li>To set the reference between customer and orders we set in the orders object the "customer"</li>
  * <li>To set the customer we use the "$order->setCustomer()" function.</li>
  * <li>So the parameter expect <b>"customer"</b></li>
  * </ul>
  *
  * @param array|null $data Model data, example: an array of \Shopware\Models\Order\Order
  * @param string $model Full namespace of the association model, example: '\Shopware\Models\Order\Order'
  * @param string $property Name of the association property, example: 'orders'
  * @param string $reference Name of the reference property, example: 'customer'
  * @return \Shopware\Components\Model\ModelEntity
  */
 public function setOneToMany($data, $model, $property, $reference = null)
 {
     $getterFunction = "get" . ucfirst($property);
     $setterFunction = null;
     if ($reference !== null) {
         $setterFunction = "set" . ucfirst($reference);
     }
     //to remove the whole one to many association, u can pass null as parameter.
     if ($data === null) {
         $this->{$getterFunction}()->clear();
         return $this;
     }
     //if no array passed or if false passed, return
     if (!is_array($data)) {
         return $this;
     }
     //create a new collection to collect all updated and created models.
     $updated = new \Doctrine\Common\Collections\ArrayCollection();
     //iterate all passed items
     foreach ($data as $item) {
         //to get the right collection item use the internal helper function
         if (is_array($item) && isset($item['id']) && $item['id'] !== null) {
             $attribute = $this->getArrayCollectionElementById($this->{$getterFunction}(), $item['id']);
             if (!$attribute instanceof $model) {
                 $attribute = new $model();
             }
             //if the item is an array without an id, create a new model.
         } elseif (is_array($item)) {
             $attribute = new $model();
             //if the item is no array, it could be an instance of the expected object.
         } else {
             $attribute = $item;
         }
         //check if the object correctly initialed. If this is not the case continue.
         if (!$attribute instanceof $model) {
             continue;
         }
         //if the current item is an array, use the from array function to set the data.
         if (is_array($item)) {
             $attribute->fromArray($item);
         }
         //after the attribute filled with data, set the association reference and add the model to the internal collection.
         if ($setterFunction !== null) {
             $attribute->{$setterFunction}($this);
         }
         if (!$this->{$getterFunction}()->contains($attribute)) {
             $this->{$getterFunction}()->add($attribute);
         }
         //add the model to the updated collection to have an flag which models updated.
         $updated->add($attribute);
     }
     //after all passed data items added to the internal collection, we have to iterate the items
     //to remove all old items which are not updated.
     foreach ($this->{$getterFunction}() as $attr) {
         //the updated collection contains all updated and created models.
         if (!$updated->contains($attr)) {
             $this->{$getterFunction}()->removeElement($attr);
         }
     }
     return $this;
 }
Exemple #25
0
 public function appendContribution($contribution)
 {
     $this->contributions->add($contribution);
 }
Exemple #26
0
 protected function cloneProducts($products, $newCart)
 {
     $newProducts = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($products as $product) {
         //            dump($newCart);
         $newProduct = clone $product;
         $newProducts->add($newProduct);
     }
     dump($newProducts);
     return $newProducts;
 }
Exemple #27
0
 /**
  * Helper function returns total count of the passed query builder
  *
  * @param \Doctrine\ORM\Query $dataQuery
  * @return int|null
  */
 private function getStatisticListTotalCount(\Doctrine\ORM\Query $dataQuery)
 {
     //userCurrencyFactor has not to be part of the count parameters
     $originalParameters = $dataQuery->getParameters();
     $countParameters = new \Doctrine\Common\Collections\ArrayCollection();
     /** @var \Doctrine\ORM\Query\Parameter $parameter */
     foreach ($originalParameters as $parameter) {
         if ($parameter->getName() === 'userCurrencyFactor') {
             continue;
         }
         $countParameters->add($parameter);
     }
     $dataQuery->setParameters($countParameters);
     $totalCount = Shopware()->Models()->getQueryCount($dataQuery);
     $dataQuery->setParameters($originalParameters);
     return $totalCount;
 }
Exemple #28
0
 /**
  * @api
  * @return \Doctrine\Common\Collections\ArrayCollection
  */
 public function getResult()
 {
     $result = $this->execute();
     $list = new \Doctrine\Common\Collections\ArrayCollection();
     foreach ($result as $row) {
         $entry = array();
         foreach ($row as $key => $value) {
             $entry[$key] = $this->convertValue($value);
         }
         $list->add($entry);
     }
     return $list;
 }
Exemple #29
0
    /**
     * @param array $data
     * @param \Shopware\Models\Article\Article $article
     * @throws \Shopware\Components\Api\Exception\CustomValidationException
     * @return array
     */
    protected function prepareVariants($data, ArticleModel $article)
    {
        unset($data['details']);

        if (!isset($data['variants'])) {
            return $data;
        }

        $variants = array();
        foreach ($data['variants'] as $variantData) {

            if (isset($variantData['id'])) {
                $variant = $this->getManager()->getRepository('Shopware\Models\Article\Detail')->findOneBy(array(
                    'id'        => $variantData['id'],
                    'articleId' => $article->getId()
                ));

                if (!$variant) {
                    throw new ApiException\CustomValidationException(sprintf("Variant by id %s not found", $variantData['id']));
                }
            } elseif (isset($variantData['number'])) {
                $variant = $this->getManager()->getRepository('Shopware\Models\Article\Detail')->findOneBy(array(
                    'number'    => $variantData['number'],
                    'articleId' => $article->getId()
                ));
            }

            if (!$variant) {
                $variant = new \Shopware\Models\Article\Detail();
                $variant->setKind(2);
            }

            $variantData = $this->prepareVariantAssociatedData($variantData);
            $variantData = $this->prepareVariantPricesAssociatedData($data, $variantData, $article, $variant);
            $variantData = $this->prepareVariantAttributeAssociatedData($variantData, $article, $variant);

            $variant->fromArray($variantData);

            if (isset($variantData['configuratorOptions']) && is_array($variantData['configuratorOptions'])) {
                $configuratorSet = $article->getConfiguratorSet();

                if (!$configuratorSet && !isset($data['configuratorSet'])) {
                    throw new ApiException\CustomValidationException('A configuratorset has to be defined');
                }

                /** @var \Shopware\Models\Article\Configurator\Set $configuratorSet */
                if ($configuratorSet) {
                    $availableGroups = $configuratorSet->getGroups();
                } else {
                    $configuratorSet = $data['configuratorSet'];
                    $availableGroups = $configuratorSet->getGroups();
                }

                $assignedOptions = new \Doctrine\Common\Collections\ArrayCollection();
                foreach ($variantData['configuratorOptions'] as $configuratorOption) {
                    $group  = $configuratorOption['group'];
                    $option = $configuratorOption['option'];

                    /** @var \Shopware\Models\Article\Configurator\Group $availableGroup */
                    foreach ($availableGroups as $availableGroup) {
                        if ($availableGroup->getName() == $group) {
                            $optionExists = false;
                            /** @var \Shopware\Models\Article\Configurator\Option $availableOption */
                            foreach ($availableGroup->getOptions() as $availableOption) {
                                if ($availableOption->getName() == $option) {
                                    $assignedOptions->add($availableOption);
                                    $optionExists = true;
                                    break;
                                }
                            }

                            if (!$optionExists) {
                                $optionModel = new \Shopware\Models\Article\Configurator\Option();
                                $optionModel->setPosition(0);
                                $optionModel->setName($option);
                                $optionModel->setGroup($availableGroup);
                                $this->getManager()->persist($optionModel);
                                $assignedOptions->add($optionModel);
                            }
                        }
                    }
                }

                $variant->setConfiguratorOptions($assignedOptions);
            }

            if (count($variant->getConfiguratorOptions()) === 0) {
                throw new \Exception('No Configurator Options assigned');
            }

            if ($variantData['isMain'] || $variantData['standard']) {
                $newMain = $variant;
                $newMain->setKind(1);

                // todo@dn Check if has configurator - delete else
                $oldMain = $data['mainDetail'];
                $oldMain['kind'] = 2;

                $data['mainDetail'] = $newMain;
//                $variant = $oldMain;
            }

            $variants[] = $variant;
        }

        $data['details'] = $variants;
        unset($data['variants']);

        return $data;
    }
 /**
  * Set authors for article, if author doesn't exist it gets created
  *
  * @param \Newscoop\Entity\Article                       $article Article
  * @param \Newscoop\IngestPluginBundle\Entity\Feed\Entry $entry   Entity
  */
 protected function setArticleAuthors(\Newscoop\Entity\Article $article, \Newscoop\IngestPluginBundle\Entity\Feed\Entry $entry)
 {
     $repository = $this->em->getRepository('\\Newscoop\\Entity\\Author');
     $doctrineCollection = new \Doctrine\Common\Collections\ArrayCollection();
     $authors = $entry->getAuthors();
     if (count($authors) > 0) {
         foreach ($authors as $author) {
             $authorEntity = $repository->findBy(array('first_name' => $author['firstname'], 'last_name' => $author['lastname']));
             if ($authorEntity === null) {
                 $authorEntity = new \Newscoop\Entity\Author($author['firstname'], $author['lastname']);
             }
             $doctrineCollection->add($authorEntity);
         }
         $article->setArticleAuthors($doctrineCollection);
     }
 }