/**
* @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);
}
