/** * @param FileUpload $file * @return Image * @throws NotImageUploadedException * @throws FileSizeException * @throws DBALException * @throws InvalidStateException */ public function processImage(FileUpload $file) { if (!$file->isImage()) { throw new NotImageUploadedException(); } if (\filesize($file->getTemporaryFile()) > Image::MAX_FILE_SIZE) { throw new FileSizeException(); } try { $this->em->beginTransaction(); $image = new Image($file); $this->em->persist($image)->flush(); $file->move($this->composeImageLocation($image)); $this->em->commit(); } catch (InvalidStateException $is) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Error occurs while moving temp. image file to new location.'); throw $is; } catch (DBALException $e) { $this->em->rollback(); $this->em->close(); $this->logger->addError('Image error'); // todo err message throw $e; } return $image; }
public function processBackup(Form $form, $values) { $this->onBeforeManualBackup(); try { $removeBackupAtTheEnd = true; $results = $this->databaseBackup->backup('manual', $removeBackupAtTheEnd); $errorOccurred = false; /** @var ResultObject $result */ foreach ($results as $result) { if (!$result->hasNoErrors()) { foreach ($result->getAllErrors() as $error) { $this->presenter->flashMessage($error['message'], $error['type']); } $errorOccurred = true; } } if ($removeBackupAtTheEnd === false or $errorOccurred === false) { $this->presenter->flashMessage('Při zálohování nenastala žádná chyba.', 'success'); } } catch (\Exception $e) { $this->logger->addError(sprintf('Manual database backup failure. %s', $e)); $this->presenter->flashMessage('Databázi se nepodařilo zazálohovat. Zkontrolujte logy.', 'error'); } $this->redirect('this'); }
/** * @param DatabaseBackupFile $file * @return ResultObject[] */ public function process(DatabaseBackupFile $file) { $d = $file->getBackupDate(); $results = []; foreach ($this->uploadsCredentials as $credentials) { $result = new ResultObject(); // empty ResultObject means all is OK $backupPath = $credentials['path'] . '/' . $d->format('Y') . '/' . $d->format('F'); $entireFilePath = $backupPath . '/' . $file->getFileName(); try { $ftp = new \Ftp(); $ftp->connect($credentials['host']); $ftp->login($credentials['username'], $credentials['password']); if (!$ftp->fileExists($backupPath)) { $ftp->mkDirRecursive($backupPath); } $ftp->put($entireFilePath, $file->getFilePath(), FTP_BINARY); $ftp->close(); } catch (\FtpException $e) { $this->logger->addCritical(sprintf('Uploading backup file\'s failed. %s', $e)); $result->addError('Zálohu se nepodařilo nahrát na: ' . $credentials['host'], 'error'); } $results[] = $result; } return $results; }
public function userInit() { $user = null; $email = $this->userValues["contact"]["email"]; try { $user = $this->userService->getUserEmail($email); } catch (Exceptions\NoResultException $ex) { $this->logger->addDebug($ex); } if ($user === null) { $this->logger->addInfo("Users module initializer - User - no user with email {$email} found. New one is gonna be created."); $addrValues = $this->userValues["contact"]["address"]; $address = new Address((array) $addrValues); $address->applyAccountNumber($this->userValues["contact"]["address"]["accountNumber"]); $address->applyIdentificationNumber($this->userValues["contact"]["address"]["identificationNumber"]); $address->applyTaxIdentificationNumber($this->userValues["contact"]["address"]["taxIdentificationNumber"]); $contValues = $this->userValues["contact"]; $contact = new Contact((array) $contValues); $contact->setAddress($address); $userValues = $this->userValues; unset($userValues["contact"]); $user = new User((array) $userValues); $user->setActive(true); $user->setContact($contact); $user->setBirthNumber("0000000000"); $this->userService->createUser($user); } }
/** * @param array $eventsToSkip * or [logType => *] or [logType1 => [event1, event2, ...], logType2 => ...] */ public function addEventsToSkip($eventsToSkip) { if ($eventsToSkip === '*') { $this->eventsToSkip = $eventsToSkip; } elseif (is_array($eventsToSkip)) { foreach ($eventsToSkip as $type => $events) { if (!Validators::is($type, 'unicode:1..')) { $this->logger->addWarning(sprintf('The keys of array $eventsToSkip must be non-empty strings. "%s" given', gettype($type))); continue; } if ($events === '*') { $this->eventsToSkip[$type] = $events; } elseif (is_array($events)) { foreach ($events as $event) { if (Validators::is($event, 'unicode:1..')) { $this->eventsToSkip[$type][$event] = $event; } else { $this->logger->addWarning(sprintf('The values of array $eventsToSkip[%s] must be non-empty string. "%s" given', $type, gettype($event))); } } } else { $this->logger->addWarning(sprintf('The values of array $eventsToSkip must be an ARRAY or * (a star). "%s" given', gettype($events))); } } } else { $this->logger->addWarning(sprintf('Argument $eventsToSkip must be an ARRAY or * (a star). "%s" given', gettype($eventsToSkip))); } }
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(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(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); }
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); }
/** * @param $path * @return string * @throws IOException */ private function prepareStoragePath($path) { if (!file_exists($path) and is_dir($path)) { try { FileSystem::createDir($path); } catch (IOException $e) { $this->logger->addCritical(sprintf('DIR creation failure: %s', $e)); throw $e; } } return $path; }
/** * @param Page $page * @throws DBALException * @throws \Exception */ public function remove(Page $page) { try { $this->em->beginTransaction(); $this->removePageUrl($page); $this->em->remove($page); $this->em->flush(); $this->em->commit(); } catch (DBALException $e) { $this->closeEntityManager(); $this->logger->addError(sprintf('Article Removal Error: %s | article ID: %d | url ID: %s | exception: %s', date('Y-m-d H:i:s'), $page->getId(), isset($url) ? $url->getId() : 'NO URL', $e->getMessage())); throw $e; } }
public function groupInit() { $group = null; $abbr = $this->groupValues["abbr"]; try { $group = $this->groupService->getSportGroupAbbr($abbr); } catch (Exceptions\NoResultException $ex) { $this->logger->addDebug($ex); } if ($group === null) { $this->logger->addInfo("System module initializer - Sport Group - no group with abbr {$abbr} found. New one is gonna be created."); $g = new SportGroup((array) $this->getGroupValues()); $this->groupService->createSportGroup($g); } }
/** * onCreate event handler * @param SeasonApplication $app */ public function onCreate(SeasonApplication $app) { $id = $this->defaultRoleName; try { if (!is_string($id)) { $role = $this->roleService->getRole($id); } else { $role = $this->roleService->getRoleName($id); } } catch (Exceptions\DataErrorException $ex) { $this->logger->addError("Application listener - onCreate - role load failed with - " . $ex->getMessage()); return; } $pos = new Position(); $pos->setGroup($app->getSportGroup()); $pos->setRole($role); $pos->setOwner($app->getOwner()); $pos->setPublishContact(false); $pos->setComment($this->defaultComment); try { $this->positionService->createPosition($pos); if ($this->deleteOldPosition) { $this->positionService->deletePositionsWithRole($pos->getOwner(), $pos->getRole()); } } catch (Exceptions\DataErrorException $ex) { $this->logger->addError("Application listener - onCreate - savingData failed with - " . $ex->getMessage()); return; } }
public function save(array $values) { $options = $this->prepareOptions($this->findOptions()); foreach ((array) $values as $key => $value) { $options[$key]->setValue($value == '' ? null : $value); $this->em->persist($options[$key]); } try { $this->em->flush(); $this->cache->remove(Option::getCacheKey()); $this->onSuccessOptionsSaving(); } catch (\Exception $e) { $this->em->rollback(); $this->em->close(); $this->logger->addError(sprintf('Save Options error: %s | error message: %s', date('Y-m-d H:i:s'), $e->getMessage())); throw $e; } }
/** * @param array $receivers * @param string $subject * @param string $messageText * @param string $attachedFile * @return ResultObject */ private function sendMail(array $receivers, $subject, $messageText, $attachedFile = null) { $result = new ResultObject(); $message = new Message(); $message->setFrom('Výčetkový systém <' . $this->systemEmail . '>')->setSubject($subject)->setBody($messageText); foreach ($receivers as $receiverEmail) { $message->addTo($receiverEmail); } if ($attachedFile !== null and file_exists($attachedFile)) { $message->addAttachment($attachedFile); } try { $this->mailer->send($message); } catch (SendException $s) { $this->logger->addError(sprintf('Backup file sending\'s failed. %s', $s)); $result->addError('Zálohu se nepodařilo odeslat', 'error'); } return $result; }
public function handleBackup($pass) { if ($this->backupPassword !== null) { if ($this->backupPassword != $pass) { $this->logger->addWarning('Unauthorized try to backup database (auto)'); return; } } if ($this->cache->load('databaseBackup') !== null) { $this->logger->addNotice('Another try to backup database (auto)'); return; } try { $this->databaseBackup->backup('auto', true); $this->cache->save('databaseBackup', 'done', [Cache::EXPIRE => '23 hours']); } catch (\Exception $e) { $this->logger->addError(sprintf('Database backup failure (auto). %s', $e)); } }
/** * @throws TerminateException */ protected function restartJob(array $request, \Exception $exception = null, $message = null) : int { $this->logger->addError(sprintf('job requeue(%s) for order %d because of %s: %s', $request['retryCounter'], $request['orderId'], get_class($exception), $message ?: $exception->getMessage())); $this->append($this->em->getReference(Order::class, $request['orderId']), $request['retryCounter'] + 1, $request['options']); if (!$this->em->isOpen()) { sleep(self::DELAY_ON_RESTART); throw TerminateException::withResponse(self::MSG_REJECT); } return self::MSG_REJECT; }
/** * Method for handling single onCreate event * @param SeasonApplication $app * @return void * @throws Exceptions\InvalidStateException */ public function onCreate(SeasonApplication $app) { $amount = null; $season = $app->getSeason(); $group = $app->getSportGroup(); try { $tax = $this->seasonTaxService->getSeasonTaxSG($season, $group); if ($tax !== null) { $amount = $tax->getMemberShip(); if (empty($amount) || $amount == 0) { return; } } else { throw new Exceptions\InvalidStateException("Season tax for season {$season} and group {$group} does not exist"); } } catch (Exceptions\DataErrorException $ex) { $this->logger->addError("Application listener - onCreate - getSeasonTaxSG failed with - " . $ex->getMessage()); return; } $subject = "Application for " . $app->getSportGroup()->getName() . " (" . $app->getSportGroup()->getSportType()->getName() . ") within " . $app->getSeason()->getLabel() . " season"; $payment = new Payment(); $payment->setOwner($app->getOwner()); $payment->setSeason($app->getSeason()); $payment->setSubject($subject); $payment->setAmount($amount); $payment->setDueDate($this->paymentService->getDefaultDueDate()); $payment->setOrderedDate(new DateTime()); $payment->setEditor($app->getEditor()); $payment->setStatus(PaymentStatus::NOT_YET); $payment->setVs($this->paymentService->generateVs($payment)); $payment->setPublicNote(""); $payment->setProtectedNote(""); try { $this->paymentService->createPayment($payment); $app->setPayment($payment); $this->seasonApplicationService->updateSeasonApplication($app); } catch (Exceptions\DataErrorException $ex) { $this->logger->addError("Application listener - onCreate - savingData failed with - " . $ex->getMessage()); return; } }
/** * @param Url $url * @return Url * @throws UrlAlreadyExistsException * @throws \Exception */ public function save(Url $url) { try { $this->em->beginTransaction(); if ($url->getId() !== null) { $url = $this->update($url); } else { $url = $this->create($url); } $this->em->commit(); } catch (UrlAlreadyExistsException $uae) { $this->closeEntityManager(); $this->logger->addError(sprintf('Url path already exists: %s', $uae)); throw $uae; } catch (\Exception $e) { $this->closeEntityManager(); $this->logger->addError(sprintf('Url Entity saving failure: %s', $e)); throw $e; } return $url; }
private function send(Message $n) { $mailerType = $this->getDesiredMailerType(); $mailer = null; if ($mailerType == self::MAILER_TYPE_SEND) { $mailer = new SendmailMailer(); } else { $mailer = new SmtpMailer($this->getSmtpOptions()); } try { $mailer->send($n); } catch (Exceptions\InvalidStateException $ex) { $this->logger->addError($ex); } }
/** * @param $path * @return null|Url */ private function loadUrlEntity($path) { /** @var Url $urlEntity */ $urlEntity = $this->cache->load($path, function (&$dependencies) use($path) { /** @var Url $urlEntity */ $urlEntity = $this->em->createQuery('SELECT u, rt FROM ' . Url::class . ' u LEFT JOIN u.actualUrlToRedirect rt WHERE u.urlPath = :urlPath')->setParameter('urlPath', $path)->getOneOrNullResult(); if ($urlEntity === null) { $this->logger->addError(sprintf('Page not found. URL_PATH: %s', $path)); return null; } $dependencies = [Nette\Caching\Cache::TAGS => $urlEntity->getCacheKey()]; return $urlEntity; }); return $urlEntity; }
public function rulesInit() { $role = $this->roleService->getRoleName("admin"); $rule = null; try { $rule = $this->ruleService->getUniqueRule($role); } catch (Exceptions\NoResultException $ex) { $this->logger->addDebug($ex->getMessage()); } if ($rule === null) { $this->logger->addInfo("Security module initializer - AclRules - no godlike Rule for role {$role} found. New one is gonna be created."); $rule = new AclRule(); $rule->setRole($role); $rule->setResource(null); $rule->setPrivilege(null); $rule->setMode(\App\Model\Misc\Enum\AclMode::PERMIT); $this->ruleService->createRule($rule); } }
public function onPasswordRegenerate(User $u) { $this->notifService->notifyNewPassword($u); $this->logger->addInfo("User Listener - onPasswordRegenerate - user {$u} notified"); $this->logger->addDebug("User Listener - onPasswordRegenerate - new password for user {$u} is {$u->provideRawPassword()}"); }
/** * @param string $message * @param array $data */ public function iLog($message, array $data = []) { /** @var Control $this */ $data = array_merge(['user' => $this->presenter->user->id, 'route' => $this->presenter->getName() . ':' . $this->presenter->action], $data); $this->log->addInfo($message, $data); }
/** * {@inheritdoc} * @return Boolean Whether the record has been processed */ public function emergency($message, array $context = []) { return $this->parentLogger->emergency($message, ['channel' => $this->name] + $context); }
public function onCreate(Payment $p) { $this->notifService->notifyNewPayment($p); $this->logger->addInfo("System Module - Payments Listener - onCreate - owner of {$p} has been notified"); }
public function onCreate(SeasonApplication $app) { $this->notifService->notifyNewSeasonApplication($app); $this->logger->addInfo("System Module - Application Listener - onCreated - owner of season application {$app} has been notified"); }
/** * onDelete event handler * @param BaseEntity $e */ public function onDelete(BaseEntity $e) { $this->aclService->invalidateCache(); $this->logger->addInfo("AclRuleListener - onDelete - cache of aclService is gonna be deleted"); }
/** * @param Logger $logger */ public function __construct(Logger $logger) { $this->loggerChannel = $logger->channel(self::SEARCH_DIRECTOR_CHANNEL); }
protected function logDebug($message, array $context = []) { $this->logger->addDebug($this->prefixMessage($message, "DEBUG"), $context); }