DocumentController.php

        $document = DocumentModel::getById(['select' => ['mailing_id'], 'id' => $args['id']]);
        if (empty($document['mailing_id'])) {
            return $response->withJson(['documents' => []]);
        }

        $substitutedUsers = UserModel::get(['select' => ['id'], 'where' => ['substitute = ?'], 'data' => [$GLOBALS['id']]]);

        $users = [$GLOBALS['id']];
        foreach ($substitutedUsers as $value) {
            $users[] = $value['id'];
        }

        $workflowSelect = "SELECT id FROM workflows ws WHERE workflows.main_document_id = main_document_id AND process_date IS NULL AND status IS NULL ORDER BY \"order\" LIMIT 1";

        $workflows = WorkflowModel::get([
            'select'    => ['main_document_id'],
            'where'     => ['user_id in (?)', "(id) in ({$workflowSelect})"],
            'data'      => [$users]
        ]);
        $ids = array_column($workflows, 'main_document_id');

        $documents = DocumentModel::get([
            'select'    => ['id'],
            'where'     => ['id in (?)', 'mailing_id = ?'],
            'data'      => [$ids, $document['mailing_id']]
        ]);
        $documentsId = array_column($documents, 'id');

        return $response->withJson(['documents' => $documentsId]);
    }

    public static function endAction(array $args)
    {
        ValidatorModel::notEmpty($args, ['id', 'status', 'workflowId']);
        ValidatorModel::intVal($args, ['id', 'workflowId']);
        ValidatorModel::stringType($args, ['status', 'note']);

        $set = ['process_date' => 'CURRENT_TIMESTAMP', 'status' => $args['status']];
        if (!empty($args['note'])) {
            $set['note'] = $args['note'];
        }
        WorkflowModel::update([
            'set'   => $set,
            'where' => ['id = ?'],
            'data'  => [$args['workflowId']]
        ]);

        if ($args['status'] == 'REF') {
            WorkflowModel::update([
                'set'   => ['status' => 'END'],
                'where' => ['main_document_id = ?', 'process_date is null'],
                'data'  => [$args['id']]
            ]);
        }

        $nextWorkflow = WorkflowModel::getCurrentStep(['select' => ['id', 'user_id'], 'documentId' => $args['id']]);
        if (!empty($nextWorkflow) && empty($nextWorkflow['user_id'])) {
            $workflowExternalInformations = WorkflowExternalInformationModel::get(['select' => ['*'], 'where' => ['workflow_id = ?'], 'data' => [$nextWorkflow['id']]]);
            if (!empty($workflowExternalInformations[0])) {
                $content = DocumentController::getContentPath(['id' => $args['id']]);
                $content = file_get_contents($content['path']);
                $document = DocumentModel::getById(['select' => ['title', 'description'], 'id' => $args['id']]);

                YousignController::createProcedure([
                    'documentId'        => $args['id'],
                    'encodedDocument'   => base64_encode($content),
                    'name'              => $document['title'],
                    'description'       => $document['description'],
                    'position'          => "364,105,462,145",
                    'workflowId'        => $nextWorkflow['id']
                ]);
            }
        } else {
            EmailController::sendNotification(['documentId' => $args['id'], 'status' => $args['status']]);
        }

        return true;
    }

    public static function hasRightById(array $args)
    {
        ValidatorModel::notEmpty($args, ['id', 'userId']);
        ValidatorModel::intVal($args, ['id', 'userId']);

        $document = DocumentModel::getById(['select' => ['typist'], 'id' => $args['id']]);
        if ($document['typist'] == $GLOBALS['id']) {
            return true;
        }

        $workflow = WorkflowModel::getCurrentStep(['select' => ['user_id'], 'documentId' => $args['id']]);
        if (empty($workflow)) {
            return false;
        }

        if ($workflow['user_id'] != $args['userId']) {
            $user = UserModel::getById(['id' => $workflow['user_id'], 'select' => ['substitute']]);
            if ($user['substitute'] != $args['userId']) {
                return false;
            }
        }

        return true;
    }

    public static function getEncodedDocumentFromEncodedZip(array $args)
    {
        ValidatorModel::notEmpty($args, ['encodedZipDocument']);
        ValidatorModel::stringType($args, ['encodedZipDocument']);

        $tmpPath = CoreConfigModel::getTmpPath();

        $zipDocumentOnTmp = $tmpPath . mt_rand() . '_parapheur.zip';
        file_put_contents($zipDocumentOnTmp, base64_decode($args['encodedZipDocument']));

        $zipArchive = new \ZipArchive();
        $open = $zipArchive->open($zipDocumentOnTmp);
        if ($open != true) {
            return ['errors' => "getDocumentFromEncodedZip : $open"];
        }

        $dirOnTmp = $tmpPath . mt_rand() . '_parapheur';
        if (!@$zipArchive->extractTo($dirOnTmp)) {
            return ['errors' => "getDocumentFromEncodedZip : Extract failed"];
        }

        $filesOnTmp = scandir($dirOnTmp);
        foreach ($filesOnTmp as $fileOnTmp) {
            if ($fileOnTmp != '.' && $fileOnTmp != '..') {
                $base64Content = base64_encode(file_get_contents("{$dirOnTmp}/{$fileOnTmp}"));
                unlink($zipDocumentOnTmp);
                return ['encodedDocument' => $base64Content];
            }
        }

        return ['errors' => "getDocumentFromEncodedZip : No document was found in Zip"];
    }

    public static function getLinkedDocuments(array $args)
    {
        ValidatorModel::notEmpty($args, ['id', 'userId', 'linkId']);
        ValidatorModel::intVal($args, ['id', 'userId']);
        ValidatorModel::stringType($args, ['linkId']);

        $substitutedUsers = UserModel::get(['select' => ['id'], 'where' => ['substitute = ?'], 'data' => [$args['userId']]]);

        $users = [$args['userId']];
        foreach ($substitutedUsers as $value) {
            $users[] = $value['id'];
        }

        $workflowSelect = "SELECT id FROM workflows ws WHERE workflows.main_document_id = main_document_id AND process_date IS NULL AND status IS NULL ORDER BY \"order\" LIMIT 1";
        $workflows = WorkflowModel::get([
            'select'    => ['main_document_id', 'mode', 'user_id'],
            'where'     => ['user_id in (?)', "(id) in ({$workflowSelect})", 'main_document_id != ?'],
            'data'      => [$users, $args['id']]
        ]);
        $documentIds = array_column($workflows, 'main_document_id');

        $linkedDocuments = [];
        if (!empty($documentIds)) {
            $linkedDocuments = DocumentModel::get([
                'select'    => ['id', 'title', 'reference'],
                'where'     => ['id in (?)', 'link_id = ?'],
                'data'      => [$documentIds, $args['linkId']],
                'orderBy'   => ['creation_date desc']
            ]);
        }

        return $linkedDocuments;
    }

    public static function getContentPath(array $args)
    {
        if (!empty($args['type'])) {
            $adr = AdrModel::getDocumentsAdr([
                'select'    => ['path', 'filename', 'fingerprint', 'type'],
                'where'     => ['main_document_id = ?', 'type = ?'],
                'data'      => [$args['id'], $args['type']]
            ]);
        }
        if (empty($adr)) {
            $adr = AdrModel::getDocumentsAdr([
                'select'    => ['path', 'filename', 'fingerprint', 'type'],
                'where'     => ['main_document_id = ?', 'type = ?'],
                'data'      => [$args['id'], 'DOC']
            ]);
        }

        if (empty($adr[0])) {
            return null;
        }

        $docserver = DocserverModel::getByType(['type' => $adr[0]['type'], 'select' => ['path']]);
        if (empty($docserver['path']) || !file_exists($docserver['path'])) {
            return ['errors' => 'Docserver does not exist', 'code' => 400];
        }

        $pathToDocument = $docserver['path'] . $adr[0]['path'] . $adr[0]['filename'];
        if (!is_file($pathToDocument)) {
            return ['errors' => 'Document not found on docserver', 'code' => 404];
        }

        $fingerprint = DocserverController::getFingerPrint(['path' => $pathToDocument]);
        if ($adr[0]['fingerprint'] != $fingerprint) {
            return ['errors' => 'Fingerprints do not match', 'code' => 400];
        }

        return ['path' => $pathToDocument];
    }

    public static function getPdfCertificate(array $args)
    {
        ValidatorModel::notEmpty($args, ['path', 'documentId']);
        ValidatorModel::intVal($args, ['documentId']);
        ValidatorModel::stringType($args, ['path']);

        $path = $args['path'];
        $documentId = $args['documentId'];

        $tmpPath = CoreConfigModel::getTmpPath();

        $signaturePath = $tmpPath . 'signature_' . $documentId . '.pkcs7';
        $signatureInfoPath = $tmpPath . 'signatureInfo_' . $documentId . '.txt';

        if (file_exists($signatureInfoPath)) {
            $content = file_get_contents($signatureInfoPath);
            if ($content !== false) {
                return $content;
            }
        }

        $content = file_get_contents($path);
        $regexp = '#ByteRange\[\s*(\d+) (\d+) (\d+)#'; // subexpressions are used to extract b and c

        $result = [];
        preg_match_all($regexp, $content, $result);

        // $result[2][0] and $result[3][0] are b and c
        if (isset($result[2]) && isset($result[3]) && isset($result[2][0]) && isset($result[3][0])) {
            $start = $result[2][0];
            $end = $result[3][0];
            if ($stream = fopen($path, 'rb')) {
                $signature = stream_get_contents($stream, $end - $start - 2, $start + 1); // because we need to exclude < and > from start and end
                fclose($stream);
                file_put_contents($signaturePath, hex2bin($signature));
            }
        }

        if (!file_exists($signaturePath)) {
            return false;
        }
        exec('openssl pkcs7 -in ' . $signaturePath . ' -inform DER -print_certs > ' . $signatureInfoPath . ' 2>&1', $output, $return);

        return file_get_contents($signatureInfoPath);
    }

    public static function setSignaturesOnPdf(array $args, Fpdi &$pdf)
    {
        ValidatorModel::notEmpty($args, ['signatures', 'pagesNumber']);
        ValidatorModel::arrayType($args, ['signatures']);
        ValidatorModel::intVal($args, ['pagesNumber']);

        $affectedPages = [];
        $tmpPath = CoreConfigModel::getTmpPath();

        $pdf->setPrintHeader(false);

        for ($i = 1; $i <= $args['pagesNumber']; $i++) {
            $page = $pdf->importPage($i);
            $size = $pdf->getTemplateSize($page);
            $pdf->AddPage($size['orientation'], $size);
            $pdf->useImportedPage($page);
            $pdf->SetAutoPageBreak(false, 0);
            $pdf->SetMargins(0, 0, 0);
            $pdf->SetAutoPageBreak(false, 0);
            foreach ($args['signatures'] as $signature) {
                if ($signature['page'] == $i) {
                    if (!in_array($i, $affectedPages)) {
                        $affectedPages[] = $i;
                    }
                    if ($signature['positionX'] == 0 && $signature['positionY'] == 0) {
                        $signWidth  = $size['width'];
                        $signPosX   = 0;
                        $signPosY   = 0;
                        $signHeight = null;
                    } else {
                        $signWidth  = ($signature['width'] * $size['width']) / 100;
                        $signHeight = ($signature['height'] * $size['height']) / 100;
                        $signPosX   = ($signature['positionX'] * $size['width']) / 100;
                        $signPosY   = ($signature['positionY'] * $size['height']) / 100;
                    }
                    if ($signature['type'] == 'SVG') {
                        $image = str_replace('data:image/svg+xml;base64,', '', $signature['encodedImage']);
                        $image = base64_decode($image);
                        if ($image === false) {
                            return ['errors' => 'setSignaturesOnPdf : base64_decode failed for SVP type signature'];
                        }

                        $imageTmpPath = $tmpPath . $GLOBALS['id'] . '_' . rand() . '_writing.svg';
                        file_put_contents($imageTmpPath, $image);
                        $pdf->ImageSVG($imageTmpPath, $signPosX, $signPosY, $signWidth, $signHeight);
                    } else {
                        $image = base64_decode($signature['encodedImage']);
                        if ($image === false) {
                            return ['errors' => 'setSignaturesOnPdf : base64_decode failed'];
                        }

                        $imageTmpPath = $tmpPath . $GLOBALS['id'] . '_' . rand() . '_writing.png';
                        file_put_contents($imageTmpPath, $image);
                        $pdf->Image($imageTmpPath, $signPosX, $signPosY, $signWidth);
                    }
                }
            }
        }

        return ['affectedPages' => $affectedPages];
    }

    public static function getDocumentPath(array $args)
    {
        ValidatorModel::notEmpty($args, ['id']);
        ValidatorModel::intVal($args, ['id']);

        $content = DocumentController::getContentPath(['id' => $args['id']]);
        if (empty($content)) {
            return ['errors' => 'Document does not exist'];
        } elseif (!empty($content['errors'])) {
            return ['errors' => $content['errors']];
        }

        return ['path' => $content['path']];
    }

    private static function processSignatures(array $args)
    {
        ValidatorModel::notEmpty($args, ['path', 'signature']);
        ValidatorModel::stringType($args, ['path']);

        $tmpPath = CoreConfigModel::getTmpPath();
        if (!is_dir($tmpPath)) {
            return ['errors' => 'Tmp path is not valid'];
        }

        $tmpFilename = $tmpPath . $GLOBALS['id'] . '_' . rand() . 'adr.pdf';
        copy($args['path'], $tmpFilename);

        $configPath = CoreConfigModel::getConfigPath();
        $overrideFile = "{$configPath}/override/setasign/fpdi_pdf-parser/src/autoload.php";
        if (file_exists($overrideFile)) {
            require_once($overrideFile);
        }
        $pdf            = new Fpdi('P');
        $pagesNumber    = $pdf->setSourceFile($tmpFilename);

        $control = DocumentController::setSignaturesOnPdf(['signatures' => [$args['signature']], 'pagesNumber' => $pagesNumber], $pdf);
        if (!empty($control['errors'])) {
            return ['errors' => $control['errors']];
        }

        if ($args['signWithServerCertificate']) {
            $control = CertificateSignatureController::signWithServerCertificate($pdf);
            if (!empty($control['errors'])) {
                return ['errors' => $control['errors']];
            }
        }

        $fileContent = $pdf->Output('', 'S');
        unlink($tmpFilename);

        return ['fileContent' => $fileContent];
    }
}