PHP EntityRepository::getClassName方法代码示例

 /**
  * {@inheritdoc}
  */
 public function reverseTransform($value)
 {
     if (!$value) {
         return null;
     }
     $entity = $this->repository->findOneBy(array($this->identifier => $value));
     if (null === $entity) {
         throw new TransformationFailedException(sprintf('Entity "%s" with identifier "%s"="%s" does not exist.', $this->repository->getClassName(), $this->identifier, $value));
     }
     return $entity;
 }

 /**
  * @param mixed $value
  *
  * @throws BadRequestException
  *
  * @return object
  */
 public function filterIn($value)
 {
     if (!is_object($value)) {
         $entity = $this->repository->find($value);
     } elseif ($value instanceof QueryInterface) {
         $entity = $value->getEntity($this->repository);
     }
     $class = $this->repository->getClassName();
     if (!$entity instanceof $class) {
         throw new BadRequestException('Desired entity of type \'' . $this->repository->getClassName() . '\' could not be found.');
     }
     return $entity;
 }

 public function findOneFolderByPath($path)
 {
     //Find a folder entity in db
     $folder = $this->folderRepo->findOneByPath($path);
     if (!$folder) {
         $class = $this->folderRepo->getClassName();
         $folder = new $class();
         $folder->setName(basename($path));
         $folder->setPath($path);
         $this->em->persist($folder);
     }
     return $folder;
 }

 /**
  * @param mixed $entity
  * @return mixed|null
  */
 public function transform($entity)
 {
     if (null === $entity) {
         return null;
     }
     $className = $this->repository->getClassName();
     if (!$entity instanceof $className) {
         throw new TransformationFailedException(sprintf('Object must be instance of %s, instance of %s has given.', $className, get_class($entity)));
     }
     $methodName = 'get' . ucfirst($this->property);
     if (!method_exists($entity, $methodName)) {
         throw new InvalidConfigurationException(sprintf('There is no getter for property "%s" in class "%s".', $this->property, $this->class));
     }
     return $entity->{$methodName}();
 }

 public function total()
 {
     $metadata = $this->em->getClassMetadata($this->repository->getClassName());
     $identifiers = $metadata->getIdentifierFieldNames();
     $id = $identifiers[0];
     return $this->repository->createQueryBuilder("q")->select("COUNT(q.{$id})")->getQuery()->getSingleScalarResult();
 }

 /**
  * Returns OrderType entity with given id.
  *
  * @param int $typeId
  *
  * @throws EntityNotFoundException
  *
  * @return null|OrderType
  */
 public function getOrderTypeEntityById($typeId)
 {
     // Get desired status.
     $typeEntity = $this->orderTypeRepository->find($typeId);
     if (!$typeEntity) {
         throw new EntityNotFoundException($this->orderTypeRepository->getClassName(), $typeId);
     }
     return $typeEntity;
 }

 /**
  * @return mixed
  */
 public function create()
 {
     $className = $this->source->getClassName();
     return new $className();
 }

 /**
  * @return string
  */
 public function getClassName()
 {
     return parent::getClassName();
 }

 public function __construct(EntityRepository $repository)
 {
     $this->repository = $repository;
     $this->entity = $repository->getClassName();
 }

 /**
  * @param $entities
  * @param $params
  * @param $method
  * @return bool
  */
 public function batchUpdate($entities, $params, $method)
 {
     $className = $this->repository->getClassName();
     return $this->formHandler->batchProcessForm(new EntitiesHolder($entities), ['entities' => $params], $method, new $className());
 }

 /**
  * Returns the class name of the object managed by the repository.
  *
  * @return string
  */
 public function getClassName()
 {
     return $this->repository->getClassName();
 }

 /**
  * @param int $id
  * @param EntityRepository $repository
  *
  * @param null $label
  *
  * @return bool
  * @throws \Doctrine\ORM\NoResultException
  * @throws \Doctrine\ORM\NonUniqueResultException
  */
 public function addElement($id = 0, EntityRepository $repository, $label = NULL)
 {
     $em = $this->getEntityManager();
     $qb = $repository->createQueryBuilder('a');
     $class = $repository->getClassName();
     /* @var TreeInterface $entry */
     $entry = new $class();
     if (!empty($label)) {
         $entry->setLabel($label);
     }
     if ($id == 0) {
         // get max_right
         $query = $qb->select('MAX(a.rgt) as max_rgt')->getQuery()->getSingleResult();
         if (isset($query['max_rgt'])) {
             $lft = $query['max_rgt'];
             $rgt = $lft + 1;
             /* @var TreeInterface $entry */
             $entry->setLft($lft)->setRgt($rgt)->setDepth(1);
             $em->persist($entry);
             $em->flush();
             return $entry->getId();
         }
         // add to parent
     } else {
         /* @var TreeInterface|NULL $parent */
         $parent = $repository->find($id);
         //dump($parent);
         if ($parent !== NULL) {
             $lft = $parent->getRgt();
             $rgt = $lft + 1;
             $queries = array();
             // update rgt
             $queries[] = $qb->update()->set('a.rgt', 'a.rgt + 2')->where('a.rgt >= :lft')->setParameter('lft', $lft)->getQuery()->getResult();
             // update lft
             $queries[] = $qb->update()->set('a.lft', 'a.lft + 2')->where('a.lft > :lft')->setParameter('lft', $lft)->getQuery()->getResult();
             // set entry
             $entry->setLft($lft)->setRgt($rgt)->setParent($parent)->setDepth($parent->getDepth() + 1);
             $em->persist($entry);
             $em->flush();
             return $entry->getId();
         }
     }
     return false;
 }

 /**
  * Deletes the translatable entities for locale
  *
  * @param EntityRepository $repository
  * @param LocaleInterface  $locale
  * @param OutputInterface  $output
  */
 protected function deleteTranslatableEntities(EntityRepository $repository, LocaleInterface $locale, OutputInterface $output)
 {
     $entityManager = $this->getDoctrineHelper()->getEntityManager();
     $criteria = new Criteria();
     $criteria->where($criteria->expr()->eq('locale', $locale->getCode()));
     $collection = $repository->matching($criteria);
     $collection->map(function (LocaleAwareInterface $entity) use($entityManager) {
         $entityManager->remove($entity);
     });
     $output->write(sprintf('Deleted <info>%s</info> entities <info>%s</info>', $collection->count(), $repository->getClassName()), true);
 }

 protected function truncate(EntityRepository $repository)
 {
     $classMetaData = $this->entityManager->getClassMetadata($repository->getClassName());
     $connection = $this->entityManager->getConnection();
     $dbPlatform = $connection->getDatabasePlatform();
     $sql = $dbPlatform->getTruncateTableSql($classMetaData->getTableName());
     $connection->executeUpdate($sql);
 }