PHP EntityManager::find方法代码示例

 /**
  * @param string
  * @param int
  * @return object|NULL
  * @throws BadRequestException
  */
 private function findById($entityName, $id)
 {
     $entity = $this->em->find($entityName, $id);
     if ($entity === NULL) {
         throw new BadRequestException('Entity "' . $entityName . '" with id = "' . $id . '" was not found.');
     }
     return $entity;
 }

 public function update($entityClass, array $items)
 {
     $position = 1;
     foreach ($items as $id) {
         $entity = $this->em->find($entityClass, $id);
         $entity->setPosition($position * 10);
         $this->em->persist($entity);
         $position++;
     }
     $this->em->flush();
 }

 public function renderDefault($id)
 {
     if (!is_null($id)) {
         $search = $this->em->find(Search::getClassName(), $id);
         if (!$search) {
             $this->flashMessage('Data not found for this id', 'error');
             $this->redirect('Homepage:');
         }
     } else {
         $this->flashMessage('Data not found for this id', 'error');
     }
     $this->template->search = $search;
 }

 /**
  * @param array $values
  * @return Role
  * @throws RoleAlreadyExistsException
  * @throws RoleMissingException
  */
 public function createRole(array $values)
 {
     $parentRole = null;
     if ($values['parent'] !== null) {
         $parentRole = $this->em->find(Role::class, $values['parent']);
         if ($parentRole === null) {
             throw new RoleMissingException();
         }
     }
     $role = new Role($values['name'], $parentRole);
     $role = $this->em->safePersist($role);
     if ($role === false) {
         throw new RoleAlreadyExistsException();
     }
     $this->onSuccessRoleCreation($role);
     return $role;
 }

 /**
  * @param array $values
  * @param Page|null $page
  * @return Page
  * @throws PagePublicationTimeException
  * @throws PagePublicationTimeMissingException
  * @throws UrlAlreadyExistsException
  * @throws LocaleNotFoundException
  * @throws PageTitleAlreadyExistsException
  * @throws PageIntroHtmlLengthException
  * @throws \Exception
  */
 public function save(array $values, Page $page = null)
 {
     foreach ($values as $k => $v) {
         $values[$k] = $v === '' ? null : $v;
     }
     if ($values['publishedAt'] === null and $values['saveAsDraft'] === false) {
         throw new PagePublicationTimeMissingException();
     }
     $values['author'] = $this->em->find(User::class, $values['author']->getId());
     try {
         if ($page !== null and $page->getId() !== null) {
             $wasDraft = $page->isDraft();
             $hadOpenedComments = $page->getAllowedComments();
             $this->updatePage($page, $values);
             $this->onSuccessPageEditing($page);
         } else {
             $wasDraft = true;
             $hadOpenedComments = true;
             $page = $this->createNewPage($values, $page);
             $this->onSuccessPageCreation($page);
         }
         if ($wasDraft !== $page->isDraft() and $wasDraft === true) {
             $this->onPageRelease($page);
         }
         if ($hadOpenedComments !== $page->getAllowedComments()) {
             if ($hadOpenedComments === true) {
                 $this->onPageCommentsClosure($page);
             } else {
                 $this->onPageCommentsOpening($page);
             }
         }
     } catch (UrlAlreadyExistsException $u) {
         $this->closeEntityManager();
         throw $u;
     } catch (PageTitleAlreadyExistsException $p) {
         $this->closeEntityManager();
         throw $p;
     } catch (\Exception $e) {
         $this->closeEntityManager();
         throw $e;
     }
     return $page;
 }

 /**
  * @param $roleId
  * @param ValidationObject $validationObject
  * @return Role
  */
 private function getRole($roleId, ValidationObject $validationObject)
 {
     /** @var Role $role */
     $role = $this->em->find(Role::class, $roleId);
     if ($role === null) {
         //throw new RoleMissingException;
         $validationObject->addError('users.user.form.messages.missingRole', FlashMessage::WARNING);
     }
     return $role;
 }

 /**
  * @param Role $role
  * @param array $permissionDefinitions
  * @throws DBALException
  * @throws \Exception
  */
 public function save(Role $role, array $permissionDefinitions)
 {
     $resources = $this->em->createQuery('SELECT r FROM ' . Resource::class . ' r INDEX BY r.id')->execute();
     $privileges = $this->em->createQuery('SELECT p FROM ' . Privilege::class . ' p INDEX BY p.id')->execute();
     try {
         $this->em->beginTransaction();
         $this->em->createQuery('DELETE ' . Permission::class . ' p
              WHERE p.role = :role')->execute(['role' => $role->getId()]);
         $parentRole = null;
         if ($role->hasParent()) {
             /** @var Role $parentRole */
             $parentRole = $this->em->find(Role::class, $role->getParentId());
         }
         foreach ($permissionDefinitions as $definition => $isAllowed) {
             $isAllowed = (bool) $isAllowed;
             $x = explode('-', $definition);
             // eg. 1-3
             /** @var \Users\Authorization\Resource $resource */
             $resource = $resources[$x[0]];
             /** @var Privilege $privilege */
             $privilege = $privileges[$x[1]];
             // check Users\Authorization\Authorizator ACL assembling
             // Role without parent
             // privilege: allowed -> must be in database
             // privilege: denied  -> does NOT have to be in database
             // Role with parent (all depths)
             /*
                               ------------------------------------------------------------
                                  parent    |    descendant    |    should be persisted?
                               ------------------------------------------------------------
                                  allowed         allowed                  NO
                                  allowed         denied                  YES
                                  denied          denied                  NO
                                  denied          allowed                 YES
                               ------------------------------------------------------------
                                 We save records where permission and denial differ
             */
             if ($parentRole !== null) {
                 // has parent
                 if ($this->authorizator->isAllowed($parentRole, $resource->getName(), $privilege->getName()) === $isAllowed) {
                     continue;
                 }
             } else {
                 // doesn't have parent
                 if ($isAllowed === false) {
                     continue;
                 }
             }
             $permission = new Permission($role, $resource, $privilege, $isAllowed);
             $this->em->persist($permission);
         }
         $this->em->flush();
         $this->em->commit();
         $this->cache->remove('acl');
         $this->onSuccessRolePermissionsEditing($role);
     } catch (\Exception $e) {
         $this->em->rollback();
         $this->em->close();
         // todo log error
         throw new $e();
     }
 }

 /**
  * Find entity by ID.
  * @param string $entityName
  * @param int $id
  * @return object
  */
 protected function findById($entityName, $id)
 {
     return $this->entityManager->find($entityName, $id);
 }