public function renderDefault()
{
$this->template->anyVariable = 'any value';
// $dao = $this->articles;
$this->template->articles = $this->articles->getArticles()->findAll();
$posts = $this->EntityManager->getRepository(Posts::getClassName());
$this->template->posts = $posts->findAll();
$this->template->myparametr = $this->context->parameters['first_parametr'];
// $this->template->test = $this->doSomeRefactoring('Hello world from blog');
// $post = new Posts();
// $post->title = 'New title';
// $post->text = 'New text New textNew text';
// $post->created_at = new \Nette\Utils\DateTime;
//
//
// $this->EntityManager->persist($post);
// $this->EntityManager->flush();
// $dao = $this->EntityManager->getRepository(Posts::getClassName());
// $dao->setTitle('test');
// $dao->__call('set', ['title' => 'my title']);
// dump($dao->__isset('title'));
// $dao->__set('title', 'test');
try {
$this->checkNum(2);
\Tracy\Debugger::barDump('If you see this, the number is 1 or below');
} catch (Nette\Application\BadRequestException $e) {
Debugger::log('Message: ' . $e->getMessage());
var_dump($e->getMessage());
}
// finally {
// \Tracy\Debugger::barDump('Got here Finally');
// }
}
protected function createComponentGrid($name)
{
$grid = new Grid($this, $name);
$repository = $this->database->getRepository('App\\Models\\Doctrine\\Entities\\User');
$model = new \Grido\DataSources\Doctrine($repository->createQueryBuilder('a')->addSelect('c')->innerJoin('a.country', 'c'), array('country' => 'c.title'));
// Map country column to the title of the Country entity
$grid->model = $model;
$grid->addColumnText('firstname', 'Firstname')->setFilterText()->setSuggestion();
$grid->addColumnText('surname', 'Surname')->setSortable()->setFilterText()->setSuggestion();
$grid->addColumnText('gender', 'Gender')->setSortable()->cellPrototype->class[] = 'center';
$grid->addColumnDate('birthday', 'Birthday', \Grido\Components\Columns\Date::FORMAT_TEXT)->setSortable()->setFilterDate()->setCondition($grid->birthdayFilterCondition);
$grid->getColumn('birthday')->cellPrototype->class[] = 'center';
$grid->addColumnText('country', 'Country')->setSortable()->setCustomRender(function ($item) {
$baseUri = $this->getBaseUri();
$img = Html::el('img')->src("{$baseUri}/img/flags/{$item->country_code}.gif");
return "{$img} {$item->country}";
})->setFilterText()->setSuggestion();
$grid->addColumnText('card', 'Card')->setSortable()->setColumn('cctype')->setReplacement(array('MasterCard' => Html::el('b')->setText('MasterCard')))->cellPrototype->class[] = 'center';
$grid->addColumnEmail('emailaddress', 'Email')->setSortable()->setFilterText();
$grid->getColumn('emailaddress')->cellPrototype->class[] = 'center';
$grid->addColumnText('centimeters', 'Height')->setSortable()->setFilterNumber();
$grid->getColumn('centimeters')->cellPrototype->class[] = 'center';
$grid->addFilterSelect('gender', 'Gender', array('' => '', 'female' => 'female', 'male' => 'male'));
$grid->addFilterSelect('card', 'Card', array('' => '', 'MasterCard' => 'MasterCard', 'Visa' => 'Visa'))->setColumn('cctype');
$grid->addFilterCheck('preferred', 'Only preferred girls :)')->setCondition(array(TRUE => array(array('gender', 'AND', 'centimeters'), array('= ?', '>= ?'), array('female', 170))));
$grid->addActionHref('edit', 'Edit')->setIcon('pencil');
$grid->addActionHref('delete', 'Delete')->setIcon('trash')->setConfirm(function ($item) {
return "Are you sure you want to delete {$item->firstname} {$item->surname}?";
});
$operation = array('print' => 'Print', 'delete' => 'Delete');
$grid->setOperation($operation, $this->handleOperations)->setConfirm('delete', 'Are you sure you want to delete %i items?');
$grid->filterRenderType = $this->filterRenderType;
$grid->setExport();
}
public function transfuse(SearchMetadata $searchMeta)
{
$class = $this->entityManager->getClassMetadata($searchMeta->getName());
$repository = $this->entityManager->getRepository($searchMeta->getName());
$this->createAndUpdate($class, $repository);
$this->dropOld($class, $repository);
}
public function __construct(EntityManager $entityManager, CommentRemover $commentRemover, CommentPersister $commentPersister)
{
$this->em = $entityManager;
$this->commentRemover = $commentRemover;
$this->commentPersister = $commentPersister;
$this->commentsRepository = $this->em->getRepository(Comment::class);
}
public function __construct(EntityManager $em)
{
$this->em = $em;
$this->streetRepository = $em->getRepository(Street::class);
$this->partCityRepository = $em->getRepository(PartCity::class);
$this->cityRepository = $em->getRepository(City::class);
}
public function __construct(EntityManager $entityManager, UrlPersister $urlPersister, UrlLinker $urlLinker, Logger $logger)
{
$this->em = $entityManager;
$this->urlPersister = $urlPersister;
$this->logger = $logger->channel('urlsEntities');
$this->urlLinker = $urlLinker;
$this->urlRepository = $this->em->getRepository(Url::class);
}
/**
* @param EntityManager $entityManager
* @param Client $elastic
*/
public function __construct(EntityManager $entityManager, Client $elastic)
{
parent::__construct();
$this->entityManager = $entityManager;
$this->elastic = $elastic;
$this->seasonsRepository = $entityManager->getRepository(Season::class);
$this->languagesRepository = $entityManager->getRepository(Language::class);
}
public function __construct(EntityManager $entityManager, TagPersister $tagPersister, TagRemover $tagRemover, Logger $logger)
{
$this->em = $entityManager;
$this->tagPersister = $tagPersister;
$this->logger = $logger->channel('Tags');
$this->tagRepository = $this->em->getRepository(Tag::class);
$this->tagRemover = $tagRemover;
}
public function __construct(ImagesUploader $imagesUploader, ImagesRemover $imagesRemover, EntityManager $entityManager, Logger $logger)
{
$this->imagesUploader = $imagesUploader;
$this->imagesRemover = $imagesRemover;
$this->em = $entityManager;
$this->logger = $logger->channel('images');
$this->imageRepository = $this->em->getRepository(Image::class);
}
public function __construct(\Kdyby\Doctrine\EntityManager $entityManager)
{
if (!$this->table_name) {
throw new \Exception('Variable $db_nam must be filled!');
}
$this->em = $entityManager;
$entits = new $this->table_name();
$this->entit = $this->em->getRepository($entits);
}
public function __construct(EntityManager $em, $rootDir)
{
$this->rootDir = $rootDir;
$this->em = $em;
$this->regionRepository = $em->getRepository(Region::class);
$this->cityRepository = $em->getRepository(City::class);
$this->streetRepository = $em->getRepository(Street::class);
$this->partCityRepository = $em->getRepository(PartCity::class);
}
public function __construct(EntityManager $entityManager, PagePersister $pagePersister, PageRemover $pageRemover, IStorage $storage, Logger $logger)
{
$this->em = $entityManager;
$this->pagePersister = $pagePersister;
$this->pageRemover = $pageRemover;
$this->logger = $logger->channel('pages');
$this->cache = new Cache($storage, 'pages');
$this->pageRepository = $this->em->getRepository(Page::class);
}
public function emailFormSucceeded(Form $form, $values)
{
$settings = $this->EntityManager->getRepository(Settings::getClassName());
$setting = $settings->find(1);
$mail = new Message();
$mail->setFrom($values['email'])->addTo($setting->admin_email)->setSubject('Zpráva z webu PeTr - ' . $values['subject'])->setBody('Zpráva od ' . $values['name'] . '<br /><br />' . $values['message']);
$mailer = new SendmailMailer();
//$mailer->send($mail);
$this->redirect('Contact:sent');
}
/**
* @param Container $container
* @param EntityManager $entityManager
*/
public function __construct(Container $container, EntityManager $entityManager)
{
parent::__construct('dwarfSearch:import');
$this->entityManager = $entityManager;
$this->seasonsRepository = $entityManager->getRepository(Season::class);
$this->episodesRepository = $entityManager->getRepository(Episode::class);
$this->languagesRepository = $entityManager->getRepository(Language::class);
$this->charactersRepository = $entityManager->getRepository(Character::class);
$this->scenariosDir = $container->expand('%appDir%/../scenarios');
}
public function __construct(EntityManager $entityManager, AlbumCoverProvider $albumCoverProvider, string $songsDirectory)
{
$this->entityManager = $entityManager;
$this->songsDirectory = $songsDirectory;
$this->albumCoverProvider = $albumCoverProvider;
$this->songRepository = $entityManager->getRepository(Song::getClassName());
$this->genresRepository = $entityManager->getRepository(Genre::getClassName());
$this->addFunctions();
$this->genreCache = [];
$this->hashCache = [];
}
/**
* Performs an authentication.
* @return Nette\Security\Identity
* @throws Nette\Security\AuthenticationException
*/
public function authenticate(array $credentials)
{
list($username, $password) = $credentials;
$row = $this->em->getRepository(UserEntity::getClassName())->findOneBy(array('login' => $username));
if (!$row) {
throw new Nette\Security\AuthenticationException('The username is incorrect.', self::IDENTITY_NOT_FOUND);
} elseif (!Passwords::verify($password, $row->password)) {
throw new Nette\Security\AuthenticationException('The password is incorrect.', self::INVALID_CREDENTIAL);
}
$arr = array('id' => $row->id, 'role' => '');
return new Nette\Security\Identity($arr[self::COLUMN_ID], $arr['role'], $arr);
}
/**
* @param string $entityName
* @param int $id
* @return mixed
* @throws \Exception
*/
public function findOrCreateEntity($entityName, $id)
{
if ($id === NULL) {
$entity = new $entityName();
$this->em->persist($entity);
return $entity;
}
$entity = $this->em->getRepository($entityName)->find($id);
if ($entity === NULL) {
throw new \Exception('Entity was not fount.');
}
return $entity;
}
/**
* @param $entity
* @param callable $modifier
* @return \Kdyby\Doctrine\QueryBuilder
*/
private function createBaseQuery($entity, $modifier)
{
$reflection = ClassType::from($entity);
if (!$reflection->hasProperty('priority')) {
throw new InvalidArgumentException('Entity has not property $priority');
}
$qb = $this->entityManager->getRepository($reflection->getName())->createQueryBuilder("e")->select();
if ($modifier !== NULL) {
$modifier($qb);
}
$qb->setMaxResults(1);
return $qb;
}
public function __construct(RoleRemover $roleRemover, UserRemover $userRemover, EntityManager $entityManager, UserPersister $userPersister, RolePersister $rolePersister, RolePermissionsPersister $rolePermissionsPersister)
{
$this->em = $entityManager;
$this->roleRemover = $roleRemover;
$this->userRemover = $userRemover;
$this->userPersister = $userPersister;
$this->rolePersister = $rolePersister;
$this->rolePermissionsPersister = $rolePermissionsPersister;
$this->userRepository = $entityManager->getRepository(User::class);
$this->roleRepository = $entityManager->getRepository(Role::class);
$this->permissionRepository = $entityManager->getRepository(Permission::class);
$this->accessDefinitionRepository = $entityManager->getRepository(AccessDefinition::class);
}
/**
* Performs an authentication against e.g. database.
* and returns IIdentity on success or throws AuthenticationException
* @return IIdentity
* @throws AuthenticationException
*/
public function authenticate(array $credentials)
{
list($email, $password) = $credentials;
$user = $this->entityManager->getRepository(User::class)->findOneBy(['email' => $email]);
if ($user === null) {
throw new AuthenticationException('Špatná E-mailová adresa');
}
if (!Passwords::verify($password, $user->getPassword())) {
throw new AuthenticationException('Špatné heslo');
} elseif (Passwords::needsRehash($user->getPassword())) {
$user->password = Passwords::hash($password);
}
$this->onLoggedIn($user, $this->httpRequest->getRemoteAddress());
return new FakeIdentity($user->getId(), get_class($user));
}
public function process(AMQPMessage $message) : int
{
try {
if (!($request = Json::decode($message->body, Json::FORCE_ARRAY))) {
return self::MSG_REJECT;
}
} catch (JsonException $e) {
$this->logger->addError($e->getMessage());
return self::MSG_REJECT;
}
$orderId = $request['orderId'];
try {
$conn = $this->em->getConnection();
if ($conn->ping() === false) {
$conn->close();
$conn->connect();
}
/** @var Order $order */
$orders = $this->em->getRepository(Order::class);
if (!($order = $orders->find($orderId))) {
$this->logger->addWarning(sprintf('Order %s not found in db', $orderId));
return self::MSG_REJECT;
}
if (!$order->getUser()) {
$this->logger->addWarning(sprintf('Order %s has no user', $orderId));
return self::MSG_REJECT;
}
$this->user->passwordLessLogin($order->getUser()->getId());
return $this->processOrder($order, $request['options']);
} catch (\App\Exception\DatabaseDeadlockException $e) {
return $this->restartJob($request, $e);
} catch (\Doctrine\DBAL\Exception\DriverException $e) {
if ($deadlock = \App\Exception\DatabaseDeadlockException::fromDriverException($e)) {
$e = $deadlock;
$message = null;
} else {
$this->logger->addError($e->getMessage(), ['exception' => $e]);
$message = $e->getPrevious() instanceof \Doctrine\DBAL\Driver\PDOException ? $e->getPrevious()->getMessage() : $e->getMessage();
}
return $this->restartJob($request, $e, $message);
} catch (\Exception $e) {
$this->logger->addError($this->getQueue(), ['exception' => $e]);
return $this->restartJob($request, $e);
} finally {
$this->user->logout(true);
$this->em->clear();
}
}
public function renderDefault($page)
{
// initial dao object
$dao = $this->em->getRepository(Search::getClassName());
$searchQuery = new SearchQuery();
// initial paginator
$paginator = new Nette\Utils\Paginator();
$paginator->setPage($page);
$searchs = $dao->fetch($searchQuery)->applySorting(array('Search.date' => 'DESC'))->applyPaginator($paginator, self::ROWSONPAGE);
$numberRows = $searchs->getTotalCount();
$paginator->setItemCount($numberRows);
// push data to template
$this->template->search = $searchs;
$this->template->paginator = $paginator;
$this->template->page = $page;
}
public function __construct(EntityManager $entityManager, IAdminGridFactory $adminGridFactory, ITranslator $translator, RegistrationFormService $registrationFormService)
{
$this->registrationRepository = $entityManager->getRepository(Registration::class);
$this->adminGridFactory = $adminGridFactory;
$this->translator = $translator;
$this->registrationFormService = $registrationFormService;
}
private function getLastPosition(EntityManager $em)
{
$last = $em->getRepository(get_class($this))->findOneBy([], ["position" => "DESC"]);
if ($last) {
return $last->getPosition();
}
return 0;
}
public function __construct(UrlParametersConverter $urlParametersConverter, LocaleFacade $localeFacade, IStorage $storage, EntityManager $em, Logger $logger)
{
$this->localeFacade = $localeFacade;
$this->urlParametersConverter = $urlParametersConverter;
$this->em = $em;
$this->cache = new Nette\Caching\Cache($storage, self::ROUTE_NAMESPACE);
$this->urlRepository = $em->getRepository(Url::class);
$this->logger = $logger->channel('router');
}
public function renderDefault()
{
$this->template->anyVariable = 'any value';
$dao = $this->EntityManager->getRepository(Article::getClassName());
$this->template->articles = $dao->findAll();
// $post = new Posts();
// $post->title = 'New title';
// $post->text = 'New text New textNew text';
// $post->created_at = new \Nette\Utils\DateTime;
//
//
// $this->EntityManager->persist($post);
// $this->EntityManager->flush();
// $dao = $this->EntityManager->getRepository(Posts::getClassName());
// $dao->setTitle('test');
// $dao->__call('set', ['title' => 'my title']);
// dump($dao->__isset('title'));
// $dao->__set('title', 'test');
}
public function __construct(EntityManager $entityManager, string $masterKey, string $addressLockTime, string $newAddressesFile)
{
$this->occupiedAddressesTreshold = 0.9;
$this->increaseRatio = 0.1;
$this->addressLockTime = $addressLockTime;
$this->masterKey = $masterKey;
$this->entityManager = $entityManager;
$this->addressRepository = $entityManager->getRepository(Address::getClassName());
$this->newAddressesFile = $newAddressesFile;
}
/**
* @param string $section
* @return object
*/
protected function getPermissionsSection($section)
{
$userSignedDao = $this->em->getRepository(User::class);
$userSigned = $userSignedDao->find($this->user->id);
$permissionsDao = $this->em->getRepository(Permissions::class);
$permissions = $permissionsDao->findBy(['user' => $userSigned, 'section' => $section]);
if (isset($permissions[0])) {
return $permissions[0];
}
return (object) ['section' => (string) $section, 'allowRead' => FALSE, 'allowWrite' => FALSE, 'allowDelete' => FALSE];
}
/**
* EditableFacade constructor.
* @param EntityManager $em
* @param IICMSAuthorizator $authorizator
*/
public function __construct(EntityManager $em, IICMSAuthorizator $authorizator)
{
$this->em = $em;
$this->editableTextRepository = $this->em->getRepository(EditableText::class);
$this->authorizator = $authorizator;
}
public function __construct(EntityManager $entityManager)
{
$this->em = $entityManager;
$this->listingsRepository = $this->em->getRepository(Listing::class);
}
