DB connection settings diff

Icon and mailboxes button
Better UI in home
2023-10-31 13:41:15 -03:00 · 2023-10-31 13:38:24 -03:00 · 2023-10-31 13:03:49 -03:00 · 2023-06-12 21:14:31 -04:00 · 2023-06-12 21:14:07 -04:00 · 2023-06-09 00:54:34 -04:00
126 changed files with 2508 additions and 848 deletions
--- a/.env.sample
+++ b/.env.sample
@ -5,7 +5,7 @@ UI_PATH=./ui
 COMPOSE_PROJECT_NAME=emails
 COMPOSE_PATH_SEPARATOR=:
 COMPOSE_FILE=./docker-compose.yml:${CLI_PATH}/docker-compose.yml:${API_PATH}/docker-compose.yml:${UI_PATH}/docker-compose.yml
-COMPOSE_PROFILES=api,ui
+COMPOSE_PROFILES=api,ui,cli

 ATT_PATH=./attachments
 LOGS_PATH=./logs
--- a/NOTES.md
+++ b/NOTES.md
@ -7,8 +7,14 @@
 * [ ] Download `attachments` (*encrypted* & *decrypted*).

 ## CLI
-* [x] Get `mailboxes` from **[API]** then run `grab messages` job in **[API]** for each one.
-* [x] Get `pending attachments` jobs from **[API]** and run.
+#### Automatic
+* [x] `mailboxes:check`: Get *registered* `mailboxes` and schedule `messages:grab` for `mailbox_id`.
+* [x] `attachments:check`: Check *saved* `attachments` and schedule `attachments:decrypt` for `attachment_id`.
+* [x] `jobs:check`: Get *pending* `jobs` and run them.
+#### Scheduled
+* [x] `messages:grab`: Grab `messages` for `mailbox`. Arguments: `mailbox_id`.
+* [x] `attachments:grab`: Grab `attachments` for `message`. Arguments: `message_id`.
+* [x] `attachments:decrypt`: Decrypt `attachment`. Arguments: `attachment_id`.

 ## API
 * [x] Grab all `mailboxes` from `Email Provider`, identifying those that are registered.
@ -21,8 +27,17 @@


 ## Workflow
-* **[User]** Choose `mailboxes` to register or unregister
-    -> **[API]** Register selected `mailboxes` and get `messages` for recently registered.
-* **[Cron]** Get registered `mailboxes` -> **[API]** Get `messages`
-* **[User]** Check messages found -> **[API]** Schedule `attachments`
-* **[Cron]** Get `attachment download` jobs -> **[API]** grab `attachments`
+* **[User]** Choose `mailboxes` to register or unregister.
+    -> **[API]** Register selected `mailboxes`, register new `messages:grab` job.
+* **[Cron]** Get `jobs`, run `jobs`.
+* **[User]** Check messages found -> **[API]** Schedule `attachments`.
+
+## Jobs
+#### Automatic
+* [x] Check *registered* `mailboxes` for new `messages`. Every weekday.
+* [x] Check if `attachments` are *encrypted*. Every weekday.
+* [x] Check for new *scheduled* `jobs`. Every minute.
+#### Scheduled
+* [ ] Grab `messages` for `mailbox` id.
+* [ ] Grab `attachments` for `message` id.
+* [ ] Decrypt `attachment`.
--- a/README.md
+++ b/README.md
@ -6,3 +6,52 @@ Grab attachments from emails by inbox.
 * Choose what mailboxes to watch.
 * Select messages that you want to grab attachments from.
 * Download (or view in browser) (decrypted) attachments from messages.
+
+## Requirements
+
+* Docker with Docker Compose [https://www.docker.com/](https://www.docker.com/)
+
+## Installation
+
+1. Pull from repository
+    ```
+    git pull git@git.provm.cl:Incoviba/emails.git
+    ```
+    Change to latest release
+    ```
+    git checkout release
+    ```
+2. Check the docker-compose.yml files
+   1. docker-compose.yml - central proxy container
+   2. api/docker-compose.yml - API container and database
+   3. cli/docker-compose.yml - CLI container that runs cron jobs
+   4. ui/docker-compose.yml - UI container
+3. Generate the API Key
+   If you have openssl (comes with most linux distros) you can run this in terminal
+   ```
+   echo API_KEY=`(openssl rand -hex 128)` >> .key.env
+   ```
+4. Check Environment files
+   1. .env - Docker Compose and Environment settings. Check volumes and ports.
+   2. .key.env - API_KEY, generated before.
+   3. .mail.env - Email Identification.
+   4. api/.env - Encrypted PDF files passwords.
+   5. api/.db.env - Database configuration.
+   6. cli/.env - API_URI, for connecting to the api container from the cli container. Change it if the api is someplace else.
+   7. ui/.env - API_URI, same as from the cli.
+5. Check if every configuration is correct before starting the application
+   ```
+   docker compose config
+   ```
+   If everything is fine
+   ```
+   docker compose up -d
+   ```
+6. Connect to the UI
+   Default [http://localhost:8000](http://localhost:8000)
+
+## Development
+When development there is a container for adminer, to use it you can add it into `COMPOSE_PROFILES` or run
+```
+docker compose up -d adminer
+```
--- a/api/.adminer.env.sample
+++ b/api/.adminer.env.sample
@ -0,0 +1,2 @@
+ADMINER_DESIGN=dracula
+ADMINER_PLUGINS="tables-filter table-indexes-structure table-structure struct-comments json-column edit-calendar edit-textarea dump-bz2 dump-date dump-json dump-php enum-option"
--- a/api/.db.env.sample
+++ b/api/.db.env.sample
@ -0,0 +1,4 @@
+MYSQL_ROOT_PASSWORD=
+MYSQL_DATABASE=
+MYSQL_USER=
+MYSQL_PASSWORD=
--- a/api/.env.sample
+++ b/api/.env.sample
@ -0,0 +1,2 @@
+PASSWORDS_SEPARATOR=,
+PASSWORDS=
--- a/api/.mail.env.sample
+++ b/api/.mail.env.sample
@ -2,5 +2,4 @@ EMAIL_HOST=imap.gmail.com
 EMAIL_PORT=993
 EMAIL_USERNAME=@gmail.com
 EMAIL_PASSWORD=
-EMAIL_FOLDER=
-ATTACHMENTS_FOLDER=/attachments
+ATTACHMENTS_FOLDER=/attachments
--- a/api/common/Controller/Attachments.php
+++ b/api/common/Controller/Attachments.php
@ -1,19 +1,20 @@
 <?php
 namespace ProVM\Common\Controller;

-use ProVM\Common\Exception\Request\MissingArgument;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use ProVM\Common\Implement\Controller\Json;
-use ProVM\Common\Service\Attachments as Service;
-use ProVM\Emails\Model\Attachment;
 use Psr\Log\LoggerInterface;
+use ProVM\Common\Implement\Controller\Json;
+use ProVM\Common\Service;
+use ProVM\Emails\Model\Attachment;
+use ProVM\Common\Exception\Request\MissingArgument;
+use function Safe\json_decode;

 class Attachments
 {
    use Json;

-    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Service $service): ResponseInterface
+    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Service\Attachments $service): ResponseInterface
    {
        $attachments = array_map(function(Attachment $attachment) {
            return $attachment->toArray();
@ -24,35 +25,7 @@ class Attachments
        ];
        return $this->withJson($response, $output);
    }
-    public function grab(ServerRequestInterface $request, ResponseInterface $response, Service $service, \ProVM\Common\Service\Jobs $jobsService): ResponseInterface
-    {
-        $body = $request->getBody();
-        $json = \Safe\json_decode($body->getContents());
-        if (!isset($json->messages)) {
-            throw new MissingArgument('messages', 'array', 'message UIDs');
-        }
-        $output = [
-            'messages' => $json->messages,
-            'total' => count($json->messages),
-            'saved' => [
-                'attachments' => [],
-                'total' => 0
-            ]
-        ];
-        foreach ($json->messages as $message_id) {
-            if (!$jobsService->isPending($message_id)) {
-                continue;
-            }
-            if ($service->grab($message_id)) {
-                $job = $jobsService->find($message_id);
-                $jobsService->execute($job->getId());
-                $output['saved']['attachments'] []= $job->toArray();
-                $output['saved']['total'] ++;
-            }
-        }
-        return $this->withJson($response, $output);
-    }
-    public function get(ServerRequestInterface $request, ResponseInterface $response, Service $service, LoggerInterface $logger, int $attachment_id): ResponseInterface
+    public function get(ServerRequestInterface $request, ResponseInterface $response, Service\Attachments $service, LoggerInterface $logger, int $attachment_id): ResponseInterface
    {
        $attachment = $service->getRepository()->fetchById($attachment_id);

@ -61,4 +34,25 @@ class Attachments
        $response->getBody()->write($service->getFile($attachment_id));
        return $response;
    }
-}
+    public function grab(ServerRequestInterface $request, ResponseInterface $response, Service\Attachments $service, Service\Messages $messagesService): ResponseInterface
+    {
+        $body = $request->getBody();
+        $json = json_decode($body->getContents());
+        if (!isset($json->messages)) {
+            throw new MissingArgument('messages', 'array', 'Messages UIDs');
+        }
+        $output = [
+            'messages' => $json->messages,
+            'attachments' => [],
+            'total' => 0
+        ];
+        foreach ($json->messages as $message_uid) {
+            $message = $messagesService->getLocalMessage($message_uid);
+            $attachments = $service->grab($message->getId());
+            $output['attachments'] = array_merge($output['attachments'], $attachments);
+            $output['total'] += count($attachments);
+        }
+
+        return $this->withJson($response, $output);
+    }
+}
--- a/api/common/Controller/Base.php
+++ b/api/common/Controller/Base.php
@ -12,7 +12,8 @@ class Base
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        return $this->withJson($response, [
-            'version' => '1.0.0'
+            'version' => '1.0.0',
+            'app' => 'emails'
        ]);
    }
-}
+}
--- a/api/common/Controller/Jobs.php
+++ b/api/common/Controller/Jobs.php
@ -1,45 +1,85 @@
 <?php
 namespace ProVM\Common\Controller;

-use ProVM\Emails\Model\Job;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use ProVM\Common\Exception\Request\MissingArgument;
 use ProVM\Common\Implement\Controller\Json;
 use ProVM\Common\Service\Jobs as Service;
+use function Safe\json_decode;

 class Jobs
 {
    use Json;

-    public function schedule(ServerRequestInterface $request, ResponseInterface $response, Service $jobsService): ResponseInterface
+    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Service $service): ResponseInterface
+    {
+        $jobs = $service->getRepository()->fetchAll();
+        return $this->withJson($response, compact('jobs'));
+    }
+    public function schedule(ServerRequestInterface $request, ResponseInterface $response, Service $service): ResponseInterface
    {
        $body = $request->getBody();
-        $json = \Safe\json_decode($body->getContents());
-        if (!isset($json->messages)) {
-            throw new MissingArgument('messages', 'array', 'messages ids');
+        $json = json_decode($body->getContents());
+        if (!isset($json->jobs)) {
+            throw new MissingArgument('jobs', 'array', 'job commands with arguments');
        }
        $output = [
-            'messages' => $json->messages,
-            'total' => count($json->messages),
+            'jobs' => $json->jobs,
+            'total' => count($json->jobs),
            'scheduled' => 0
        ];
-        foreach ($json->messages as $message_id) {
-            if ($jobsService->schedule($message_id)) {
+        foreach ($json->jobs as $job) {
+            if ($service->queue($job->command, $job->arguments)) {
                $output['scheduled'] ++;
            }
        }
        return $this->withJson($response, $output);
    }
-    public function pending(ServerRequestInterface $request, ResponseInterface $response, Service $jobsService): ResponseInterface
+    public function pending(ServerRequestInterface $request, ResponseInterface $response, Service $service): ResponseInterface
    {
-        $pending = array_map(function(Job $job) {
-            return $job->toArray();
-        }, $jobsService->getPending());
+        $pending = $service->getPending();
        $output = [
            'total' => count($pending),
-            'pending' => $pending
+            'jobs' => $pending
        ];
        return $this->withJson($response, $output);
    }
-}
+    public function pendingCommands(ServerRequestInterface $request, ResponseInterface $response, Service $service): ResponseInterface
+    {
+        $body = $response->getBody();
+        $json = json_decode($body->getContents());
+        if (!isset($json->commands)) {
+            throw new MissingArgument('commands', 'array', 'job commands');
+        }
+        $output = [
+            'commands' => $json->commands,
+            'total' => count($json->commands),
+            'pending' => []
+        ];
+        foreach ($json->commands as $command) {
+            $pending = $service->getPendingByCommand($command);
+            if (count($pending) === 0) {
+                continue;
+            }
+            $output['pending'][$command] = $pending;
+        }
+        return $this->withJson($response, $output);
+    }
+    public function finish(ServerRequestInterface $request, ResponseInterface $response, Service $service, $job_id): ResponseInterface
+    {
+        $output = [
+            'job_id' => $job_id,
+            'status' => $service->finish($job_id)
+        ];
+        return $this->withJson($response, $output);
+    }
+    public function failed(ServerRequestInterface $request, ResponseInterface $response, Service $service, $job_id): ResponseInterface
+    {
+        $output = [
+            'job_id' => $job_id,
+            'status' => $service->failed($job_id)
+        ];
+        return $this->withJson($response, $output);
+    }
+}
--- a/api/common/Controller/Messages.php
+++ b/api/common/Controller/Messages.php
@ -1,24 +1,35 @@
 <?php
 namespace ProVM\Common\Controller;

-use Ddeboer\Imap\Exception\MessageDoesNotExistException;
+use ProVM\Common\Exception\Request\MissingArgument;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
-use ProVM\Common\Exception\Request\MissingArgument;
 use ProVM\Common\Implement\Controller\Json;
-use ProVM\Common\Service\Messages as Service;
+use ProVM\Common\Service;
 use ProVM\Emails\Model\Message;
+use function Safe\json_decode;

 class Messages
 {
    use Json;

-    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Service $service, int $mailbox_id): ResponseInterface
+    public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Service\Messages $service, int $mailbox_id): ResponseInterface
    {
        $mailbox = $service->getMailboxes()->get($mailbox_id);
        $messages = array_map(function(Message $message) {
            return $message->toArray();
        }, $service->getAll($mailbox->getName()));
+        usort($messages, function($a, $b) {
+            $d = $a['date_time'] - $b['date_time'];
+            if ($d->days === 0) {
+                $f = strcmp($a['from'], $b['from']);
+                if ($f === 0) {
+                    return strcmp($a['subject'], $b['subject']);
+                }
+                return $f;
+            }
+            return $d->format('%r%a');
+        });
        $output = [
            'mailbox' => $mailbox->toArray(),
            'total' => count($messages),
@ -26,7 +37,7 @@ class Messages
        ];
        return $this->withJson($response, $output);
    }
-    public function valid(ServerRequestInterface $request, ResponseInterface $response, Service $service, \ProVM\Common\Service\Attachments $attachments, int $mailbox_id): ResponseInterface
+    public function valid(ServerRequestInterface $request, ResponseInterface $response, Service\Messages $service, Service\Attachments $attachments, int $mailbox_id): ResponseInterface
    {
        $mailbox = $service->getMailboxes()->get($mailbox_id);
        $messages = array_values(array_filter(array_map(function(Message $message) use ($service, $attachments) {
@ -34,6 +45,17 @@ class Messages
        }, $service->getValid($mailbox->getName())), function($message) {
            return $message !== null;
        }));
+        usort($messages, function($a, $b) {
+            $d = strcmp($a['date_time'], $b['date_time']);
+            if ($d === 0) {
+                $f = strcmp($a['from'], $b['from']);
+                if ($f === 0) {
+                    return strcmp($a['subject'], $b['subject']);
+                }
+                return $f;
+            }
+            return $d;
+        });
        $output = [
            'mailbox' => $mailbox->toArray(),
            'total' => count($messages),
@ -41,33 +63,49 @@ class Messages
        ];
        return $this->withJson($response, $output);
    }
-    public function get(ServerRequestInterface $request, ResponseInterface $response, Service $service, int $message_id): ResponseInterface
+    public function get(ServerRequestInterface $request, ResponseInterface $response, Service\Messages $service, int $message_id): ResponseInterface
    {
        $message = $service->getRepository()->fetchById($message_id);
        return $this->withJson($response, ['message' => $message->toArray()]);
    }
-    public function grab(ServerRequestInterface $request, ResponseInterface $response, Service $service, \ProVM\Common\Service\Attachments $attachmentsService): ResponseInterface
+    public function grab(ServerRequestInterface $request, ResponseInterface $response, Service\Messages $service, \ProVM\Common\Service\Attachments $attachmentsService, $mailbox_id): ResponseInterface
+    {
+        $output = [
+            'mailbox_id' => $mailbox_id,
+            'messages' => [],
+            'count' => 0
+        ];
+        $mailbox = $service->getMailboxes()->get($mailbox_id);
+        $messages = $service->grab($mailbox->getName());
+        foreach ($messages as $message_id) {
+            $message = $service->getLocalMessage($message_id);
+            if ($message->hasValidAttachments()) {
+                $attachmentsService->create($message->getId());
+            }
+        }
+        $output['messages'] = $messages;
+        $output['count'] = count($messages);
+        return $this->withJson($response, $output);
+    }
+    public function schedule(ServerRequestInterface $request, ResponseInterface $response, Service\Messages $service, Service\Jobs $jobsService): ResponseInterface
    {
        $body = $request->getBody();
-        $json = \Safe\json_decode($body->getContents());
-        if (!isset($json->mailboxes)) {
-            throw new MissingArgument('mailboxes', 'array', 'mailboxes names');
+        $json = json_decode($body);
+        if (!isset($json->messages)) {
+            throw new MissingArgument('messages', 'array', 'messages IDs');
        }
        $output = [
-            'mailboxes' => $json->mailboxes,
-            'messages' => [],
-            'message_count' => 0
+            'messages' => $json->messages,
+            'scheduled' => 0
        ];
-        foreach ($json->mailboxes as $mailbox_name) {
-            $messages = $service->grab($mailbox_name);
-            foreach ($messages as $message) {
-                if ($message->hasValidAttachments()) {
-                    $attachmentsService->create($message);
-                }
+        foreach ($json->messages as $message_id) {
+            if ($jobsService->queue('attachments:grab', [$message_id])) {
+                $message = $service->getRepository()->fetchById($message_id);
+                $message->doesHaveScheduledDownloads();
+                $service->getRepository()->save($message);
+                $output['scheduled'] ++;
            }
-            $output['messages'] = array_merge($output['messages'], $messages);
-            $output['message_count'] += count($messages);
        }
        return $this->withJson($response, $output);
    }
-}
+}
--- a/api/common/Define/Model.php
+++ b/api/common/Define/Model.php
@ -1,6 +1,8 @@
 <?php
 namespace ProVM\Common\Define;

-interface Model
+use JsonSerializable;
+
+interface Model extends JsonSerializable
 {
-}
+}
--- a/api/common/Define/Repository.php
+++ b/api/common/Define/Repository.php
@ -0,0 +1,28 @@
+<?php
+namespace ProVM\Common\Define;
+
+use PDO;
+use Psr\Log\LoggerInterface;
+
+interface Repository
+{
+    public function getConnection(): PDO;
+    public function getTable(): string;
+    public function getLogger(): LoggerInterface;
+
+    public function setConnection(PDO $pdo): Repository;
+    public function setTable(string $table): Repository;
+    public function setLogger(LoggerInterface $logger): Repository;
+
+    public function isInstalled(): bool;
+    public function install();
+    public function resetIndex(): void;
+
+    public function create(array $data): Model;
+    public function save(Model &$model): void;
+    public function fetchAll(): array;
+    public function fetchById(int $id): Model;
+    public function update(Model $model, Model $old): void;
+    public function optimize(): void;
+    public function delete(Model $model): void;
+}
--- a/api/common/Exception/Job/Stateless.php
+++ b/api/common/Exception/Job/Stateless.php
@ -0,0 +1,15 @@
+<?php
+namespace ProVM\Common\Exception\Job;
+
+use Exception;
+use Throwable;
+
+class Stateless extends Exception
+{
+    public function __construct(int $job_id, ?Throwable $previous = null)
+    {
+        $message = "Job {$job_id} does not have any state";
+        $code = 2002;
+        parent::__construct($message, $code, $previous);
+    }
+}
--- a/api/common/Exception/Mailbox/EmptyMailbox.php
+++ b/api/common/Exception/Mailbox/EmptyMailbox.php
@ -1,8 +1,9 @@
 <?php
 namespace ProVM\Common\Exception;

-use Ddeboer\Imap\MailboxInterface;
 use Exception;
+use Throwable;
+use Ddeboer\Imap\MailboxInterface;

 class EmptyMailbox extends Exception
 {
@ -12,4 +13,4 @@ class EmptyMailbox extends Exception
        $code = 101;
        parent::__construct($message, $code, $previous);
    }
-}
+}
--- a/api/common/Exception/Mailbox/Invalid.php
+++ b/api/common/Exception/Mailbox/Invalid.php
@ -2,6 +2,7 @@
 namespace ProVM\Common\Exception\Mailbox;

 use Exception;
+use Throwable;

 class Invalid extends Exception
 {
@ -11,4 +12,4 @@ class Invalid extends Exception
        $code = 100;
        parent::__construct($message, $code, $previous);
    }
-}
+}
--- a/api/common/Exception/Mailbox/Stateless.php
+++ b/api/common/Exception/Mailbox/Stateless.php
@ -2,6 +2,7 @@
 namespace ProVM\Common\Exception\Mailbox;

 use Exception;
+use Throwable;
 use ProVM\Emails\Model\Mailbox;

 class Stateless extends Exception
@ -12,4 +13,4 @@ class Stateless extends Exception
        $code = 102;
        parent::__construct($message, $code, $previous);
    }
-}
+}
--- a/api/common/Exception/Request/Auth/Forbidden.php
+++ b/api/common/Exception/Request/Auth/Forbidden.php
@ -0,0 +1,15 @@
+<?php
+namespace ProVM\Common\Exception\Request\Auth;
+
+use Exception;
+use Throwable;
+
+class Forbidden extends Exception
+{
+    public function __construct(?Throwable $previous = null)
+    {
+        $message = 'Forbidden';
+        $code = 413;
+        parent::__construct($message, $code, $previous);
+    }
+}
--- a/api/common/Exception/Request/Auth/Unauthorized.php
+++ b/api/common/Exception/Request/Auth/Unauthorized.php
@ -0,0 +1,15 @@
+<?php
+namespace ProVM\Common\Exception\Request\Auth;
+
+use Exception;
+use Throwable;
+
+class Unauthorized extends Exception
+{
+    public function __construct(?Throwable $previous = null)
+    {
+        $message = 'Unauthorized';
+        $code = 401;
+        parent::__construct($message, $code, $previous);
+    }
+}
--- a/api/common/Factory/Model.php
+++ b/api/common/Factory/Model.php
@ -55,4 +55,4 @@ class Model
        }
        return $this->getContainer()->get($repository_class);
    }
-}
+}
--- a/api/common/Implement/Repository.php
+++ b/api/common/Implement/Repository.php
@ -3,11 +3,11 @@ namespace ProVM\Common\Implement;

 use PDO;
 use PDOException;
-use ProVM\Common\Exception\Database\BlankResult;
 use Psr\Log\LoggerInterface;
-use ProVM\Common\Define\Model as ModelInterface;
+use ProVM\Common\Exception\Database\BlankResult;
+use ProVM\Common\Define;

-abstract class Repository
+abstract class Repository implements Define\Repository
 {
    public function __construct(PDO $connection, LoggerInterface $logger)
    {
@ -32,33 +32,32 @@ abstract class Repository
        return $this->logger;
    }

-    public function setConnection(PDO $pdo): Repository
+    public function setConnection(PDO $pdo): Define\Repository
    {
        $this->connection = $pdo;
        return $this;
    }
-    public function setTable(string $table): Repository
+    public function setTable(string $table): Define\Repository
    {
        $this->table = $table;
        return $this;
    }
-    public function setLogger(LoggerInterface $logger): Repository
+    public function setLogger(LoggerInterface $logger): Define\Repository
    {
        $this->logger = $logger;
        return $this;
    }

-    abstract protected function fieldsForUpdate(): array;
-    abstract protected function valuesForUpdate(ModelInterface $model): array;
-    protected function idProperty(): string
+    public function isInstalled(): bool
    {
-        return 'getId';
+        $query = "SHOW TABLES LIKE '{$this->getTable()}'";
+        $st = $this->getConnection()->query($query);
+        if ($st === false) {
+            throw new PDOException("Could not run query {$query}");
+        }
+        return $st->rowCount() > 0;
    }
-    protected function idField(): string
-    {
-        return 'id';
-    }
-    public function update(ModelInterface $model, ModelInterface $old): void
+    public function update(Define\Model $model, Define\Model $old): void
    {
        $query = "UPDATE `{$this->getTable()}` SET ";
        $model_values = $this->valuesForUpdate($model);
@ -79,22 +78,7 @@ abstract class Repository
        $st = $this->getConnection()->prepare($query);
        $st->execute($values);
    }
-    abstract protected function fieldsForInsert(): array;
-    abstract protected function valuesForInsert(ModelInterface $model): array;
-    protected function insert(ModelInterface $model): void
-    {
-        $fields = $this->fieldsForInsert();
-        $fields_string = implode(', ', array_map(function($field) {
-            return "`{$field}`";
-        }, $fields));
-        $fields_questions = implode(', ', array_fill(0, count($fields), '?'));
-        $query = "INSERT INTO `{$this->getTable()}` ({$fields_string}) VALUES ({$fields_questions})";
-        $values = $this->valuesForInsert($model);
-        $st = $this->getConnection()->prepare($query);
-        $st->execute($values);
-    }
-    abstract protected function defaultFind(ModelInterface $model): ModelInterface;
-    public function save(ModelInterface &$model): void
+    public function save(Define\Model &$model): void
    {
        try {
            $old = $this->defaultFind($model);
@ -107,12 +91,7 @@ abstract class Repository
            throw $e;
        }
    }
-    abstract public function load(array $row): ModelInterface;
-
-    abstract protected function fieldsForCreate(): array;
-    abstract protected function valuesForCreate(array $data): array;
-    abstract protected function defaultSearch(array $data): ModelInterface;
-    public function create(array $data): ModelInterface
+    public function create(array $data): Define\Model
    {
        try {
            return $this->defaultSearch($data);
@ -121,11 +100,6 @@ abstract class Repository
            return $this->load($data);
        }
    }
-
-    protected function getId(ModelInterface $model): int
-    {
-        return $model->getId();
-    }
    public function resetIndex(): void
    {
        $query = "ALTER TABLE `{$this->getTable()}` AUTO_INCREMENT = 1";
@ -136,7 +110,7 @@ abstract class Repository
        $query = "OPTIMIZE TABLE `{$this->getTable()}`";
        $this->getConnection()->query($query);
    }
-    public function delete(ModelInterface $model): void
+    public function delete(Define\Model $model): void
    {
        $query = "DELETE FROM `{$this->getTable()}` WHERE `{$this->idField()}` = ?";
        $st = $this->getConnection()->prepare($query);
@ -144,8 +118,42 @@ abstract class Repository
        $this->resetIndex();
        $this->optimize();
    }
+    public function fetchAll(): array
+    {
+        $query = "SELECT * FROM `{$this->getTable()}`";
+        return $this->fetchMany($query);
+    }
+    public function fetchById(int $id): Define\Model
+    {
+        $query = "SELECT * FROM `{$this->getTable()}` WHERE `{$this->idField()}` = ?";
+        return $this->fetchOne($query, [$id]);
+    }

-    protected function fetchOne(string $query, ?array $values = null): ModelInterface
+    protected function idProperty(): string
+    {
+        return 'getId';
+    }
+    protected function idField(): string
+    {
+        return 'id';
+    }
+    protected function insert(Define\Model $model): void
+    {
+        $fields = $this->fieldsForInsert();
+        $fields_string = implode(', ', array_map(function($field) {
+            return "`{$field}`";
+        }, $fields));
+        $fields_questions = implode(', ', array_fill(0, count($fields), '?'));
+        $query = "INSERT INTO `{$this->getTable()}` ({$fields_string}) VALUES ({$fields_questions})";
+        $values = $this->valuesForInsert($model);
+        $st = $this->getConnection()->prepare($query);
+        $st->execute($values);
+    }
+    protected function getId(Define\Model $model): int
+    {
+        return $model->getId();
+    }
+    protected function fetchOne(string $query, ?array $values = null): Define\Model
    {
        if ($values !== null) {
            $st = $this->getConnection()->prepare($query);
@ -174,14 +182,14 @@ abstract class Repository
        return array_map([$this, 'load'], $rows);
    }

-    public function fetchAll(): array
-    {
-        $query = "SELECT * FROM `{$this->getTable()}`";
-        return $this->fetchMany($query);
-    }
-    public function fetchById(int $id): ModelInterface
-    {
-        $query = "SELECT * FROM `{$this->getTable()}` WHERE `{$this->idField()}` = ?";
-        return $this->fetchOne($query, [$id]);
-    }
-}
+    abstract public function install(): void;
+    abstract public function load(array $row): Define\Model;
+    abstract protected function fieldsForUpdate(): array;
+    abstract protected function valuesForUpdate(Define\Model $model): array;
+    abstract protected function fieldsForInsert(): array;
+    abstract protected function valuesForInsert(Define\Model $model): array;
+    abstract protected function defaultFind(Define\Model $model): Define\Model;
+    abstract protected function fieldsForCreate(): array;
+    abstract protected function valuesForCreate(array $data): array;
+    abstract protected function defaultSearch(array $data): Define\Model;
+}
--- a/api/common/Middleware/Attachments.php
+++ b/api/common/Middleware/Attachments.php
@ -0,0 +1,25 @@
+<?php
+namespace ProVM\Common\Middleware;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Psr\Log\LoggerInterface;
+use ProVM\Common\Exception\Database\BlankResult;
+use ProVM\Common\Service;
+
+class Attachments
+{
+    public function __construct(protected Service\Attachments $service, protected LoggerInterface $logger) {}
+
+    public function __invoke(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        try {
+            $this->service->checkDownloaded();
+            $this->service->checkEncryption();
+        } catch (BlankResult $e) {
+            $this->logger->notice($e);
+        }
+        return $handler->handle($request);
+    }
+}
--- a/api/common/Middleware/Auth.php
+++ b/api/common/Middleware/Auth.php
@ -6,19 +6,19 @@ use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\RequestHandlerInterface;
 use Psr\Log\LoggerInterface;
+use ProVM\Common\Exception\Request\Auth\Unauthorized;
+use ProVM\Common\Service\Auth as Service;

 class Auth
 {
-    public function __construct(ResponseFactoryInterface $factory, LoggerInterface $logger, string $api_key)
+    public function __construct(ResponseFactoryInterface $factory, LoggerInterface $logger, protected Service $service)
    {
        $this->setResponseFactory($factory);
        $this->setLogger($logger);
-        $this->setAPIKey($api_key);
    }

    protected ResponseFactoryInterface $factory;
    protected LoggerInterface $logger;
-    protected string $api_key;

    public function getResponseFactory(): ResponseFactoryInterface
    {
@ -28,10 +28,6 @@ class Auth
    {
        return $this->logger;
    }
-    public function getAPIKey(): string
-    {
-        return $this->api_key;
-    }

    public function setResponseFactory(ResponseFactoryInterface $factory): Auth
    {
@ -43,30 +39,23 @@ class Auth
        $this->logger = $logger;
        return $this;
    }
-    public function setAPIKey(string $key): Auth
-    {
-        $this->api_key = $key;
-        return $this;
-    }

    public function __invoke(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
    {
        if ($request->getMethod() === 'OPTIONS') {
            return $handler->handle($request);
        }
-        $auths = $request->getHeader('Authorization');
-        foreach ($auths as $auth) {
-            if (str_contains($auth, 'Bearer')) {
-                $key = str_replace('Bearer ', '', $auth);
-                if (sha1($this->getAPIKey()) === $key) {
-                    return $handler->handle($request);
-                }
+        try {
+            if ($this->service->validate($request)) {
+                return $handler->handle($request);
            }
+        } catch (Unauthorized $e) {
+            $response = $this->getResponseFactory()->createResponse($e->getCode());
+            $response->getBody()->write(json_encode(['error' => $e->getCode(), 'message' => $e->getMessage()]));
        }
-        $this->getLogger()->debug(sha1($this->getAPIKey()));
-        $response = $this->getResponseFactory()->createResponse(401);
-        $response->getBody()->write(\Safe\json_encode(['error' => 401, 'message' => 'Incorrect token']));
+        $response = $this->getResponseFactory()->createResponse(413);
+        $response->getBody()->write(\Safe\json_encode(['error' => 413, 'message' => 'Incorrect token']));
        return $response
            ->withHeader('Content-Type', 'application/json');
    }
-}
+}
--- a/api/common/Middleware/Install.php
+++ b/api/common/Middleware/Install.php
@ -0,0 +1,20 @@
+<?php
+namespace ProVM\Common\Middleware;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use ProVM\Common\Service\Install as Service;
+
+class Install
+{
+    public function __construct(protected Service $service) {}
+
+    public function __invoke(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        if (!$this->service->check()) {
+            $this->service->install();
+        }
+        return $handler->handle($request);
+    }
+}
--- a/api/common/Middleware/Logging.php
+++ b/api/common/Middleware/Logging.php
@ -0,0 +1,25 @@
+<?php
+namespace ProVM\Common\Middleware;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Psr\Log\LoggerInterface;
+use function Safe\json_encode;
+
+class Logging
+{
+    public function __construct(protected LoggerInterface $logger) {}
+
+    public function __invoke(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        $response = $handler->handle($request);
+        $output = [
+            'uri' => var_export($request->getUri(), true),
+            'body' => $request->getBody()->getContents(),
+            'response' => (clone $response)->getBody()->getContents()
+        ];
+        $this->logger->info(json_encode($output, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE));
+        return $response;
+    }
+}
--- a/api/common/Middleware/Mailboxes.php
+++ b/api/common/Middleware/Mailboxes.php
@ -0,0 +1,24 @@
+<?php
+namespace ProVM\Common\Middleware;
+
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Log\LoggerInterface;
+use ProVM\Common\Exception\Database\BlankResult;
+use ProVM\Common\Service;
+
+class Mailboxes
+{
+    public function __construct(protected Service\Messages $service, protected LoggerInterface $logger) {}
+
+    public function __invoke(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
+    {
+        try {
+            $this->service->checkUpdate();
+        } catch (BlankResult $e) {
+            $this->logger->notice($e);
+        }
+        return $handler->handle($request);
+    }
+}
--- a/api/common/Service/Attachments.php
+++ b/api/common/Service/Attachments.php
@ -1,15 +1,15 @@
 <?php
 namespace ProVM\Common\Service;

+use ProVM\Common\Exception\Database\BlankResult;
+use Psr\Log\LoggerInterface;
 use Ddeboer\Imap\Message\AttachmentInterface;
 use Ddeboer\Imap\MessageInterface;
-use Nyholm\Psr7\Stream;
+use Safe\Exceptions\FilesystemException;
 use ProVM\Common\Exception\Message\NoAttachments;
 use ProVM\Emails\Model\Message;
 use ProVM\Emails\Repository\Attachment;
-use Psr\Http\Message\StreamInterface;
-use Psr\Log\LoggerInterface;
-use Safe\Exceptions\FilesystemException;
+use function Safe\{file_get_contents,file_put_contents};

 class Attachments extends Base
 {
@ -100,13 +100,33 @@ class Attachments extends Base
                $attachment->getFullFilename()
            ]);
        }
-        return \Safe\file_get_contents($filename);
+        return file_get_contents($filename);
    }

    public function getAll(): array
    {
        return $this->getRepository()->fetchAll();
    }
+    public function getDownloadedFiles(): array
+    {
+        $downloaded = [];
+        $folder = $this->getFolder();
+        $files = new \FilesystemIterator($folder);
+        foreach ($files as $file) {
+            if ($file->isDir()) {
+                continue;
+            }
+            $name = $file->getBasename(".{$file->getExtension()}");
+            list($date, $subject, $filename) = explode(' - ', $name);
+            try {
+                $message = $this->getMessages()->find($subject, $date)[0];
+                $filename = "{$filename}.{$file->getExtension()}";
+                $downloaded []= compact('message', 'filename');
+            } catch (BlankResult $e) {
+            }
+        }
+        return $downloaded;
+    }
    public function create(int $message_id): array
    {
        $message = $this->getMessages()->getRepository()->fetchById($message_id);
@ -183,7 +203,7 @@ class Attachments extends Base
            $attachment->getFullFilename()
        ]);
        try {
-            \Safe\file_put_contents($destination, $remote_attachment->getDecodedContent());
+            file_put_contents($destination, $remote_attachment->getDecodedContent());
            return true;
        } catch (FilesystemException $e) {
            $this->getLogger()->error($e);
@ -236,6 +256,9 @@ class Attachments extends Base
        if (!$message->hasValidAttachments()) {
            return false;
        }
+        if ($message->hasDownloadedAttachments()) {
+            return true;
+        }
        foreach ($remote_message->getAttachments() as $attachment) {
            if (!str_contains($attachment->getFilename(), '.pdf')) {
                continue;
@ -247,4 +270,59 @@ class Attachments extends Base
        }
        return true;
    }
-}
+    public function find(Message $message, string $filename): \ProVM\Emails\Model\Attachment
+    {
+        return $this->getRepository()->fetchByMessageAndFilename($message->getId(), $filename);
+    }
+    public function exists(Message $message, string $filename): bool
+    {
+        try {
+            $this->find($message, $filename);
+            return true;
+        } catch (BlankResult $e) {
+            return false;
+        }
+    }
+    public function add(Message $message, string $filename): bool
+    {
+        $data = [
+            'message_id' => $message->getId(),
+            'filename' => $filename
+        ];
+        try {
+            $attachment = $this->getRepository()->create($data);
+            $attachment->itIsDownloaded();
+            $this->getRepository()->save($attachment);
+            $message->doesHaveDownloadedAttachments();
+            $this->getMessages()->getRepository()->save($message);
+            return true;
+        } catch (PDOException $e) {
+            $this->getLogger()->error($e);
+            return false;
+        }
+    }
+    public function checkDownloaded(): void
+    {
+        $data = $this->getDownloadedFiles();
+        foreach ($data as $info) {
+            if (!$this->exists($info['message'], $info['filename'])) {
+                $this->logger->info("Updating attachment {$info['filename']} for message {$info['message']->getSubject()}");
+                $this->add($info['message'], $info['filename']);
+            }
+        }
+    }
+    public function getDownloaded(): array
+    {
+        return $this->getRepository()->fetchDownloaded();
+    }
+    public function checkEncryption(): void
+    {
+        $attachments = $this->getDownloaded();
+        foreach ($attachments as $attachment) {
+            if ($attachment->isEncrypted() and !$attachment->isDecrypted()) {
+                $this->logger->notice("Schedule decrypt for {$attachment->getFullFilename()}");
+                $this->decrypt($attachment->getMessage(), $attachment->getFilename());
+            }
+        }
+    }
+}
--- a/api/common/Service/Auth.php
+++ b/api/common/Service/Auth.php
@ -0,0 +1,33 @@
+<?php
+namespace ProVM\Common\Service;
+
+use Psr\Http\Message\ServerRequestInterface;
+use ProVM\Common\Exception\Request\Auth\Unauthorized;
+
+class Auth
+{
+    public function __construct(protected string $api_key) {}
+
+    public function validate(ServerRequestInterface $request): bool
+    {
+        $key = $this->getHeaderKey($request);
+        if (sha1($this->api_key) === $key) {
+            return true;
+        }
+        return false;
+    }
+
+    protected function getHeaderKey(ServerRequestInterface $request): string
+    {
+        if (!$request->hasHeader('Authorization')) {
+            throw new Unauthorized();
+        }
+        $auths = $request->getHeader('Authorization');
+        foreach ($auths as $auth) {
+            if (str_contains($auth, 'Bearer')) {
+                return str_replace('Bearer ', '', $auth);
+            }
+        }
+        throw new Unauthorized();
+    }
+}
--- a/api/common/Service/Install.php
+++ b/api/common/Service/Install.php
@ -0,0 +1,40 @@
+<?php
+namespace ProVM\Common\Service;
+
+use ProVM\Common\Factory\Model;
+
+class Install
+{
+    public function __construct(protected Model $factory, protected array $model_list) {}
+
+    public function check(): bool
+    {
+        foreach ($this->model_list as $model_class) {
+            $repository = $this->factory->find($model_class);
+            if (!$repository->isInstalled()) {
+                return false;
+            }
+        }
+        return true;
+    }
+    public function install(): void
+    {
+        $check = true;
+        $repository = null;
+        foreach ($this->model_list as $model_class) {
+            $repository = $this->factory->find($model_class);
+            if ($check) {
+                $query = "SET FOREIGN_KEY_CHECKS = 0";
+                $repository->getConnection()->query($query);
+                $check = false;
+            }
+            if (!$repository->isInstalled()) {
+                $repository->install();
+            }
+        }
+        if (!$check) {
+            $query = "SET FOREIGN_KEY_CHECKS = 1";
+            $repository->getConnection()->query($query);
+        }
+    }
+}
--- a/api/common/Service/Jobs.php
+++ b/api/common/Service/Jobs.php
@ -1,40 +1,49 @@
 <?php
 namespace ProVM\Common\Service;

+use Illuminate\Support\Facades\Date;
 use PDOException;
 use ProVM\Common\Exception\Database\BlankResult;
 use Safe\DateTimeImmutable;
-use ProVM\Emails\Repository\Job;
+use ProVM\Emails\Repository;
+use ProVM\Emails\Model;

 class Jobs extends Base
 {
-    public function __construct(Job $repository)
+    public function __construct(Repository\Job $repository, protected Repository\State\Job $stateRepository)
    {
        $this->setRepository($repository);
    }

-    protected Job $repository;
+    protected Repository\Job $repository;

-    public function getRepository(): Job
+    public function getRepository(): Repository\Job
    {
        return $this->repository;
    }

-    public function setRepository(Job $repository): Jobs
+    public function setRepository(Repository\Job $repository): Jobs
    {
        $this->repository = $repository;
        return $this;
    }

-    public function schedule(int $message_id): bool
+    public function queue(string $command, ?array $arguments = null): bool
    {
        $data = [
-            'message_id' => $message_id,
-            'date_time' => (new DateTimeImmutable())->format('Y-m-d H:i:s')
+            'command' => $command,
+            'arguments' => implode(' ', $arguments)
        ];
        try {
            $job = $this->getRepository()->create($data);
            $this->getRepository()->save($job);
+            $data = [
+                'job_id' => $job->getId(),
+                'date_time' => (new DateTimeImmutable())->format('Y-m-d H:i:s'),
+                'status' => Model\State\Job::Pending
+            ];
+            $state = $this->stateRepository->create($data);
+            $this->stateRepository->save($state);
            return true;
        } catch (PDOException $e) {
            return false;
@ -44,28 +53,42 @@ class Jobs extends Base
    {
        return $this->getRepository()->fetchAllPending();
    }
-    public function isPending(int $message_id): bool
+    public function getPendingByCommand(string $command): array
    {
        try {
-            $this->getRepository()->fetchPendingByMessage($message_id);
-            return true;
+            return $this->getRepository()->fetchAllPendingByCommand($command);
        } catch (BlankResult $e) {
-            return false;
+            return [];
        }
    }
-    public function find(int $message_id): \ProVM\Emails\Model\Job
-    {
-        return $this->getRepository()->fetchPendingByMessage($message_id);
-    }
-    public function execute(int $job_id): bool
+    public function finish(int $job_id): bool
    {
+        $data = [
+            'job_id' => $job_id,
+            'date_time' => (new DateTimeImmutable())->format('Y-m-d H:i:s'),
+            'status' => Model\State\Job::Executed
+        ];
        try {
-            $job = $this->getRepository()->fetchById($job_id);
-            $job->wasExecuted();
-            $this->getRepository()->save($job);
+            $state = $this->stateRepository->create($data);
+            $this->stateRepository->save($state);
            return true;
        } catch (PDOException $e) {
            return false;
        }
    }
-}
+    public function failed(int $job_id): bool
+    {
+        $data = [
+            'job_id' => $job_id,
+            'date_time' => (new DateTimeImmutable())->format('Y-m-d H:i:s'),
+            'status' => Model\State\Job::Failure
+        ];
+        try {
+            $state = $this->stateRepository->create($data);
+            $this->stateRepository->save($state);
+            return true;
+        } catch (PDOException $e) {
+            return false;
+        }
+    }
+}
--- a/api/common/Service/Mailboxes.php
+++ b/api/common/Service/Mailboxes.php
@ -11,7 +11,7 @@ use ProVM\Emails\Repository\State;

 class Mailboxes extends Base
 {
-    public function __construct(Mailbox $repository, Remote\Mailboxes $remoteService, State\Mailbox $states, LoggerInterface $logger)
+    public function __construct(Mailbox $repository, Remote\Mailboxes $remoteService, State\Mailbox $states, LoggerInterface $logger, protected int $max_update_days)
    {
        $this->setRepository($repository)
            ->setRemoteService($remoteService)
@ -35,7 +35,6 @@ class Mailboxes extends Base
    {
        return $this->statesRepository;
    }
-
    public function setRepository(Mailbox $repository): Mailboxes
    {
        $this->repository = $repository;
@ -110,6 +109,7 @@ class Mailboxes extends Base
            $this->getStatesRepository()->save($state);
            return true;
        } catch (PDOException $e) {
+            $this->getLogger()->error($e);
            return false;
        }
    }
@ -141,4 +141,13 @@ class Mailboxes extends Base
        }
        return true;
    }
-}
+    public function isUpdated(\ProVM\Emails\Model\Mailbox $mailbox): bool
+    {
+        $states = $mailbox->getStates();
+        if (count($states) === 0) {
+            return false;
+        }
+        $last = $states[count($states) - 1];
+        return abs((int) $last->getDateTime()->diff(new \DateTimeImmutable())->format('%r%a')) < $this->max_update_days;
+    }
+}
--- a/api/common/Service/Messages.php
+++ b/api/common/Service/Messages.php
@ -4,6 +4,7 @@ namespace ProVM\Common\Service;
 use Ddeboer\Imap\Exception\MessageDoesNotExistException;
 use Ddeboer\Imap\MailboxInterface;
 use PDOException;
+use ProVM\Common\Exception\Database\BlankResult;
 use ProVM\Common\Exception\Mailbox\Stateless;
 use Psr\Log\LoggerInterface;
 use Ddeboer\Imap\MessageInterface;
@ -14,17 +15,19 @@ use Safe\DateTimeImmutable;

 class Messages extends Base
 {
-    public function __construct(Mailboxes $mailboxes, Message $repository, Remote\Messages $remoteService, LoggerInterface $logger)
+    public function __construct(Mailboxes $mailboxes, Message $repository, Remote\Messages $remoteService, Jobs $jobsService, LoggerInterface $logger)
    {
        $this->setMailboxes($mailboxes)
            ->setRepository($repository)
            ->setRemoteService($remoteService)
+            ->setJobsService($jobsService)
            ->setLogger($logger);
    }

    protected Mailboxes $mailboxes;
    protected Message $repository;
    protected Remote\Messages $remoteService;
+    protected Jobs $jobsService;

    public function getMailboxes(): Mailboxes
    {
@ -38,6 +41,10 @@ class Messages extends Base
    {
        return $this->remoteService;
    }
+    public function getJobsService(): Jobs
+    {
+        return $this->jobsService;
+    }

    public function setMailboxes(Mailboxes $mailboxes): Messages
    {
@ -54,6 +61,11 @@ class Messages extends Base
        $this->remoteService = $service;
        return $this;
    }
+    public function setJobsService(Jobs $service): Messages
+    {
+        $this->jobsService = $service;
+        return $this;
+    }

    public function getLocalMessage(string $message_uid): \ProVM\Emails\Model\Message
    {
@ -174,4 +186,17 @@ class Messages extends Base
        }
        return false;
    }
-}
+    public function find(string $subject, string $date): array
+    {
+        return $this->repository->fetchAllBySubjectAndDate($subject, new DateTimeImmutable($date));
+    }
+    public function checkUpdate(): void
+    {
+        $registered = $this->getMailboxes()->getRegistered();
+        foreach ($registered as $mailbox) {
+            if (!$this->getMailboxes()->isUpdated($mailbox)) {
+                $this->getJobsService()->queue('messages:grab', [$mailbox->getId()]);
+            }
+        }
+    }
+}
--- a/api/docker-compose.yml
+++ b/api/docker-compose.yml
@ -7,7 +7,7 @@ services:
      - ${API_PATH:-.}:/app/api
      - ${API_PATH:-.}/nginx.conf:/etc/nginx/conf.d/api.conf
    ports:
-      - "${API_PORT:-8080}:8080"
+      - "${API_PORT:-8080}:81"
  api:
    profiles:
      - api
@ -18,7 +18,7 @@ services:
    env_file:
      - ${API_PATH:-.}/.env
      - ${API_PATH:-.}/.db.env
-      - .mail.env
+      - ${API_PATH:-.}/.mail.env
      - .key.env
    volumes:
      - ${API_PATH:-.}/:/app/api
--- a/api/nginx.conf
+++ b/api/nginx.conf
@ -1,15 +1,15 @@
 server {
-    listen 0.0.0.0:8080;
+    listen 81;
    root /app/api/public;
    index index.php index.html index.htm;

-    access_log /var/logs/nginx/access.log;
-    error_log /var/logs/nginx/error.log;
+    access_log /var/logs/nginx/api.access.log;
+    error_log /var/logs/nginx/api.error.log;

    location / {
-        try_files $uri $uri/ /index.php?$query_string;
+        try_files $uri /index.php$is_args$args;
    }
-    location ~ \.php$ {
+    location ~ \.php {
        if ($request_method = 'OPTIONS') {
            add_header 'Access-Control-Allow-Origin' '*';
            add_header 'Access-Control-Allow-Headers' 'Authorization,Accept,Origin,DNT,X-CustomHeader,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Content-Range,Range';
@ -26,11 +26,12 @@ server {

        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
+        include fastcgi_params;
        fastcgi_pass api:9000;
        fastcgi_index index.php;
-        include fastcgi_params;
        fastcgi_param REQUEST_URI $request_uri;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
+        fastcgi_param SCRIPT_NAME $fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
    }
-}
+}
--- a/api/public/index.php
+++ b/api/public/index.php
@ -7,7 +7,8 @@ $app = require_once implode(DIRECTORY_SEPARATOR, [
 Monolog\ErrorHandler::register($app->getContainer()->get(Psr\Log\LoggerInterface::class));
 try {
    $app->run();
-} catch (Error | Exception $e) {
+} catch (Error $e) {
    $app->getContainer()->get(Psr\Log\LoggerInterface::class)->error($e);
-    throw $e;
+} catch (Exception $e) {
+    $app->getContainer()->get(Psr\Log\LoggerInterface::class)->debug($e);
 }
--- a/api/resources/routes/01_mailboxes.php
+++ b/api/resources/routes/01_mailboxes.php
@ -11,6 +11,7 @@ $app->group('/mailboxes', function($app) {

 $app->group('/mailbox/{mailbox_id}', function($app) {
    $app->group('/messages', function($app) {
+        $app->get('/grab[/]', [Messages::class, 'grab']);
        $app->get('/valid[/]', [Messages::class, 'valid']);
        $app->get('[/]', Messages::class);
    });
--- a/api/resources/routes/02_attachments.php
+++ b/api/resources/routes/02_attachments.php
@ -2,10 +2,10 @@
 use ProVM\Common\Controller\Attachments;

 $app->group('/attachments', function($app) {
-    $app->put('/grab', [Attachments::class, 'grab']);
-    $app->post('/decrypt', [Attachments::class, 'decrypt']);
+    $app->put('/grab[/]', [Attachments::class, 'grab']);
+    $app->get('/pending[/]', [Attachments::class, 'pending']);
    $app->get('[/]', Attachments::class);
 });
 $app->group('/attachment/{attachment_id}', function($app) {
    $app->get('[/]', [Attachments::class, 'get']);
-});
+});
--- a/api/resources/routes/02_messages.php
+++ b/api/resources/routes/02_messages.php
@ -4,9 +4,9 @@ use ProVM\Common\Controller\Jobs;

 $app->group('/messages', function($app) {
    $app->put('/grab', [Messages::class, 'grab']);
-    $app->put('/schedule', [Jobs::class, 'schedule']);
-    $app->get('/pending', [Jobs::class, 'pending']);
+    $app->put('/schedule', [Messages::class, 'schedule']);
+    //$app->get('/pending', [Jobs::class, 'pending']);
 });
 $app->group('/message/{message_id}', function($app) {
    $app->get('[/]', [Messages::class, 'get']);
-});
+});
--- a/api/resources/routes/03_jobs.php
+++ b/api/resources/routes/03_jobs.php
@ -0,0 +1,15 @@
+<?php
+use ProVM\Common\Controller\Jobs;
+
+$app->group('/jobs', function($app) {
+    $app->group('/pending', function($app) {
+        $app->put('/command[/]', [Jobs::class, 'pendingCommands']);
+        $app->get('[/]', [Jobs::class, 'pending']);
+    });
+    $app->post('/schedule[/]', [Jobs::class, 'schedule']);
+    $app->get('[/]', Jobs::class);
+});
+$app->group('/job/{job_id}', function($app) {
+    $app->get('/finish[/]', [Jobs::class, 'finish']);
+    $app->get('/failed[/]', [Jobs::class, 'failed']);
+});
--- a/api/setup/app.php
+++ b/api/setup/app.php
@ -1,7 +1,10 @@
 <?php
+use DI\ContainerBuilder;
+use DI\Bridge\Slim\Bridge;
+
 require_once 'composer.php';

-$builder = new \DI\ContainerBuilder();
+$builder = new ContainerBuilder();

 $folders = [
    'settings',
@ -24,7 +27,7 @@ foreach ($folders as $f) {
        $builder->addDefinitions($file->getRealPath());
    }
 }
-$app = \DI\Bridge\Slim\Bridge::create($builder->build());
+$app = Bridge::create($builder->build());

 $folder = implode(DIRECTORY_SEPARATOR, [
    __DIR__,
--- a/api/setup/middleware/04_db.php
+++ b/api/setup/middleware/04_db.php
@ -0,0 +1,4 @@
+<?php
+$app->add($app->getContainer()->get(ProVM\Common\Middleware\Attachments::class));
+$app->add($app->getContainer()->get(ProVM\Common\Middleware\Mailboxes::class));
+$app->add($app->getContainer()->get(ProVM\Common\Middleware\Install::class));
--- a/api/setup/middleware/98_log.php
+++ b/api/setup/middleware/98_log.php
@ -0,0 +1,2 @@
+<?php
+$app->add($app->getContainer()->get(ProVM\Common\Middleware\Logging::class));
--- a/api/setup/settings/01_env.php
+++ b/api/setup/settings/01_env.php
@ -5,7 +5,7 @@ return [
            'host' => $_ENV['EMAIL_HOST'],
            'username' => $_ENV['EMAIL_USERNAME'],
            'password' => $_ENV['EMAIL_PASSWORD'],
-            'folder' => $_ENV['EMAIL_FOLDER'],
+            //'folder' => $_ENV['EMAIL_FOLDER'],
        ];
        if (isset($_ENV['EMAIL_PORT'])) {
            $data['port'] = $_ENV['EMAIL_PORT'];
@ -20,12 +20,15 @@ return [
        $arr = [
            'host' => 'db',
            'name' => $_ENV['MYSQL_DATABASE'],
-            'username' => $_ENV['MYSQL_USER'],
-            'password' => $_ENV['MYSQL_PASSWORD']
+            'user' => [
+                'name' => $_ENV['MYSQL_USER'],
+                'password' => $_ENV['MYSQL_PASSWORD']
+            ]
        ];
        if (isset($_ENV['MYSQL_PORT'])) {
            $arr['port'] = $_ENV['MYSQL_PORT'];
        }
-        return (object) $arr;
-    }
+        return json_decode(json_encode($arr));
+    },
+    'max_update_days' => 7
 ];
--- a/api/setup/settings/02_folders.php
+++ b/api/setup/settings/02_folders.php
@ -18,4 +18,5 @@ return [
        ]);
    },
    'attachments_folder' => $_ENV['ATTACHMENTS_FOLDER'],
-];
+    'logs_folder' => '/logs',
+];
--- a/api/setup/settings/04_db.php
+++ b/api/setup/settings/04_db.php
@ -0,0 +1,33 @@
+<?php
+return [
+    'model_list' => function() {
+        function getClassesFromFolder(string $folder): array {
+            $classes = [];
+            $files = new FilesystemIterator($folder);
+            foreach ($files as $file) {
+                if ($file->isDir()) {
+                    $classes = array_merge($classes, getClassesFromFolder($file->getRealPath()));
+                    continue;
+                }
+                $classes []= ltrim(str_replace("\\\\", "\\", implode("\\", [
+                    'ProVM',
+                    'Emails',
+                    'Model',
+                    str_replace([implode(DIRECTORY_SEPARATOR, [
+                        dirname(__FILE__, 3),
+                        'src',
+                        'Model'
+                    ]), '/'], ['', "\\"], $folder),
+                    $file->getBasename(".{$file->getExtension()}")
+                ])), "\\");
+            }
+            return $classes;
+        }
+        $folder = implode(DIRECTORY_SEPARATOR, [
+            dirname(__FILE__, 3),
+            'src',
+            'Model'
+        ]);
+        return getClassesFromFolder($folder);
+    }
+];
--- a/api/setup/settings/98_log.php
+++ b/api/setup/settings/98_log.php
@ -1,4 +1,5 @@
 <?php
 return [
-    'log_file' => '/logs/php.log'
-];
+    'log_file' => '/logs/php.log',
+    'logstash_socket' => 'localhost:50000'
+];
--- a/api/setup/setups/01_emails.php
+++ b/api/setup/setups/01_emails.php
@ -5,13 +5,13 @@ return [
    Ddeboer\Imap\ServerInterface::class => function(ContainerInterface $container) {
        $emails = $container->get('emails');
        if (isset($emails->port)) {
-            return new \Ddeboer\Imap\Server($emails->host, $emails->port);
+            return new Ddeboer\Imap\Server($emails->host, $emails->port);
        }
-        return new \Ddeboer\Imap\Server($emails->host);
+        return new Ddeboer\Imap\Server($emails->host);
    },
-    \Ddeboer\Imap\ConnectionInterface::class => function(ContainerInterface $container) {
+    Ddeboer\Imap\ConnectionInterface::class => function(ContainerInterface $container) {
        $emails = $container->get('emails');
-        $server = $container->get(\Ddeboer\Imap\ServerInterface::class);
+        $server = $container->get(Ddeboer\Imap\ServerInterface::class);
        return $server->authenticate($emails->username, $emails->password);
    },
    PDO::class => function(ContainerInterface $container) {
@ -22,6 +22,6 @@ return [
        }
        $dsn []= "dbname={$database->name}";
        $dsn = implode(';', $dsn);
-        return new PDO($dsn, $database->username, $database->password);
+        return new PDO($dsn, $database->user->name, $database->user->password);
    },
 ];
--- a/api/setup/setups/02_services.php
+++ b/api/setup/setups/02_services.php
@ -18,5 +18,23 @@ return [
            $container->get('attachments_folder'),
            $container->get(Psr\Log\LoggerInterface::class)
        );
+    },
+    ProVM\Common\Service\Mailboxes::class => function(ContainerInterface $container) {
+        return new ProVM\Common\Service\Mailboxes(
+            $container->get(ProVM\Emails\Repository\Mailbox::class),
+            $container->get(ProVM\Common\Service\Remote\Mailboxes::class),
+            $container->get(ProVM\Emails\Repository\State\Mailbox::class),
+            $container->get(Psr\Log\LoggerInterface::class),
+            $container->get('max_update_days')
+        );
+    },
+    ProVM\Common\Service\Install::class => function(ContainerInterface $container) {
+        return new ProVM\Common\Service\Install(
+            $container->get(ProVM\Common\Factory\Model::class),
+            $container->get('model_list')
+        );
+    },
+    ProVM\Common\Service\Auth::class => function(ContainerInterface $container) {
+        return new ProVM\Common\Service\Auth($container->get('api_key'));
    }
 ];
--- a/api/setup/setups/03_factories.php
+++ b/api/setup/setups/03_factories.php
@ -2,16 +2,17 @@
 use Psr\Container\ContainerInterface;

 return [
-    \ProVM\Common\Factory\Model::class => function(ContainerInterface $container) {
-        $factory = new \ProVM\Common\Factory\Model($container);
-        $repositories = [
-            'Mailbox' => \ProVM\Emails\Repository\Mailbox::class,
-            'Message' => \ProVM\Emails\Repository\Message::class,
-            'Attachment' => \ProVM\Emails\Repository\Attachment::class,
-            "State\\Mailbox" => \ProVM\Emails\Repository\State\Mailbox::class,
-            "State\\Message" => \ProVM\Emails\Repository\State\Message::class,
-            "State\\Attachment" => \ProVM\Emails\Repository\State\Attachment::class
-        ];
-        return $factory->setRepositories($repositories);
+    ProVM\Common\Factory\Model::class => function(ContainerInterface $container) {
+        $factory = new ProVM\Common\Factory\Model($container);
+        return $factory->setRepositories([
+            'Mailbox' => ProVM\Emails\Repository\Mailbox::class,
+            'Message' => ProVM\Emails\Repository\Message::class,
+            'Attachment' => ProVM\Emails\Repository\Attachment::class,
+            'Job' => ProVM\Emails\Repository\Job::class,
+            "State\\Mailbox" => ProVM\Emails\Repository\State\Mailbox::class,
+            "State\\Message" => ProVM\Emails\Repository\State\Message::class,
+            "State\\Attachment" => ProVM\Emails\Repository\State\Attachment::class,
+            "State\\Job" => ProVM\Emails\Repository\State\Job::class,
+        ]);
    }
-];
+];
--- a/api/setup/setups/04_middlewares.php
+++ b/api/setup/setups/04_middlewares.php
@ -7,5 +7,8 @@ return [
            $container->get(Nyholm\Psr7\Factory\Psr17Factory::class),
            $container->get(Psr\Log\LoggerInterface::class)
        );
-    }
-];
+    },
+    ProVM\Common\Middleware\Logging::class => function(ContainerInterface $container) {
+        return new ProVM\Common\Middleware\Logging($container->get('request_logger'));
+    },
+];
--- a/api/setup/setups/97_auth.php
+++ b/api/setup/setups/97_auth.php
@ -2,11 +2,11 @@
 use Psr\Container\ContainerInterface;

 return [
-    \ProVM\Common\Middleware\Auth::class => function(ContainerInterface $container) {
-        return new \ProVM\Common\Middleware\Auth(
-            $container->get(\Nyholm\Psr7\Factory\Psr17Factory::class),
-            $container->get(\Psr\Log\LoggerInterface::class),
-            $container->get('api_key')
+    ProVM\Common\Middleware\Auth::class => function(ContainerInterface $container) {
+        return new ProVM\Common\Middleware\Auth(
+            $container->get(Nyholm\Psr7\Factory\Psr17Factory::class),
+            $container->get(Psr\Log\LoggerInterface::class),
+            $container->get(ProVM\Common\Service\Auth::class)
        );
    }
 ];
--- a/api/setup/setups/98_log.php
+++ b/api/setup/setups/98_log.php
@ -2,21 +2,61 @@
 use Psr\Container\ContainerInterface;

 return [
-    Monolog\Handler\DeduplicationHandler::class => function(ContainerInterface $container) {
-        return new Monolog\Handler\DeduplicationHandler($container->get(Monolog\Handler\RotatingFileHandler::class));
+    'log_processors' => function(ContainerInterface $container) {
+        return [
+            $container->get(Monolog\Processor\PsrLogMessageProcessor::class),
+            $container->get(Monolog\Processor\IntrospectionProcessor::class),
+            $container->get(Monolog\Processor\WebProcessor::class),
+            $container->get(Monolog\Processor\MemoryPeakUsageProcessor::class),
+        ];
    },
-    Monolog\Handler\RotatingFileHandler::class => function(ContainerInterface $container) {
-        $handler = new Monolog\Handler\RotatingFileHandler($container->get('log_file'));
-        $handler->setFormatter($container->get(Monolog\Formatter\SyslogFormatter::class));
-        return $handler;
+    'request_log_handler' => function(ContainerInterface $container) {
+        return (new Monolog\Handler\RotatingFileHandler(implode(DIRECTORY_SEPARATOR, [$container->get('logs_folder'), 'requests.log'])));
+    },
+    'request_logger' => function(ContainerInterface $container) {
+        return new Monolog\Logger(
+            'request_logger',
+            [$container->get('request_log_handler')],
+            $container->get('log_processors')
+        );
+    },
+    'file_log_handler' => function(ContainerInterface $container) {
+        return new Monolog\Handler\FilterHandler(
+            (new Monolog\Handler\RotatingFileHandler($container->get('log_file')))
+                ->setFormatter(new Monolog\Formatter\LineFormatter(null, null, true)),
+            Monolog\Level::Error
+        );
+    },
+    'debug_log_handler' => function(ContainerInterface $container) {
+        return new Monolog\Handler\FilterHandler(
+            (new Monolog\Handler\RotatingFileHandler(implode(DIRECTORY_SEPARATOR, [$container->get('logs_folder'), 'debug.log'])))
+                ->setFormatter(new Monolog\Formatter\LineFormatter(null, null, true)),
+            Monolog\Level::Debug,
+            Monolog\Level::Warning
+        );
    },
    Psr\Log\LoggerInterface::class => function(ContainerInterface $container) {
-        $logger = new Monolog\Logger('file_logger');
-        $logger->pushHandler($container->get(Monolog\Handler\DeduplicationHandler::class));
-        //$logger->pushHandler($container->get(Monolog\Handler\RotatingFileHandler::class));
-        $logger->pushProcessor($container->get(Monolog\Processor\PsrLogMessageProcessor::class));
-        $logger->pushProcessor($container->get(Monolog\Processor\IntrospectionProcessor::class));
-        $logger->pushProcessor($container->get(Monolog\Processor\MemoryUsageProcessor::class));
-        return $logger;
+        return $container->get('file_logger');
+    },
+    'file_logger' => function(ContainerInterface $container) {
+        return new Monolog\Logger(
+            'file',
+            [
+                $container->get('file_log_handler'),
+                $container->get('debug_log_handler')
+            ],
+            $container->get('log_processors')
+        );
+    },
+    'elk_logger' => function(ContainerInterface $container) {
+        return new Monolog\Logger('elk', [
+            (new Monolog\Handler\SocketHandler($container->get('logstash_socket')))
+                ->setFormatter(new Monolog\Formatter\LogstashFormatter('emails', 'docker'))
+        ], [
+            new Monolog\Processor\PsrLogMessageProcessor(),
+            new Monolog\Processor\WebProcessor(),
+            new Monolog\Processor\IntrospectionProcessor(),
+            new Monolog\Processor\MemoryPeakUsageProcessor()
+        ]);
    }
-];
+];
--- a/api/src/Model/Attachment.php
+++ b/api/src/Model/Attachment.php
@ -95,9 +95,9 @@ class Attachment implements Model
    public function getFullFilename(): string
    {
        return implode(' - ', [
-            $this->getMessage()->getSubject(),
            $this->getMessage()->getDateTime()->format('Y-m-d His'),
-            $this->getFilename()
+            $this->getMessage()->getSubject(),
+            $this->getFilename(),
        ]);
    }

@ -169,4 +169,8 @@ class Attachment implements Model
            'decrypted' => $this->isDecrypted()
        ];
    }
-}
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/Job.php
+++ b/api/src/Model/Job.php
@ -3,29 +3,27 @@ namespace ProVM\Emails\Model;

 use DateTimeInterface;
 use ProVM\Common\Define\Model;
+use ProVM\Common\Exception\Database\BlankResult;
+use ProVM\Common\Exception\Job\Stateless;
+use ProVM\Emails;

 class Job implements Model
 {
    protected int $id;
-    protected Message $message;
-    protected DateTimeInterface $dateTime;
-    protected bool $executed;
+    protected string $command;
+    protected string $arguments;

    public function getId(): int
    {
        return $this->id;
    }
-    public function getMessage(): Message
+    public function getCommand(): string
    {
-        return $this->message;
+        return $this->command;
    }
-    public function getDateTime(): DateTimeInterface
+    public function getArguments(): string
    {
-        return $this->dateTime;
-    }
-    public function isExecuted(): bool
-    {
-        return $this->executed ?? false;
+        return $this->arguments ?? '';
    }

    public function setId(int $id): Job
@ -33,29 +31,76 @@ class Job implements Model
        $this->id = $id;
        return $this;
    }
-    public function setMessage(Message $message): Job
+    public function setCommand(string $command): Job
    {
-        $this->message = $message;
+        $this->command = $command;
        return $this;
    }
-    public function setDateTime(DateTimeInterface $dateTime): Job
+    public function setArguments(string $arguments): Job
    {
-        $this->dateTime = $dateTime;
+        $this->arguments = $arguments;
        return $this;
    }
-    public function wasExecuted(): Job
+
+    protected Emails\Repository\State\Job $stateRepository;
+    public function getStateRepository(): Emails\Repository\State\Job
    {
-        $this->executed = true;
+        return $this->stateRepository;
+    }
+    public function setStateRepository(Emails\Repository\State\Job $repository): Job
+    {
+        $this->stateRepository = $repository;
        return $this;
    }

+    protected array $states;
+    public function getStates(): array
+    {
+        if (!isset($this->states)) {
+            try {
+                $this->setStates($this->getStateRepository()->fetchByJob($this->getId()));
+            } catch (BlankResult $e) {
+                return [];
+            }
+        }
+        return $this->states;
+    }
+    public function addState(State\Job $state): Job
+    {
+        $this->states []= $state;
+        return $this;
+    }
+    public function setStates(array $states): Job
+    {
+        foreach ($states as $state) {
+            $this->addState($state);
+        }
+        return $this;
+    }
+
+    public function isExecuted(): bool
+    {
+        return $this->lastState()->getStatus() === State\Job::Executed;
+    }
+    public function lastState(): State\Job
+    {
+        if (count($this->getStates()) === 0) {
+            throw new Stateless($this->getId());
+        }
+        return $this->getStates()[array_key_last($this->getStates())];
+    }
+
    public function toArray(): array
    {
        return [
            'id' => $this->getId(),
-            'message' => $this->getMessage()->toArray(),
-            'date_time' => $this->getDateTime()->format('Y-m-d H:i:s'),
-            'executed' => $this->isExecuted()
+            'command' => $this->getCommand(),
+            'arguments' => $this->getArguments(),
+            'states' => $this->getStates()
        ];
    }
-}
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/Mailbox.php
+++ b/api/src/Model/Mailbox.php
@ -104,6 +104,9 @@ class Mailbox implements Model
    public function lastPosition(): int
    {
        $state = $this->lastState()->getUIDs();
+        if (count($state) === 0) {
+            return 0;
+        }
        return array_key_last($state);
    }

@ -119,4 +122,8 @@ class Mailbox implements Model
            ]
        ];
    }
-}
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/Message.php
+++ b/api/src/Model/Message.php
@ -99,18 +99,23 @@ class Message implements Model
    {
        if (!isset($this->states)) {
            try {
-                $this->setStates($this->getFactory()->find(\ProVM\Emails\Model\State\Message::class)->fetchByMessage($this->getId()));
+                $this->setStates($this->getFactory()->find(State\Message::class)->fetchByMessage($this->getId()));
            } catch (BlankResult $e) {
                return [];
            }
        }
        return $this->states;
    }
-    public function getState(string $name): \ProVM\Emails\Model\State\Message
+    public function getState(string $name): State\Message
    {
-        return $this->getStates()[$name];
+        try {
+            return $this->getStates()[$name];
+        } catch (\Exception $e) {
+            $this->newState($name);
+            return $this->getStates()[$name];
+        }
    }
-    public function addState(\ProVM\Emails\Model\State\Message $state): Message
+    public function addState(State\Message $state): Message
    {
        $this->states[$state->getName()] = $state;
        return $this;
@ -124,9 +129,10 @@ class Message implements Model
    }
    protected function newState(string $name): Message
    {
-        $this->addState((new \ProVM\Emails\Model\State\Message())
+        $this->addState((new State\Message())
            ->setName($name)
            ->setMessage($this)
+            ->setValue(false)
        );
        return $this;
    }
@ -143,31 +149,31 @@ class Message implements Model
    {
        return $this->getState('downloaded_attachments')->getValue() ?? false;
    }
+    public function hasScheduledDownloads(): bool
+    {
+        return $this->getState('scheduled_downloads')->getValue() ?? false;
+    }

    public function doesHaveAttachments(): Message
    {
-        if (!isset($this->getStates()['has_attachments'])) {
-            $this->newState('has_attachments');
-        }
        $this->getState('has_attachments')->setValue(true);
        return $this;
    }
    public function doesHaveValidAttachments(): Message
    {
-        if (!isset($this->getStates()['valid_attachments'])) {
-            $this->newState('valid_attachments');
-        }
        $this->getState('valid_attachments')->setValue(true);
        return $this;
    }
    public function doesHaveDownloadedAttachments(): Message
    {
-        if (!isset($this->getStates()['downloaded_attachments'])) {
-            $this->newState('downloaded_attachments');
-        }
        $this->getState('downloaded_attachments')->setValue(true);
        return $this;
    }
+    public function doesHaveScheduledDownloads(): Message
+    {
+        $this->getState('scheduled_downloads')->setValue(true);
+        return $this;
+    }

    protected array $attachments;
    public function getAttachments(): array
@ -205,11 +211,16 @@ class Message implements Model
            'states' => [
                'has_attachments' => $this->hasAttachments(),
                'valid_attachments' => $this->hasValidAttachments(),
-                'downloaded_attachments' => $this->hasDownloadedAttachments()
+                'downloaded_attachments' => $this->hasDownloadedAttachments(),
+                'scheduled_downloads' => $this->hasScheduledDownloads()
            ],
            'attachments' => $this->hasValidAttachments() ? array_map(function(Attachment $attachment) {
                return $attachment->toArray();
            }, $this->getAttachments()) : []
        ];
    }
-}
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/State/Attachment.php
+++ b/api/src/Model/State/Attachment.php
@ -47,4 +47,18 @@ class Attachment implements Model
        $this->value = $value;
        return $this;
    }
-}
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->getId(),
+            'attachment_id' => $this->getAttachment()->getId(),
+            'name' => $this->getName(),
+            'value' => $this->getValue()
+        ];
+    }
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/State/Job.php
+++ b/api/src/Model/State/Job.php
@ -0,0 +1,65 @@
+<?php
+namespace ProVM\Emails\Model\State;
+
+use ProVM\Common\Define\Model;
+use ProVM\Emails;
+
+class Job implements Model
+{
+    const Executed = 0;
+    const Pending = 1;
+    const Failure = -1;
+
+    protected int $id;
+    protected Emails\Model\Job $job;
+    protected \DateTimeInterface $dateTime;
+    protected int $status;
+
+    public function getId(): int
+    {
+        return $this->id;
+    }
+    public function getJob(): Emails\Model\Job
+    {
+        return $this->job;
+    }
+    public function getDateTime(): \DateTimeInterface
+    {
+        return $this->dateTime;
+    }
+    public function getStatus(): int
+    {
+        return $this->status;
+    }
+
+    public function setId(int $id): Job
+    {
+        $this->id = $id;
+        return $this;
+    }
+    public function setJob(Emails\Model\Job $job): Job
+    {
+        $this->job = $job;
+        return $this;
+    }
+    public function setDateTime(\DateTimeInterface $dateTime): Job
+    {
+        $this->dateTime = $dateTime;
+        return $this;
+    }
+    public function setStatus(int $status): Job
+    {
+        $this->status = $status;
+        return $this;
+    }
+
+    public function jsonSerialize(): mixed
+    {
+        return [
+            'id' => $this->getId(),
+            'job_id' => $this->getJob()->getId(),
+            'date' => $this->getDateTime(),
+            'status' => $this->getStatus()
+        ];
+    }
+}
--- a/api/src/Model/State/Mailbox.php
+++ b/api/src/Model/State/Mailbox.php
@ -30,7 +30,7 @@ class Mailbox implements Model
    }
    public function getUIDs(): array
    {
-        return $this->uids;
+        return $this->uids ?? [];
    }

    public function setId(int $id): Mailbox
@ -65,4 +65,19 @@ class Mailbox implements Model
        }
        return $this;
    }
-}
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->getId(),
+            'mailbox_id' => $this->getMailbox()->getId(),
+            'date_time' => $this->getDateTime()->format('Y-m-d H:i:s'),
+            'count' => $this->getCount(),
+            'uids' => $this->getUIDs()
+        ];
+    }
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Model/State/Message.php
+++ b/api/src/Model/State/Message.php
@ -47,4 +47,18 @@ class Message implements Model
        $this->value = $value;
        return $this;
    }
-}
+
+    public function toArray(): array
+    {
+        return [
+            'id' => $this->getId(),
+            'message_id' => $this->getMessage()->getId(),
+            'name' => $this->getName(),
+            'value' => $this->getValue()
+        ];
+    }
+    public function jsonSerialize(): mixed
+    {
+        return $this->toArray();
+    }
+}
--- a/api/src/Repository/Attachment.php
+++ b/api/src/Repository/Attachment.php
@ -28,6 +28,20 @@ class Attachment extends Repository
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `message_id` INT UNSIGNED NOT NULL,
+    `filename` VARCHAR(255) NOT NULL,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_messages_{$this->getTable()}` (`message_id`)
+        REFERENCES `messages` (`id`) ON DELETE CASCADE ON UPDATE CASCADE 
+)";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForInsert(): array
    {
        return [
@ -115,4 +129,11 @@ class Attachment extends Repository
        $query = "SELECT * FROM {$this->getTable()} WHERE message_id = ?";
        return $this->fetchMany($query, [$message_id]);
    }
-}
+    public function fetchDownloaded(): array
+    {
+        $query = "SELECT a.* 
+FROM `{$this->getTable()}` a JOIN `attachments_states` `as` ON `as`.attachment_id = a.id 
+WHERE `as`.name = 'downloaded' AND `as`.value = 1";
+        return $this->fetchMany($query);
+    }
+}
--- a/api/src/Repository/Job.php
+++ b/api/src/Repository/Job.php
@ -2,33 +2,45 @@
 namespace ProVM\Emails\Repository;

 use PDO;
-use ProVM\Common\Factory\Model;
+use ProVM\Common\Factory;
 use Psr\Log\LoggerInterface;
-use Safe\DateTimeImmutable;
 use ProVM\Common\Define\Model as ModelInterface;
 use ProVM\Common\Implement\Repository;
 use ProVM\Emails\Model\Job as BaseModel;
+use ProVM\Emails;

 class Job extends Repository
 {
-    public function __construct(PDO $connection, LoggerInterface $logger, Model $factory)
+    public function __construct(PDO $connection, LoggerInterface $logger, Factory\Model $factory)
    {
        parent::__construct($connection, $logger);
        $this->setFactory($factory)
-            ->setTable('attachments_jobs');
+            ->setTable('jobs');
    }

-    protected \ProVM\Common\Factory\Model $factory;
-    public function getFactory(): \ProVM\Common\Factory\Model
+    protected Factory\Model $factory;
+    public function getFactory(): Factory\Model
    {
        return $this->factory;
    }
-    public function setFactory(\ProVM\Common\Factory\Model $factory): Job
+    public function setFactory(Factory\Model $factory): Job
    {
        $this->factory = $factory;
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `command` VARCHAR(100) NOT NULL,
+    `arguments` TEXT NOT NULL,
+    PRIMARY KEY (`id`) 
+)";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForUpdate(): array
    {
        return $this->fieldsForInsert();
@ -40,69 +52,68 @@ class Job extends Repository
    protected function fieldsForInsert(): array
    {
        return [
-            'message_id',
-            'date_time',
-            'executed'
+            'command',
+            'arguments',
        ];
    }
    protected function valuesForInsert(ModelInterface $model): array
    {
        return [
-            $model->getMessage()->getId(),
-            $model->getDateTime()->format('Y-m-d H:i:s'),
-            $model->isExecuted() ? 1 : 0
+            $model->getCommand(),
+            $model->getArguments(),
        ];
    }
    protected function defaultFind(ModelInterface $model): ModelInterface
    {
-        return $this->fetchByMessageAndDate($model->getMessage()->getId(), $model->getDateTime()->format('Y-m-d H:i:s'));
+        return $this->fetchByCommandAndArguments($model->getCommand(), $model->getArguments());
    }
    protected function fieldsForCreate(): array
    {
        return [
-            'message_id',
-            'date_time',
-            'executed'
+            'command',
+            'arguments',
        ];
    }
    protected function valuesForCreate(array $data): array
    {
        return [
-            $data['message_id'],
-            $data['date_time'],
-            $data['executed'] ?? 0
+            $data['command'],
+            $data['arguments'],
        ];
    }
    protected function defaultSearch(array $data): ModelInterface
    {
-        return $this->fetchByMessageAndDate($data['message_id'], $data['date_time']);
+        return $this->fetchByCommandAndArguments($data['command'], $data['arguments']);
    }

    public function load(array $row): ModelInterface
    {
-        $model = (new BaseModel())
+        return (new BaseModel())
            ->setId($row['id'])
-            ->setMessage($this->getFactory()->find(\ProVM\Emails\Model\Message::class)->fetchById($row['message_id']))
-            ->setDateTime(new DateTimeImmutable($row['date_time']));
-        if ($row['executed'] ?? 0 === 1) {
-            $model->wasExecuted();
-        }
-        return $model;
+            ->setCommand($row['command'])
+            ->setArguments($row['arguments'])
+            ->setStateRepository($this->getFactory()->find(Emails\Model\State\Job::class));
    }

    public function fetchAllPending(): array
    {
-        $query = "SELECT * FROM {$this->getTable()} WHERE `executed` = 0";
-        return $this->fetchMany($query);
+        $query = "SELECT a.*
+FROM `{$this->getTable()}` a
+    JOIN (SELECT s1.* FROM `jobs_states` s1 JOIN (SELECT MAX(id) AS id, job_id FROM `jobs_states` GROUP BY job_id) s2 ON s2.id = s1.id) b ON b.`job_id` = a.`id` 
+WHERE b.`status` = ?";
+        return $this->fetchMany($query, [Emails\Model\State\Job::Pending]);
    }
-    public function fetchByMessageAndDate(int $message_id, string $date_time): \ProVM\Emails\Model\Job
+    public function fetchByCommandAndArguments(string $command, string $arguments): Emails\Model\Job
    {
-        $query = "SELECT * FROM {$this->getTable()} WHERE `message_id` = ? AND `date_time` = ?";
-        return $this->fetchOne($query, [$message_id, $date_time]);
+        $query = "SELECT * FROM {$this->getTable()} WHERE `command` = ? AND `arguments` = ?";
+        return $this->fetchOne($query, [$command, $arguments]);
    }
-    public function fetchPendingByMessage(int $message_id): \ProVM\Emails\Model\Job
+    public function fetchAllPendingByCommand(string $command): array
    {
-        $query = "SELECT * FROM {$this->getTable()} WHERE `message_id` = ? AND `executed` = 0";
-        return $this->fetchOne($query, [$message_id]);
+        $query = "SELECT a.* 
+FROM `{$this->getTable()}` a
+    JOIN (SELECT s1.* FROM `jobs_states` s1 JOIN (SELECT MAX(id) AS id, job_id FROM `jobs_states` GROUP BY job_id) s2 ON s2.id = s1.id) b ON b.`job_id` = a.`id`
+WHERE a.`command` = ? AND b.`status` = ?";
+        return $this->fetchMany($query, [$command, Emails\Model\State\Job::Pending]);
    }
-}
+}
--- a/api/src/Repository/Mailbox.php
+++ b/api/src/Repository/Mailbox.php
@ -28,6 +28,18 @@ class Mailbox extends Repository
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `name` VARCHAR(100) NOT NULL,
+    `validity` INT UNSIGNED NOT NULL,
+    PRIMARY KEY (`id`) 
+)";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForUpdate(): array
    {
        return $this->fieldsForInsert();
@ -86,4 +98,4 @@ class Mailbox extends Repository
        $query = "SELECT * FROM `{$this->getTable()}` WHERE `name` = ?";
        return $this->fetchOne($query, [$name]);
    }
-}
+}
--- a/api/src/Repository/Message.php
+++ b/api/src/Repository/Message.php
@ -3,34 +3,50 @@ namespace ProVM\Emails\Repository;

 use DateTimeInterface;
 use PDO;
-use PDOException;
-use Exception;
-use ProVM\Common\Define\Model;
 use Psr\Log\LoggerInterface;
-use ProVM\Common\Implement\Repository;
 use Safe\DateTimeImmutable;
-use Safe\Exceptions\ErrorfuncException;
+use ProVM\Common\Define\Model;
+use ProVM\Common\Implement\Repository;
+use ProVM\Common\Factory;

 class Message extends Repository
 {
-    public function __construct(PDO $connection, LoggerInterface $logger, \ProVM\Common\Factory\Model $factory)
+    public function __construct(PDO $connection, LoggerInterface $logger, Factory\Model $factory)
    {
        parent::__construct($connection, $logger);
        $this->setTable('messages')
            ->setFactory($factory);
    }

-    protected \ProVM\Common\Factory\Model $factory;
-    public function getFactory(): \ProVM\Common\Factory\Model
+    protected Factory\Model $factory;
+    public function getFactory(): Factory\Model
    {
        return $this->factory;
    }
-    public function setFactory(\ProVM\Common\Factory\Model $factory): Message
+    public function setFactory(Factory\Model $factory): Message
    {
        $this->factory = $factory;
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `uid` VARCHAR(255) NOT NULL,
+    `mailbox_id` INT UNSIGNED NOT NULL,
+    `position` INT UNSIGNED NOT NULL,
+    `subject` VARCHAR(255) NOT NULL,
+    `from` VARCHAR(255) NOT NULL,
+    `date_time` DATETIME NOT NULL,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_mailboxes_{$this->getTable()}` (`mailbox_id`)
+        REFERENCES `mailboxes` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+)";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForUpdate(): array
    {
        return $this->fieldsForInsert();
@ -111,23 +127,26 @@ class Message extends Repository
        $valid_states = [
            'has_attachments',
            'valid_attachments',
-            'downloaded_attachments'
+            'downloaded_attachments',
+            'scheduled_downloads'
        ];
+        $stateRepository = $this->getFactory()->find(\ProVM\Emails\Model\State\Message::class);
        foreach ($valid_states as $state_name) {
            try {
                $model->getState($state_name);
            } catch (\Exception $e) {
+                $this->getLogger()->warning($e);
                $data = [
                    'message_id' => $model->getId(),
                    'name' => $state_name
                ];
-                $state = $this->getFactory()->find(\ProVM\Emails\Model\State\Message::class)->create($data);
+                $state = $stateRepository->create($data);
                $model->addState($state);
            }
        }
        foreach ($model->getStates() as $state) {
-            $state->setMessage($model);
-            $this->getFactory()->find(\ProVM\Emails\Model\State\Message::class)->save($state);
+            //$state->setMessage($model);
+            $stateRepository->save($state);
        }
    }

@ -160,4 +179,9 @@ class Message extends Repository
                    WHERE `mailbox_id` = ? `subject` = ? AND `from` = ? AND `date_time` = ?";
        return $this->fetchOne($query, [$mailbox_id, $subject, $from, $dateTime->format('Y-m-d H:i:s')]);
    }
-}
+    public function fetchAllBySubjectAndDate(string $subject, DateTimeInterface $dateTime): array
+    {
+        $query = "SELECT * FROM `{$this->getTable()}` WHERE `subject` = ? AND `date_time` BETWEEN ? AND ?";
+        return $this->fetchMany($query, [$subject, $dateTime->format('Y-m-d 00:00:00'), $dateTime->format('Y-m-d 23:59:59')]);
+    }
+}
--- a/api/src/Repository/State/Attachment.php
+++ b/api/src/Repository/State/Attachment.php
@ -26,6 +26,22 @@ class Attachment extends Repository
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `attachment_id` INT UNSIGNED NOT NULL,
+    `name` VARCHAR(100) NOT NULL,
+    `value` INT(1) NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_attachments_{$this->getTable()}` (`attachment_id`)
+        REFERENCES `attachments` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+)
+";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForInsert(): array
    {
        return [
@ -90,4 +106,4 @@ class Attachment extends Repository
        $query = "SELECT * FROM `{$this->getTable()}` WHERE `attachment_id` = ? AND `name` = ?";
        return $this->fetchOne($query, [$attachment_id, $name]);
    }
-}
+}
--- a/api/src/Repository/State/Job.php
+++ b/api/src/Repository/State/Job.php
@ -0,0 +1,113 @@
+<?php
+namespace ProVM\Emails\Repository\State;
+
+use PDO;
+use Psr\Log\LoggerInterface;
+use ProVM\Common\Define;
+use ProVM\Common\Factory;
+use ProVM\Common\Implement\Repository;
+use ProVM\Emails;
+
+class Job extends Repository
+{
+    public function __construct(PDO $connection, LoggerInterface $logger, Factory\Model $factory)
+    {
+        parent::__construct($connection, $logger);
+        $this->setTable('jobs_states')
+            ->setFactory($factory);
+    }
+
+    protected Factory\Model $factory;
+    public function getFactory(): Factory\Model
+    {
+        return $this->factory;
+    }
+    public function setFactory(Factory\Model $factory): Job
+    {
+        $this->factory = $factory;
+        return $this;
+    }
+
+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `job_id` INT UNSIGNED NOT NULL,
+    `date_time` DATETIME NOT NULL,
+    `status` INT NOT NULL DEFAULT 1,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_jobs_{$this->getTable()}` (`job_id`)
+        REFERENCES `jobs` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+)";
+        $this->getConnection()->query($query);
+    }
+
+    public function load(array $row): Define\Model
+    {
+        return (new Emails\Model\State\Job())
+            ->setId($row['id'])
+            ->setJob($this->getFactory()->find(Emails\Model\Job::class)->fetchById($row['job_id']))
+            ->setDateTime(new \DateTimeImmutable($row['date_time']))
+            ->setStatus($row['status']);
+    }
+
+    public function fetchByJob(int $job_id): array
+    {
+        $query = "SELECT * FROM `{$this->getTable()}` WHERE `job_id` = ?";
+        return $this->fetchMany($query, [$job_id]);
+    }
+    public function fetchByJobAndStatus(int $job_id, int $status): Emails\Model\State\Job
+    {
+        $query = "SELECT * FROM `{$this->getTable()}` WHERE `job_id` = ? AND `status` = ?";
+        return $this->fetchOne($query, [$job_id, $status]);
+    }
+
+    protected function fieldsForInsert(): array
+    {
+        return [
+            'job_id',
+            'date_time',
+            'status'
+        ];
+    }
+    protected function valuesForInsert(Define\Model $model): array
+    {
+        return [
+            $model->getJob()->getId(),
+            $model->getDateTime()->format('Y-m-d H:i:s'),
+            $model->getStatus()
+        ];
+    }
+
+    protected function fieldsForUpdate(): array
+    {
+        return $this->fieldsForInsert();
+    }
+    protected function fieldsForCreate(): array
+    {
+        return $this->fieldsForInsert();
+    }
+
+    protected function valuesForUpdate(Define\Model $model): array
+    {
+        return $this->valuesForInsert($model);
+    }
+    protected function valuesForCreate(array $data): array
+    {
+        return [
+            $data['job_id'],
+            $data['date_time'],
+            $data['status']
+        ];
+    }
+
+    protected function defaultFind(Define\Model $model): Define\Model
+    {
+        return $this->fetchByJobAndStatus($model->getJob()->getId(), $model->getStatus());
+    }
+    protected function defaultSearch(array $data): Define\Model
+    {
+        return $this->fetchByJobAndStatus($data['job_id'], $data['status']);
+    }
+}
--- a/api/src/Repository/State/Mailbox.php
+++ b/api/src/Repository/State/Mailbox.php
@ -28,6 +28,23 @@ class Mailbox extends Repository
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `mailbox_id` INT UNSIGNED NOT NULL,
+    `date_time` DATETIME NOT NULL,
+    `count` INT UNSIGNED NOT NULL,
+    `uids` TEXT NOT NULL,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_mailboxes_{$this->getTable()}` (`mailbox_id`)
+        REFERENCES `mailboxes` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+)
+";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForUpdate(): array
    {
        return $this->fieldsForInsert();
@ -99,4 +116,4 @@ class Mailbox extends Repository
        $query = "SELECT * FROM `{$this->getTable()}` WHERE `mailbox_id` = ? AND `date_time` = ?";
        return $this->fetchOne($query, [$mailbox_id, $date_time]);
    }
-}
+}
--- a/api/src/Repository/State/Message.php
+++ b/api/src/Repository/State/Message.php
@ -26,6 +26,22 @@ class Message extends Repository
        return $this;
    }

+    public function install(): void
+    {
+        $query = "
+CREATE TABLE {$this->getTable()} (
+    `id` INT UNSIGNED NOT NULL AUTO_INCREMENT,
+    `message_id` INT UNSIGNED NOT NULL,
+    `name` VARCHAR(100) NOT NULL,
+    `value` INT(1) NOT NULL DEFAULT 0,
+    PRIMARY KEY (`id`),
+    FOREIGN KEY `fk_messages_{$this->getTable()}` (`message_id`)
+        REFERENCES `messages` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
+)
+";
+        $this->getConnection()->query($query);
+    }
+
    protected function fieldsForUpdate(): array
    {
        return $this->fieldsForInsert();
@ -90,4 +106,4 @@ class Message extends Repository
        $query = "SELECT * FROM `{$this->getTable()}` WHERE `message_id` = ? AND `name` = ?";
        return $this->fetchOne($query, [$message_id, $name]);
    }
-}
+}
--- a/cli/.env.sample
+++ b/cli/.env.sample
@ -0,0 +1 @@
+API_URI=http://proxy:8080
--- a/cli/Dockerfile
+++ b/cli/Dockerfile
@ -3,7 +3,7 @@ FROM php:8-cli
 ENV PATH ${PATH}:/app/bin

 RUN apt-get update  \
-    && apt-get install -y cron git libzip-dev unzip \
+    && apt-get install -y cron git libzip-dev unzip qpdf \
    && rm -r /var/lib/apt/lists/* \
    && docker-php-ext-install zip

--- a/cli/common/Command/DecryptPdf.php
+++ b/cli/common/Command/DecryptPdf.php
@ -1,67 +0,0 @@
-<?php
-namespace ProVM\Common\Command;
-
-use ProVM\Common\Service\Communicator;
-use Symfony\Component\Console\Attribute\AsCommand;
-use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Console\Style\SymfonyStyle;
-
-#[AsCommand(
-    name: 'attachments:decrypt',
-    description: 'Decrypt attachments pending',
-    hidden: false
-)]
-class DecryptPdf extends Command
-{
-    public function __construct(Communicator $communicator, string $name = null)
-    {
-        $this->setCommunicator($communicator);
-        parent::__construct($name);
-    }
-
-    protected Communicator $communicator;
-    public function getCommunicator(): Communicator
-    {
-        return $this->communicator;
-    }
-    public function setCommunicator(Communicator $communicator): DecryptPdf
-    {
-        $this->communicator = $communicator;
-        return $this;
-    }
-
-    protected function getAttachments(): array
-    {
-        $response = $this->getCommunicator()->get('/attachments/pending');
-        return \Safe\json_decode($response->getBody()->getContents())->attachments;
-    }
-    protected function decrypt(string $attachment): bool
-    {
-        $response = $this->getCommunicator()->put('/attachments/decrypt', ['attachments' => [$attachment]]);
-        return \Safe\json_decode($response->getBody()->getContents())->status;
-    }
-
-    public function execute(InputInterface $input, OutputInterface $output)
-    {
-        $io = new SymfonyStyle($input, $output);
-        $io->title('Decrypt Attachments');
-
-        $io->section('Grabbing Attachments');
-        $attachments = $this->getAttachments();
-        $io->text('Found ' . count($attachments) . ' attachments.');
-        $io->section('Decrypting Attachments');
-        foreach ($attachments as $attachment) {
-            $status = $this->decrypt($attachment);
-            if ($status) {
-                $io->success("{$attachment} decrypted correctly.");
-            } else {
-                $io->error("Problem decrypting {$attachment}.");
-            }
-        }
-        $io->success('Done.');
-
-        return Command::SUCCESS;
-    }
-}
--- a/cli/common/Command/GrabAttachments.php
+++ b/cli/common/Command/GrabAttachments.php
@ -1,65 +0,0 @@
-<?php
-namespace ProVM\Common\Command;
-
-use ProVM\Common\Service\Communicator;
-use Symfony\Component\Console\Attribute\AsCommand;
-use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Console\Style\SymfonyStyle;
-
-#[AsCommand(
-    name: 'attachments:grab',
-    description: 'Grab attachments from pending messages',
-    aliases: ['attachments:get'],
-    hidden: false
-)]
-class GrabAttachments extends Command
-{
-    public function __construct(Communicator $communicator, string $name = null)
-    {
-        $this->setCommunicator($communicator);
-        parent::__construct($name);
-    }
-
-    protected Communicator $service;
-    public function getCommunicator(): Communicator
-    {
-        return $this->service;
-    }
-    public function setCommunicator(Communicator $service): GrabAttachments
-    {
-        $this->service = $service;
-        return $this;
-    }
-
-    protected function getMessages(): array
-    {
-        $response = $this->getCommunicator()->get('/messages/pending');
-        return \Safe\json_decode($response->getBody()->getContents())->messages;
-    }
-    protected function grabAttachments(int $message_uid): int
-    {
-        $response = $this->getCommunicator()->put('/attachments/grab', ['messages' => [$message_uid]]);
-        return \Safe\json_decode($response->getBody()->getContents())->attachment_count;
-    }
-
-    public function execute(InputInterface $input, OutputInterface $output): int
-    {
-        $io = new SymfonyStyle($input, $output);
-        $io->title('Grab Attachments');
-
-        $io->section('Grabbing Messages');
-        $messages = $this->getMessages();
-        $io->text('Found ' . count($messages) . ' messages.');
-        $io->section('Grabbing Attachments');
-        foreach ($messages as $job) {
-            $message = $job->message;
-            $attachments = $this->grabAttachments($message->uid);
-            $io->text("Found {$attachments} attachments for message UID:{$message->uid}.");
-        }
-        $io->success('Done.');
-
-        return Command::SUCCESS;
-    }
-}
--- a/cli/common/Command/Jobs/Check.php
+++ b/cli/common/Command/Jobs/Check.php
@ -0,0 +1,52 @@
+<?php
+namespace ProVM\Command\Jobs;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use ProVM\Service\Jobs;
+
+#[AsCommand(
+    name: 'jobs:check',
+    description: 'Check for pending jobs',
+    hidden: false
+)]
+class Check extends Command
+{
+    public function __construct(protected Jobs $service, string $name = null)
+    {
+        parent::__construct($name);
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output)
+    {
+        $section1 = $output->section();
+        $section2 = $output->section();
+        $io1 = new SymfonyStyle($input, $section1);
+        $io2 = new SymfonyStyle($input, $section2);
+        $io1->title('Checking Pending Jobs');
+        $pending_jobs = $this->service->getPending();
+        $notice = 'Found ' . count($pending_jobs) . ' jobs';
+        $io1->text($notice);
+        if (count($pending_jobs) > 0) {
+            $io1->section('Running Jobs');
+            $io1->progressStart(count($pending_jobs));
+            foreach ($pending_jobs as $job) {
+                $section2->clear();
+                $io2->text("Running {$job->command}");
+                if ($this->service->run($job)) {
+                    $io2->success('Success');
+                } else {
+                    $io2->error('Failure');
+                }
+                $io1->progressAdvance();
+            }
+        }
+        $section2->clear();
+        $io2->success('Done');
+
+        return Command::SUCCESS;
+    }
+}
--- a/cli/common/Command/Jobs/Execute.php
+++ b/cli/common/Command/Jobs/Execute.php
@ -0,0 +1,41 @@
+<?php
+namespace ProVM\Command\Jobs;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use ProVM\Service\Jobs;
+
+#[AsCommand(
+    name: 'jobs:execute',
+    description: 'Execute job by job_id',
+    hidden: false
+)]
+class Execute extends Command
+{
+    public function __construct(protected Jobs $service, string $name = null)
+    {
+        parent::__construct($name);
+    }
+
+    protected function configure()
+    {
+        $this->addArgument('job_id', InputArgument::REQUIRED, 'Job ID to be executed');
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output)
+    {
+        $io = new SymfonyStyle($input, $output);
+        $job_id = $input->getArgument('job_id');
+        $job = $this->service->get($job_id);
+        if ($this->service->run($job)) {
+            $io->success('Success');
+        } else {
+            $io->error('Failed');
+        }
+        return Command::SUCCESS;
+    }
+}
--- a/cli/common/Command/Mailboxes/Check.php
+++ b/cli/common/Command/Mailboxes/Check.php
@ -0,0 +1,53 @@
+<?php
+namespace ProVM\Command\Mailboxes;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use ProVM\Service\Mailboxes;
+
+#[AsCommand(
+    name: 'mailboxes:check',
+    description: 'Check registered mailboxes for new emails',
+    hidden: false
+)]
+class Check extends Command
+{
+    public function __construct(protected Mailboxes $service, string $name = null)
+    {
+        parent::__construct($name);
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $section1 = $output->section();
+        $section2 = $output->section();
+        $io1 = new SymfonyStyle($input, $section1);
+        $io2 = new SymfonyStyle($input, $section2);
+        $io1->title('Checking for New Messages');
+        $mailboxes = $this->service->getAll();
+        $notice = 'Found ' . count($mailboxes) . ' mailboxes';
+        $io1->text($notice);
+        if (count($mailboxes) > 0) {
+            $io1->section('Checking for new messages');
+            $io1->progressStart(count($mailboxes));
+            foreach ($mailboxes as $mailbox) {
+                $section2->clear();
+                $io2->text("Checking {$mailbox->name}");
+                if ($this->service->check($mailbox)) {
+                    $io2->success("Found new emails in {$mailbox->name}");
+                } else {
+                    $io2->info("No new emails in {$mailbox->name}");
+                }
+                $io1->progressAdvance();
+            }
+            $io1->progressFinish();
+        }
+        $section2->clear();
+        $io2->success('Done');
+
+        return Command::SUCCESS;
+    }
+}
--- a/cli/common/Command/Messages.php
+++ b/cli/common/Command/Messages.php
@ -1,66 +0,0 @@
-<?php
-namespace ProVM\Common\Command;
-
-use ProVM\Common\Service\Communicator;
-use Symfony\Component\Console\Attribute\AsCommand;
-use Symfony\Component\Console\Command\Command;
-use Symfony\Component\Console\Input\InputInterface;
-use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Console\Style\SymfonyStyle;
-
-#[AsCommand(
-    name: 'messages:grab',
-    description: 'Run grab messages job for registered mailboxes',
-    aliases: ['messages'],
-    hidden: false
-)]
-class Messages extends Command
-{
-    public function __construct(Communicator $communicator, string $name = null)
-    {
-        $this->setCommunicator($communicator);
-        parent::__construct($name);
-    }
-
-    protected Communicator $communicator;
-    public function getCommunicator(): Communicator
-    {
-        return $this->communicator;
-    }
-    public function setCommunicator(Communicator $communicator): Messages
-    {
-        $this->communicator = $communicator;
-        return $this;
-    }
-
-    protected function getMailboxes(): array
-    {
-        $response = $this->getCommunicator()->get('/mailboxes/registered');
-        return \Safe\json_decode($response->getBody()->getContents())->mailboxes;
-    }
-    protected function grabMessages(string $mailbox): int
-    {
-        $response = $this->getCommunicator()->put('/messages/grab', ['mailboxes' => [$mailbox]]);
-        $body = \Safe\json_decode($response->getBody()->getContents());
-        return $body->message_count;
-    }
-
-    public function execute(InputInterface $input, OutputInterface $output)
-    {
-        $io = new SymfonyStyle($input, $output);
-
-        $io->title('Messages');
-        $io->section('Grabbing Registered Mailboxes');
-
-        $mailboxes = $this->getMailboxes();
-        $io->text('Found ' . count($mailboxes) . ' registered mailboxes.');
-        $io->section('Grabbing Messages');
-        foreach ($mailboxes as $mailbox) {
-            $message_count = $this->grabMessages($mailbox->name);
-            $io->text("Found {$message_count} messages in {$mailbox->name}.");
-        }
-        $io->success('Done.');
-
-        return Command::SUCCESS;
-    }
-}
--- a/cli/common/Command/Messages/Grab.php
+++ b/cli/common/Command/Messages/Grab.php
@ -0,0 +1,41 @@
+<?php
+namespace ProVM\Command\Messages;
+
+use Symfony\Component\Console\Attribute\AsCommand;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\Console\Style\SymfonyStyle;
+use ProVM\Service\Mailboxes;
+
+#[AsCommand(
+    name: 'messages:grab',
+    description: 'Run grab messages job for mailbox',
+    hidden: false
+)]
+class Grab extends Command
+{
+    public function __construct(protected Mailboxes $service, string $name = null)
+    {
+        parent::__construct($name);
+    }
+    protected function configure()
+    {
+        $this->addArgument('mailbox_id', InputArgument::REQUIRED, 'Mailbox ID to grab emails');
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output)
+    {
+        $io = new SymfonyStyle($input, $output);
+
+        $mailbox_id = $input->getArgument('mailbox_id');
+        $io->title("Grabbing Messages for Mailbox ID {$mailbox_id}");
+        $io->section('Grabbing Messages');
+        $count = $this->service->grabMessages($mailbox_id);
+        $io->info("Found {$count} messages");
+        $io->success('Done.');
+
+        return Command::SUCCESS;
+    }
+}
--- a/cli/common/Exception/Response/EmptyResponse.php
+++ b/cli/common/Exception/Response/EmptyResponse.php
@ -0,0 +1,16 @@
+<?php
+namespace ProVM\Exception\Response;
+
+use Exception;
+use Throwable;
+
+class EmptyResponse extends Exception
+{
+    public function __construct(string $uri, string $method = 'get', ?Throwable $previous = null)
+    {
+        $method = strtoupper($method);
+        $message = "Received empty response for request {$method} '{$uri}'";
+        $code = 410;
+        parent::__construct($message, $code, $previous);
+    }
+}
--- a/cli/common/Exception/Response/MissingResponse.php
+++ b/cli/common/Exception/Response/MissingResponse.php
@ -0,0 +1,15 @@
+<?php
+namespace ProVM\Exception\Response;
+
+use Exception;
+use Throwable;
+
+class MissingResponse extends Exception
+{
+    public function __construct(string $expected, ?Throwable $previous = null)
+    {
+        $message = "Response is missing parameter(s) {$expected}";
+        $code = 406;
+        parent::__construct($message, $code, $previous);
+    }
+}
--- a/cli/common/Service/Attachments.php
+++ b/cli/common/Service/Attachments.php
@ -0,0 +1,114 @@
+<?php
+namespace ProVM\Service;
+
+use ProVM\Exception\Response\EmptyResponse;
+use ProVM\Exception\Response\MissingResponse;
+use Psr\Log\LoggerInterface;
+use function Safe\json_decode;
+
+class Attachments
+{
+    public function __construct(protected Communicator $communicator, protected LoggerInterface $logger, protected array $passwords, protected string $base_command = 'qpdf') {}
+
+    protected array $attachments;
+
+    public function findAll(): \Generator
+    {
+        $this->logger->info('Finding all downloaded attachment files');
+        $folder = '/attachments';
+        $files = new \FilesystemIterator($folder);
+        foreach ($files as $file) {
+            if ($file->isDir()) {
+                continue;
+            }
+            yield $file->getRealPath();
+        }
+    }
+    public function getAll(): array
+    {
+        if (!isset($this->attachments)) {
+            $this->logger->info('Grabbing all attachments');
+            $response = $this->communicator->get('/attachments');
+            $body = $response->getBody()->getContents();
+            if (trim($body) === '') {
+                $this->attachments = [];
+                return $this->attachments;
+            }
+            $this->attachments = json_decode($body)->attachments;
+        }
+        return $this->attachments;
+    }
+    public function get(int $attachment_id): object
+    {
+        $this->logger->info("Getting attachment {$attachment_id}");
+        $uri = "/attachment/{$attachment_id}";
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            throw new EmptyResponse($uri);
+        }
+        $json = json_decode($body);
+        if (!isset($json->attachment)) {
+            throw new MissingResponse('attachment');
+        }
+        return $json->attachment;
+    }
+    public function find(string $filename): int
+    {
+        $this->logger->info("Finding attachment {$filename}");
+        foreach ($this->getAll() as $attachment) {
+            if ($attachment->fullfilename === $filename) {
+                return $attachment->id;
+            }
+        }
+        throw new \Exception("{$filename} is not in the database");
+    }
+    public function isEncrypted(string $filename): bool
+    {
+        if (!file_exists($filename)) {
+            throw new \InvalidArgumentException("File not found {$filename}");
+        }
+        $escaped_filename = escapeshellarg($filename);
+        $cmd = "{$this->base_command} --is-encrypted {$escaped_filename}";
+        exec($cmd, $output, $retcode);
+        return $retcode == 0;
+    }
+    public function scheduleDecrypt(int $attachment_id): bool
+    {
+        $this->logger->info("Scheduling decryption of attachment {$attachment_id}");
+        $uri = "/attachment/{$attachment_id}/decrypt";
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            throw new EmptyResponse($uri);
+        }
+        $json = json_decode($body);
+        if (!isset($json->status)) {
+            throw new MissingResponse('status');
+        }
+        return $json->status;
+    }
+    public function decrypt(string $basename): bool
+    {
+        $this->logger->info("Decrypting {$basename}");
+        $in_filename = implode('/', ['attachments', $basename]);
+        $out_filename = implode('/', ['attachments', 'decrypted', $basename]);
+        if (file_exists($out_filename)) {
+            throw new \Exception("{$basename} already decrypted");
+        }
+        foreach ($this->passwords as $password) {
+            $cmd = $this->base_command . ' -password=' . escapeshellarg($password) . ' -decrypt ' . escapeshellarg($in_filename) . ' ' . escapeshellarg($out_filename);
+            exec($cmd, $output, $retcode);
+            $success = $retcode == 0;
+            if ($success) {
+                return true;
+            }
+            if (file_exists($out_filename)) {
+                unlink($out_filename);
+            }
+            unset($output);
+        }
+        return false;
+    }
+
+}
--- a/cli/common/Service/Communicator.php
+++ b/cli/common/Service/Communicator.php
@ -1,31 +1,19 @@
 <?php
-namespace ProVM\Common\Service;
+namespace ProVM\Service;

 use HttpResponseException;
 use Psr\Http\Client\ClientInterface;
 use Psr\Http\Message\ResponseInterface;
+use Safe\Exceptions\JsonException;
 use function Safe\json_encode;

 class Communicator
 {
-    public function __construct(ClientInterface $client)
-    {
-        $this->setClient($client);
-    }
-
-    protected ClientInterface $client;
-
-    public function getClient(): ClientInterface
-    {
-        return $this->client;
-    }
-
-    public function setClient(ClientInterface $client): Communicator
-    {
-        $this->client = $client;
-        return $this;
-    }
+    public function __construct(protected ClientInterface $client) {}

+    /**
+     * @throws HttpResponseException
+     */
    protected function handleResponse(ResponseInterface $response): ResponseInterface
    {
        if ($response->getStatusCode() < 200 or $response->getStatusCode() >= 300) {
@ -33,6 +21,11 @@ class Communicator
        }
        return $response;
    }
+
+    /**
+     * @throws HttpResponseException
+     * @throws JsonException
+     */
    protected function request(string $method, string $uri, ?array $body = null): ResponseInterface
    {
        $options = [];
@ -42,23 +35,42 @@ class Communicator
            ];
            $options['body'] = json_encode($body);
        }
-        return $this->handleResponse($this->getClient()->request($method, $uri, $options));
+        return $this->handleResponse($this->client->request($method, $uri, $options));
    }

+    /**
+     * @throws HttpResponseException
+     * @throws JsonException
+     */
    public function get(string $uri): ResponseInterface
    {
        return $this->request('get', $uri);
    }
+
+    /**
+     * @throws HttpResponseException
+     * @throws JsonException
+     */
    public function post(string $uri, array $data): ResponseInterface
    {
        return $this->request('post', $uri, $data);
    }
+
+    /**
+     * @throws HttpResponseException
+     * @throws JsonException
+     */
    public function put(string $uri, array $data): ResponseInterface
    {
        return $this->request('put', $uri, $data);
    }
+
+    /**
+     * @throws HttpResponseException
+     * @throws JsonException
+     */
    public function delete(string $uri, array $data): ResponseInterface
    {
        return $this->request('delete', $uri, $data);
    }
-}
+}
--- a/cli/common/Service/Jobs.php
+++ b/cli/common/Service/Jobs.php
@ -0,0 +1,71 @@
+<?php
+namespace ProVM\Service;
+
+use Psr\Log\LoggerInterface;
+use ProVM\Exception\Response\{EmptyResponse, MissingResponse};
+use function Safe\json_decode;
+
+class Jobs
+{
+    public function __construct(protected Communicator $communicator, protected LoggerInterface $logger) {}
+
+    public function getPending(): array
+    {
+        $this->logger->info('Getting pending jobs');
+        $response = $this->communicator->get('/jobs/pending');
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            return [];
+        }
+        $json = json_decode($body);
+        if (!isset($json->jobs)) {
+            return [];
+        }
+        return $json->jobs;
+    }
+    public function get(int $job_id): object
+    {
+        $this->logger->info("Getting Job {$job_id}");
+        $uri = "/job/{$job_id}";
+        return $this->send($uri, 'job');
+    }
+    public function run(object $job): bool
+    {
+        $this->logger->debug("Running Job {$job->id}");
+        $base_command = '/app/bin/emails';
+        $cmd = [$base_command, $job->command];
+        if ($job->arguments !== '') {
+            $cmd []= $job->arguments;
+        }
+        $cmd = implode(' ', $cmd);
+        $response = shell_exec($cmd);
+        if ($response !== false) {
+            return $this->finished($job->id);
+        }
+        return $this->failure($job->id);
+    }
+
+    protected function finished(int $job_id): bool
+    {
+        $uri = "/job/{$job_id}/finish";
+        return $this->send($uri, 'status');
+    }
+    protected function failure(int $job_id): bool
+    {
+        $uri = "/job/{$job_id}/failed";
+        return $this->send($uri, 'status');
+    }
+    protected function send(string $uri, string $param): mixed
+    {
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            throw new EmptyResponse($uri);
+        }
+        $json = json_decode($body);
+        if (!isset($json->{$param})) {
+            throw new MissingResponse($param);
+        }
+        return $json->{$param};
+    }
+}
--- a/cli/common/Service/Mailboxes.php
+++ b/cli/common/Service/Mailboxes.php
@ -0,0 +1,61 @@
+<?php
+namespace ProVM\Service;
+
+use DateTimeImmutable;
+use ProVM\Exception\Response\EmptyResponse;
+use ProVM\Exception\Response\MissingResponse;
+use Psr\Log\LoggerInterface;
+use function Safe\json_decode;
+
+class Mailboxes
+{
+    public function __construct(protected Communicator $communicator, protected LoggerInterface $logger, protected int $min_check_days) {}
+
+    public function getAll(): array
+    {
+        $this->logger->info('Getting all registered mailboxes');
+        $response = $this->communicator->get('/mailboxes/registered');
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            return [];
+        }
+        $json = json_decode($body);
+        if (!isset($json->mailboxes)) {
+            return [];
+        }
+        return $json->mailboxes;
+    }
+    public function check(object $mailbox): bool
+    {
+        $this->logger->info("Checking mailbox {$mailbox->id}");
+        if ((new DateTimeImmutable())->diff(new DateTimeImmutable($mailbox->last_checked->date->date))->days < $this->min_check_days) {
+            return true;
+        }
+        $uri = "/mailbox/{$mailbox->id}/check";
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            throw new EmptyResponse($uri);
+        }
+        $json = json_decode($body);
+        if (!isset($json->status)) {
+            throw new MissingResponse('status');
+        }
+        return $json->status;
+    }
+    public function grabMessages(int $mailbox_id): int
+    {
+        $this->logger->info("Grabbing messages for {$mailbox_id}");
+        $uri = "/mailbox/{$mailbox_id}/messages/grab";
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            return 0;
+        }
+        $json = json_decode($body);
+        if (!isset($json->count)) {
+            return 0;
+        }
+        return $json->count;
+    }
+}
--- a/cli/common/Service/Messages.php
+++ b/cli/common/Service/Messages.php
@ -0,0 +1,43 @@
+<?php
+namespace ProVM\Service;
+
+use ProVM\Exception\Response\EmptyResponse;
+use ProVM\Exception\Response\MissingResponse;
+use Psr\Log\LoggerInterface;
+use function Safe\json_decode;
+
+class Messages
+{
+    public function __construct(protected Communicator $communicator, protected LoggerInterface $logger) {}
+
+    public function get(int $message_id): object
+    {
+        $this->logger->info("Getting message {$message_id}");
+        $uri = "/message/{$message_id}";
+        $response = $this->communicator->get($uri);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            throw new EmptyResponse($uri);
+        }
+        $json = json_decode($body);
+        if (!isset($json->message)) {
+            throw new MissingResponse('message');
+        }
+        return $json->message;
+    }
+    public function grabAttachments(string $message_uid): int
+    {
+        $this->logger->info("Grabbing attachments for message UID {$message_uid}");
+        $uri = '/attachments/grab';
+        $response = $this->communicator->put($uri, ['messages' => [$message_uid]]);
+        $body = $response->getBody()->getContents();
+        if (trim($body) === '') {
+            return 0;
+        }
+        $json = json_decode($body);
+        if (!isset($json->total)) {
+            return 0;
+        }
+        return $json->total;
+    }
+}
--- a/cli/common/Wrapper/Application.php
+++ b/cli/common/Wrapper/Application.php
@ -1,9 +1,8 @@
 <?php
-namespace ProVM\Common\Wrapper;
+namespace ProVM\Wrapper;

 use Psr\Container\ContainerInterface;
 use Symfony\Component\Console\Application as Base;
-
 class Application extends Base
 {
    public function __construct(ContainerInterface $container, string $name = 'UNKNOWN', string $version = 'UNKNOWN')
@ -22,4 +21,4 @@ class Application extends Base
        $this->container = $container;
        return $this;
    }
-}
+}
--- a/cli/composer.json
+++ b/cli/composer.json
@ -15,7 +15,7 @@
    },
    "autoload": {
        "psr-4": {
-            "ProVM\\Common\\": "common/"
+            "ProVM\\": "common/"
        }
    },
    "authors": [
--- a/cli/crontab
+++ b/cli/crontab
@ -1,3 +1,10 @@
 # minutes hour day_of_month month day_of_week command
-0 2 * * 2-6 /app/bin/emails messages:grab >> /logs/messages.log
-0 3 * * 2-6 /app/bin/emails attachments:grab >> /logs/attachments.log
+#0  2   *   *   2-6 /app/bin/emails messages:grab >> /logs/messages.log
+#0  3   *   *   2-6 /app/bin/emails attachments:grab >> /logs/attachments.log
+
+# Pending jobs every minute
+*   *   *   *   *   /app/bin/emails jobs:check >> /logs/jobs.log
+# Check mailboxes for new emails every weekday
+0   0   *   *   2-6 /app/bin/emails mailboxes:check >> /logs/mailboxes.log
+# Check attachments every weekday
+0   1   *   *   2-6 /app/bin/emails attachments:check >> /logs/attachments.log
--- a/cli/docker-compose.yml
+++ b/cli/docker-compose.yml
@ -12,4 +12,6 @@ services:
      - .key.env
    volumes:
      - ${CLI_PATH:-.}/:/app
-      - ./logs/cli:/logs
+      - ${CLI_PATH}/crontab:/var/spool/cron/crontabs/root
+      - ${LOGS_PATH}/cli:/logs
+      - ${ATT_PATH}:/attachments
--- a/cli/public/index.php
+++ b/cli/public/index.php
@ -4,9 +4,11 @@ $app = require_once implode(DIRECTORY_SEPARATOR, [
    'setup',
    'app.php'
 ]);
+Monolog\ErrorHandler::register($app->getContainer()->get(Psr\Log\LoggerInterface::class));
 try {
    $app->run();
-} catch (Error | Exception $e) {
-    $app->getContainer()->get(\Psr\Log\LoggerInterface::class)->error($e);
-    throw $e;
+} catch (Error $e) {
+    $app->getContainer()->get(Psr\Log\LoggerInterface::class)->error($e);
+} catch (Exception $e) {
+    $app->getContainer()->get(Psr\Log\LoggerInterface::class)->warning($e);
 }
--- a/cli/resources/commands/01_mailboxes.php
+++ b/cli/resources/commands/01_mailboxes.php
@ -0,0 +1,2 @@
+<?php
+$app->add($app->getContainer()->get(ProVM\Command\Mailboxes\Check::class));
--- a/cli/resources/commands/01_messages.php
+++ b/cli/resources/commands/01_messages.php
@ -1,2 +1,2 @@
 <?php
-$app->add($app->getContainer()->get(\ProVM\Common\Command\Messages::class));
+$app->add($app->getContainer()->get(ProVM\Command\Messages\Grab::class));
--- a/cli/resources/commands/02_attachments.php
+++ b/cli/resources/commands/02_attachments.php
@ -1,3 +1,4 @@
 <?php
-$app->add($app->getContainer()->get(\ProVM\Common\Command\GrabAttachments::class));
-$app->add($app->getContainer()->get(\ProVM\Common\Command\DecryptPdf::class));
+$app->add($app->getContainer()->get(ProVM\Command\Attachments\Check::class));
+$app->add($app->getContainer()->get(ProVM\Command\Attachments\Grab::class));
+$app->add($app->getContainer()->get(ProVM\Command\Attachments\Decrypt::class));
--- a/cli/resources/commands/03_jobs.php
+++ b/cli/resources/commands/03_jobs.php
@ -0,0 +1,3 @@
+<?php
+$app->add($app->getContainer()->get(ProVM\Command\Jobs\Check::class));
+$app->add($app->getContainer()->get(ProVM\Command\Jobs\Execute::class));
--- a/cli/setup/app.php
+++ b/cli/setup/app.php
@ -1,7 +1,7 @@
 <?php
 require_once 'composer.php';

-$builder = new \DI\ContainerBuilder();
+$builder = new DI\ContainerBuilder();

 $folders = [
    'settings',
@ -24,7 +24,7 @@ foreach ($folders as $f) {
    }
 }

-$app = new \ProVM\Common\Wrapper\Application($builder->build());
+$app = new ProVM\Wrapper\Application($builder->build());

 $folder = implode(DIRECTORY_SEPARATOR, [
    __DIR__,
--- a/cli/setup/settings/01_env.php
+++ b/cli/setup/settings/01_env.php
@ -1,5 +1,10 @@
 <?php
 return [
    'api_uri' => $_ENV['API_URI'],
-    'api_key' => sha1($_ENV['API_KEY'])
+    'api_key' => sha1($_ENV['API_KEY']),
+    'base_command' => 'qpdf',
+    'passwords' => function() {
+        return explode($_ENV['PASSWORDS_SEPARATOR'] ?? ',', $_ENV['PASSWORDS'] ?? '');
+    },
+    'min_check_days' => 1
 ];
--- a/cli/setup/settings/02_folders.php
+++ b/cli/setup/settings/02_folders.php
@ -14,5 +14,6 @@ return [
            $container->get('resources_folder'),
            'commands'
        ]);
-    }
+    },
+    'logs_folder' => '/logs',
 ];
--- a/cli/setup/setups/02_api.php
+++ b/cli/setup/setups/02_api.php
@ -2,12 +2,12 @@
 use Psr\Container\ContainerInterface;

 return [
-    \Psr\Http\Client\ClientInterface::class => function(ContainerInterface $container) {
-        return new \GuzzleHttp\Client([
+    Psr\Http\Client\ClientInterface::class => function(ContainerInterface $container) {
+        return new GuzzleHttp\Client([
            'base_uri' => $container->get('api_uri'),
            'headers' => [
                'Authorization' => "Bearer {$container->get('api_key')}"
            ]
        ]);
    }
-];
+];
--- a/cli/setup/setups/03_middleware.php
+++ b/cli/setup/setups/03_middleware.php
@ -0,0 +1,8 @@
+<?php
+use Psr\Container\ContainerInterface;
+
+return [
+    ProVM\Middleware\Logging::class => function(ContainerInterface $container) {
+        return new ProVM\Middleware\Logging($container->get('request_logger'));
+    }
+];
--- a/cli/setup/setups/04_commands.php
+++ b/cli/setup/setups/04_commands.php
@ -0,0 +1,21 @@
+<?php
+
+use Psr\Container\ContainerInterface;
+
+return [
+    ProVM\Service\Mailboxes::class => function(ContainerInterface $container) {
+        return new ProVM\Service\Mailboxes(
+            $container->get(ProVM\Service\Communicator::class),
+            $container->get(Psr\Log\LoggerInterface::class),
+            $container->get('min_check_days')
+        );
+    },
+    ProVM\Service\Attachments::class => function(ContainerInterface $container) {
+        return new ProVM\Service\Attachments(
+            $container->get(ProVM\Service\Communicator::class),
+            $container->get(Psr\Log\LoggerInterface::class),
+            $container->get('passwords'),
+            $container->get('base_command')
+        );
+    },
+];
--- a/cli/setup/setups/98_log.php
+++ b/cli/setup/setups/98_log.php
@ -2,14 +2,49 @@
 use Psr\Container\ContainerInterface;

 return [
-    \Monolog\Handler\RotatingFileHandler::class => function(ContainerInterface $container) {
-        $handler = new \Monolog\Handler\RotatingFileHandler($container->get('log_file'));
-        $handler->setFormatter($container->get(\Monolog\Formatter\LineFormatter::class));
-        return $handler;
+    'log_processors' => function(ContainerInterface $container) {
+        return [
+            $container->get(Monolog\Processor\PsrLogMessageProcessor::class),
+            $container->get(Monolog\Processor\IntrospectionProcessor::class),
+            $container->get(Monolog\Processor\MemoryPeakUsageProcessor::class),
+        ];
    },
-    \Psr\Log\LoggerInterface::class => function(ContainerInterface $container) {
-        $logger = new \Monolog\Logger('file_logger');
-        $logger->pushHandler($container->get(\Monolog\Handler\RotatingFileHandler::class));
-        return $logger;
-    }
-];
+    'request_log_handler' => function(ContainerInterface $container) {
+        return (new Monolog\Handler\RotatingFileHandler(implode(DIRECTORY_SEPARATOR, [$container->get('logs_folder'), 'requests.log'])));
+    },
+    'request_logger' => function(ContainerInterface $container) {
+        return new Monolog\Logger(
+            'request_logger',
+            [$container->get('request_log_handler')],
+            $container->get('log_processors')
+        );
+    },
+    'file_log_handler' => function(ContainerInterface $container) {
+        return new Monolog\Handler\FilterHandler(
+            (new Monolog\Handler\RotatingFileHandler($container->get('log_file')))
+                ->setFormatter(new Monolog\Formatter\LineFormatter(null, null, true)),
+            Monolog\Level::Error
+        );
+    },
+    'debug_log_handler' => function(ContainerInterface $container) {
+        return new Monolog\Handler\FilterHandler(
+            (new Monolog\Handler\RotatingFileHandler(implode(DIRECTORY_SEPARATOR, [$container->get('logs_folder'), 'debug.log'])))
+                ->setFormatter(new Monolog\Formatter\LineFormatter(null, null, true)),
+            Monolog\Level::Debug,
+            Monolog\Level::Warning
+        );
+    },
+    Psr\Log\LoggerInterface::class => function(ContainerInterface $container) {
+        return $container->get('file_logger');
+    },
+    'file_logger' => function(ContainerInterface $container) {
+        return new Monolog\Logger(
+            'file',
+            [
+                $container->get('file_log_handler'),
+                $container->get('debug_log_handler')
+            ],
+            $container->get('log_processors')
+        );
+    },
+];
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Aldarien	00167b02d5	DB connection settings diff	2023-10-31 13:41:15 -03:00
Aldarien	81d1bc21fe	Icon and mailboxes button	2023-10-31 13:38:24 -03:00
Aldarien	75c7dd95a0	Better UI in home	2023-10-31 13:03:49 -03:00
Aldarien	3124d09480	Merge branch 'feature/jobs' into develop	2023-06-12 21:14:31 -04:00
Aldarien	88f91c4bd5	Jobs setup	2023-06-12 21:14:07 -04:00
Aldarien	03c1dac2f2	Cleanup of cli	2023-06-09 00:54:34 -04:00
Aldarien	9307ba330c	Various updates	2023-06-08 20:49:27 -04:00
Aldarien	3ed5acf75e	Readme	2022-12-01 15:33:20 -03:00
Aldarien	5202698d06	Move .mail.env to api container	2022-12-01 15:33:06 -03:00
Aldarien	e3719fb7b9	*.env.sample files	2022-12-01 14:38:22 -03:00
Aldarien	1f8d4f0bce	Log _SERVER when errors are found	2022-12-01 14:32:16 -03:00
Aldarien	025697d37c	FIX: Check for _REQUEST	2022-12-01 14:22:13 -03:00
Aldarien	de81f16557	Logging	2022-12-01 14:15:54 -03:00
Aldarien	c0ddd00cc6	Scheduling UI corrected	2022-11-30 20:45:18 -03:00