20210417471

Committed 14 Dec 2025 03:51PM UTC coverage: 44.081%. First build

Build # 20210417471

Build Type

Pull #6181

github

Committed by

web-flow

Commit Message

Merge 21aee754a into 95a26cb92

Pull Request Pull Request #6181: feat: cancel signature request notification

Run Details

114 of 235 new or added lines in 9 files covered. (48.51%)

5932 of 13457 relevant lines covered (44.08%)

5.06 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.01

/lib/Service/RequestSignatureService.php

<?php

declare(strict_types=1);
/**
 * SPDX-FileCopyrightText: 2020-2024 LibreCode coop and contributors
 * SPDX-License-Identifier: AGPL-3.0-or-later
 */

namespace OCA\Libresign\Service;

use OCA\Libresign\AppInfo\Application;
use OCA\Libresign\Db\File as FileEntity;
use OCA\Libresign\Db\FileElementMapper;
use OCA\Libresign\Db\FileMapper;
use OCA\Libresign\Db\IdentifyMethodMapper;
use OCA\Libresign\Db\SignRequest as SignRequestEntity;
use OCA\Libresign\Db\SignRequestMapper;
use OCA\Libresign\Enum\SignatureFlow;
use OCA\Libresign\Events\SignRequestCanceledEvent;
use OCA\Libresign\Handler\DocMdpHandler;
use OCA\Libresign\Helper\ValidateHelper;
use OCA\Libresign\Service\IdentifyMethod\IIdentifyMethod;
use OCP\AppFramework\Db\DoesNotExistException;
use OCP\EventDispatcher\IEventDispatcher;
use OCP\Files\IMimeTypeDetector;
use OCP\Files\Node;
use OCP\Http\Client\IClientService;
use OCP\IAppConfig;
use OCP\IL10N;
use OCP\IUser;
use OCP\IUserManager;
use Psr\Log\LoggerInterface;
use Sabre\DAV\UUIDUtil;

class RequestSignatureService {
        use TFile;

        public function __construct(
                protected IL10N $l10n,
                protected IdentifyMethodService $identifyMethod,
                protected SignRequestMapper $signRequestMapper,
                protected IUserManager $userManager,
                protected FileMapper $fileMapper,
                protected IdentifyMethodMapper $identifyMethodMapper,
                protected PdfParserService $pdfParserService,
                protected FileElementService $fileElementService,
                protected FileElementMapper $fileElementMapper,
                protected FolderService $folderService,
                protected IMimeTypeDetector $mimeTypeDetector,
                protected ValidateHelper $validateHelper,
                protected IClientService $client,
                protected DocMdpHandler $docMdpHandler,
                protected LoggerInterface $logger,
                protected SequentialSigningService $sequentialSigningService,
                protected IAppConfig $appConfig,
                protected IEventDispatcher $eventDispatcher,
        ) {
        }

        public function save(array $data): FileEntity {
                $file = $this->saveFile($data);
                $this->saveVisibleElements($data, $file);
                if (!isset($data['status'])) {
                        $data['status'] = $file->getStatus();
                }
                $this->sequentialSigningService->setFile($file);
                $this->associateToSigners($data, $file->getId());
                return $file;
        }

        /**
         * Save file data
         *
         * @param array{?userManager: IUser, ?signRequest: SignRequest, name: string, callback: string, uuid?: ?string, status: int, file?: array{fileId?: int, fileNode?: Node}} $data
         */
        public function saveFile(array $data): FileEntity {
                if (!empty($data['uuid'])) {
                        $file = $this->fileMapper->getByUuid($data['uuid']);
                        return $this->updateStatus($file, $data['status'] ?? 0);
                }
                $fileId = null;
                if (isset($data['file']['fileNode']) && $data['file']['fileNode'] instanceof Node) {
                        $fileId = $data['file']['fileNode']->getId();
                } elseif (!empty($data['file']['fileId'])) {
                        $fileId = $data['file']['fileId'];
                }
                if (!is_null($fileId)) {
                        try {
                                $file = $this->fileMapper->getByFileId($fileId);
                                return $this->updateStatus($file, $data['status'] ?? 0);
                        } catch (\Throwable) {
                        }
                }

                $node = $this->getNodeFromData($data);

                $file = new FileEntity();
                $file->setNodeId($node->getId());
                if ($data['userManager'] instanceof IUser) {
                        $file->setUserId($data['userManager']->getUID());
                } elseif ($data['signRequest'] instanceof SignRequestEntity) {
                        $file->setSignRequestId($data['signRequest']->getId());
                }
                $file->setUuid(UUIDUtil::getUUID());
                $file->setCreatedAt(new \DateTime('now', new \DateTimeZone('UTC')));
                $metadata = $this->getFileMetadata($node);
                $file->setName($this->removeExtensionFromName($data['name'], $metadata));
                $file->setMetadata($metadata);
                if (!empty($data['callback'])) {
                        $file->setCallback($data['callback']);
                }
                if (isset($data['status'])) {
                        $file->setStatus($data['status']);
                } else {
                        $file->setStatus(FileEntity::STATUS_ABLE_TO_SIGN);
                }

                if (isset($data['signatureFlow']) && is_string($data['signatureFlow'])) {
                        try {
                                $signatureFlow = \OCA\Libresign\Enum\SignatureFlow::from($data['signatureFlow']);
                                $file->setSignatureFlowEnum($signatureFlow);
                        } catch (\ValueError) {
                                $this->setSignatureFlowFromGlobalConfig($file);
                        }
                } else {
                        $this->setSignatureFlowFromGlobalConfig($file);
                }

                $this->fileMapper->insert($file);
                return $file;
        }

        private function setSignatureFlowFromGlobalConfig(FileEntity $file): void {
                $globalFlowValue = $this->appConfig->getValueString(Application::APP_ID, 'signature_flow', SignatureFlow::PARALLEL->value);
                $globalFlow = SignatureFlow::from($globalFlowValue);
                $file->setSignatureFlowEnum($globalFlow);
        }

        private function updateStatus(FileEntity $file, int $status): FileEntity {
                if ($status > $file->getStatus()) {
                        $file->setStatus($status);
                        /** @var FileEntity */
                        return $this->fileMapper->update($file);
                }
                return $file;
        }

        private function getFileMetadata(\OCP\Files\Node $node): array {
                $metadata = [];
                if ($extension = strtolower($node->getExtension())) {
                        $metadata = [
                                'extension' => $extension,
                        ];
                        if ($metadata['extension'] === 'pdf') {
                                $metadata = array_merge(
                                        $metadata,
                                        $this->pdfParserService
                                                ->setFile($node)
                                                ->getPageDimensions()
                                );
                        }
                }
                return $metadata;
        }

        private function removeExtensionFromName(string $name, array $metadata): string {
                if (!isset($metadata['extension'])) {
                        return $name;
                }
                $extensionPattern = '/\.' . preg_quote($metadata['extension'], '/') . '$/i';
                $result = preg_replace($extensionPattern, '', $name);
                return $result ?? $name;
        }

        private function deleteIdentifyMethodIfNotExits(array $users, int $fileId): void {
                $file = $this->fileMapper->getById($fileId);
                $signRequests = $this->signRequestMapper->getByFileId($fileId);
                foreach ($signRequests as $key => $signRequest) {
                        $identifyMethods = $this->identifyMethod->getIdentifyMethodsFromSignRequestId($signRequest->getId());
                        if (empty($identifyMethods)) {
                                $this->unassociateToUser($file->getNodeId(), $signRequest->getId());
                                continue;
                        }
                        foreach ($identifyMethods as $methodName => $list) {
                                foreach ($list as $method) {
                                        $exists[$key]['identify'][$methodName] = $method->getEntity()->getIdentifierValue();
                                        if (!$this->identifyMethodExists($users, $method)) {
                                                $this->unassociateToUser($file->getNodeId(), $signRequest->getId());
                                                continue 3;
                                        }
                                }
                        }
                }
        }

        private function identifyMethodExists(array $users, IIdentifyMethod $identifyMethod): bool {
                foreach ($users as $user) {
                        if (!empty($user['identifyMethods'])) {
                                foreach ($user['identifyMethods'] as $data) {
                                        if ($identifyMethod->getEntity()->getIdentifierKey() !== $data['method']) {
                                                continue;
                                        }
                                        if ($identifyMethod->getEntity()->getIdentifierValue() === $data['value']) {
                                                return true;
                                        }
                                }
                        } else {
                                foreach ($user['identify'] as $method => $value) {
                                        if ($identifyMethod->getEntity()->getIdentifierKey() !== $method) {
                                                continue;
                                        }
                                        if ($identifyMethod->getEntity()->getIdentifierValue() === $value) {
                                                return true;
                                        }
                                }
                        }
                }
                return false;
        }

        /**
         * @return SignRequestEntity[]
         *
         * @psalm-return list<SignRequestEntity>
         */
        private function associateToSigners(array $data, int $fileId): array {
                $return = [];
                if (!empty($data['users'])) {
                        $this->deleteIdentifyMethodIfNotExits($data['users'], $fileId);

                        $this->sequentialSigningService->resetOrderCounter();
                        $fileStatus = $data['status'] ?? null;

                        foreach ($data['users'] as $user) {
                                $userProvidedOrder = isset($user['signingOrder']) ? (int)$user['signingOrder'] : null;
                                $signingOrder = $this->sequentialSigningService->determineSigningOrder($userProvidedOrder);
                                $signerStatus = $user['status'] ?? null;

                                if (isset($user['identifyMethods'])) {
                                        foreach ($user['identifyMethods'] as $identifyMethod) {
                                                $return[] = $this->associateToSigner(
                                                        identifyMethods: [
                                                                $identifyMethod['method'] => $identifyMethod['value'],
                                                        ],
                                                        displayName: $user['displayName'] ?? '',
                                                        description: $user['description'] ?? '',
                                                        notify: empty($user['notify']) && $this->isStatusAbleToNotify($fileStatus),
                                                        fileId: $fileId,
                                                        signingOrder: $signingOrder,
                                                        fileStatus: $fileStatus,
                                                        signerStatus: $signerStatus,
                                                );
                                        }
                                } else {
                                        $return[] = $this->associateToSigner(
                                                identifyMethods: $user['identify'],
                                                displayName: $user['displayName'] ?? '',
                                                description: $user['description'] ?? '',
                                                notify: empty($user['notify']) && $this->isStatusAbleToNotify($fileStatus),
                                                fileId: $fileId,
                                                signingOrder: $signingOrder,
                                                fileStatus: $fileStatus,
                                                signerStatus: $signerStatus,
                                        );
                                }
                        }
                }
                return $return;
        }

        private function isStatusAbleToNotify(?int $status): bool {
                return in_array($status, [
                        FileEntity::STATUS_ABLE_TO_SIGN,
                        FileEntity::STATUS_PARTIAL_SIGNED,
                ]);
        }

        private function associateToSigner(
                array $identifyMethods,
                string $displayName,
                string $description,
                bool $notify,
                int $fileId,
                int $signingOrder = 0,
                ?int $fileStatus = null,
                ?int $signerStatus = null,
        ): SignRequestEntity {
                $identifyMethodsIncances = $this->identifyMethod->getByUserData($identifyMethods);
                if (empty($identifyMethodsIncances)) {
                        throw new \Exception($this->l10n->t('Invalid identification method'));
                }
                $signRequest = $this->getSignRequestByIdentifyMethod(
                        current($identifyMethodsIncances),
                        $fileId
                );
                $displayName = $this->getDisplayNameFromIdentifyMethodIfEmpty($identifyMethodsIncances, $displayName);
                $this->setDataToUser($signRequest, $displayName, $description, $fileId);

                $signRequest->setSigningOrder($signingOrder);

                $isNewSignRequest = !$signRequest->getId();
                $currentStatus = $signRequest->getStatusEnum();

                if ($isNewSignRequest || $currentStatus === \OCA\Libresign\Enum\SignRequestStatus::DRAFT) {
                        $desiredStatus = $this->determineInitialStatus($signingOrder, $fileStatus, $signerStatus, $currentStatus, $fileId);
                        $this->updateStatusIfAllowed($signRequest, $currentStatus, $desiredStatus, $isNewSignRequest);
                }

                $this->saveSignRequest($signRequest);

                $shouldNotify = $notify && $signRequest->getStatusEnum() === \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;

                foreach ($identifyMethodsIncances as $identifyMethod) {
                        $identifyMethod->getEntity()->setSignRequestId($signRequest->getId());
                        $identifyMethod->willNotifyUser($shouldNotify);
                        $identifyMethod->save();
                }
                return $signRequest;
        }

        private function updateStatusIfAllowed(
                SignRequestEntity $signRequest,
                \OCA\Libresign\Enum\SignRequestStatus $currentStatus,
                \OCA\Libresign\Enum\SignRequestStatus $desiredStatus,
                bool $isNewSignRequest,
        ): void {
                if ($isNewSignRequest || $this->sequentialSigningService->isStatusUpgrade($currentStatus, $desiredStatus)) {
                        $signRequest->setStatusEnum($desiredStatus);
                }
        }

        private function determineInitialStatus(
                int $signingOrder,
                ?int $fileStatus = null,
                ?int $signerStatus = null,
                ?\OCA\Libresign\Enum\SignRequestStatus $currentStatus = null,
                ?int $fileId = null,
        ): \OCA\Libresign\Enum\SignRequestStatus {
                // If fileStatus is explicitly DRAFT (0), keep signer as DRAFT
                // This allows adding new signers in DRAFT mode even when file is not in DRAFT status
                if ($fileStatus === FileEntity::STATUS_DRAFT) {
                        return \OCA\Libresign\Enum\SignRequestStatus::DRAFT;
                }

                // If file status is ABLE_TO_SIGN, apply flow-based logic
                if ($fileStatus === FileEntity::STATUS_ABLE_TO_SIGN) {
                        if ($this->sequentialSigningService->isOrderedNumericFlow()) {
                                // In ordered flow, only first signer (order 1) should be ABLE_TO_SIGN
                                // Others remain DRAFT until their turn
                                return $signingOrder === 1
                                        ? \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN
                                        : \OCA\Libresign\Enum\SignRequestStatus::DRAFT;
                        }
                        // In parallel flow, all can sign - ignore individual signer status if file is ABLE_TO_SIGN
                        return \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;
                }

                // Handle explicit signer status when file status is not DRAFT or ABLE_TO_SIGN
                if ($signerStatus !== null) {
                        $desiredStatus = \OCA\Libresign\Enum\SignRequestStatus::from($signerStatus);
                        if ($currentStatus !== null && !$this->sequentialSigningService->isStatusUpgrade($currentStatus, $desiredStatus)) {
                                return $currentStatus;
                        }

                        // Validate status transition based on signing order
                        if ($fileId !== null) {
                                return $this->sequentialSigningService->validateStatusByOrder($desiredStatus, $signingOrder, $fileId);
                        }

                        return $desiredStatus;
                }

                // Default fallback based on flow type
                if (!$this->sequentialSigningService->isOrderedNumericFlow()) {
                        return \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;
                }

                return $signingOrder === 1
                        ? \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN
                        : \OCA\Libresign\Enum\SignRequestStatus::DRAFT;
        }

        /**
         * @param IIdentifyMethod[] $identifyMethodsIncances
         * @param string $displayName
         * @return string
         */
        private function getDisplayNameFromIdentifyMethodIfEmpty(array $identifyMethodsIncances, string $displayName): string {
                if (!empty($displayName)) {
                        return $displayName;
                }
                foreach ($identifyMethodsIncances as $identifyMethod) {
                        if ($identifyMethod->getName() === 'account') {
                                return $this->userManager->get($identifyMethod->getEntity()->getIdentifierValue())->getDisplayName();
                        }
                }
                foreach ($identifyMethodsIncances as $identifyMethod) {
                        if ($identifyMethod->getName() !== 'account') {
                                return $identifyMethod->getEntity()->getIdentifierValue();
                        }
                }
                return '';
        }

        private function saveVisibleElements(array $data, FileEntity $file): array {
                if (empty($data['visibleElements'])) {
                        return [];
                }
                $elements = $data['visibleElements'];
                foreach ($elements as $key => $element) {
                        $element['fileId'] = $file->getId();
                        $elements[$key] = $this->fileElementService->saveVisibleElement($element);
                }
                return $elements;
        }

        public function validateNewRequestToFile(array $data): void {
                $this->validateNewFile($data);
                $this->validateUsers($data);
                $this->validateHelper->validateFileStatus($data);
        }

        public function validateNewFile(array $data): void {
                if (empty($data['name'])) {
                        throw new \Exception($this->l10n->t('Name is mandatory'));
                }
                $this->validateHelper->validateNewFile($data);
        }

        public function validateUsers(array $data): void {
                if (empty($data['users'])) {
                        throw new \Exception($this->l10n->t('Empty users list'));
                }
                if (!is_array($data['users'])) {
                        // TRANSLATION This message will be displayed when the request to API with the key users has a value that is not an array
                        throw new \Exception($this->l10n->t('User list needs to be an array'));
                }
                foreach ($data['users'] as $user) {
                        if (!array_key_exists('identify', $user)) {
                                throw new \Exception('Identify key not found');
                        }
                        $this->identifyMethod->setAllEntityData($user);
                }
        }

        public function saveSignRequest(SignRequestEntity $signRequest): void {
                if ($signRequest->getId()) {
                        $this->signRequestMapper->update($signRequest);
                } else {
                        $this->signRequestMapper->insert($signRequest);
                }
        }

        /**
         * @psalm-suppress MixedMethodCall
         */
        private function setDataToUser(SignRequestEntity $signRequest, string $displayName, string $description, int $fileId): void {
                $signRequest->setFileId($fileId);
                if (!$signRequest->getUuid()) {
                        $signRequest->setUuid(UUIDUtil::getUUID());
                }
                if (!empty($displayName)) {
                        $signRequest->setDisplayName($displayName);
                }
                if (!empty($description)) {
                        $signRequest->setDescription($description);
                }
                if (!$signRequest->getId()) {
                        $signRequest->setCreatedAt(new \DateTime('now', new \DateTimeZone('UTC')));
                }
        }

        private function getSignRequestByIdentifyMethod(IIdentifyMethod $identifyMethod, int $fileId): SignRequestEntity {
                try {
                        $signRequest = $this->signRequestMapper->getByIdentifyMethodAndFileId($identifyMethod, $fileId);
                } catch (DoesNotExistException) {
                        $signRequest = new SignRequestEntity();
                }
                return $signRequest;
        }

        public function unassociateToUser(int $fileId, int $signRequestId): void {
                $signRequest = $this->signRequestMapper->getByFileIdAndSignRequestId($fileId, $signRequestId);
                $deletedOrder = $signRequest->getSigningOrder();
                $groupedIdentifyMethods = $this->identifyMethod->getIdentifyMethodsFromSignRequestId($signRequestId);

                $this->dispatchCancellationEventIfNeeded($signRequest, $fileId, $groupedIdentifyMethods);

                try {
                        $this->signRequestMapper->delete($signRequest);
                        foreach ($groupedIdentifyMethods as $identifyMethods) {
                                foreach ($identifyMethods as $identifyMethod) {
                                        $identifyMethod->delete();
                                }
                        }
                        $visibleElements = $this->fileElementMapper->getByFileIdAndSignRequestId($fileId, $signRequestId);
                        foreach ($visibleElements as $visibleElement) {
                                $this->fileElementMapper->delete($visibleElement);
                        }

                        $this->sequentialSigningService->reorderAfterDeletion($fileId, $deletedOrder);
                } catch (\Throwable) {
                }
        }

        private function dispatchCancellationEventIfNeeded(
                SignRequestEntity $signRequest,
                int $fileId,
                array $groupedIdentifyMethods,
        ): void {
                if ($signRequest->getStatus() !== \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN->value) {
                        return;
                }

                try {
                        $libreSignFile = $this->fileMapper->getByFileId($fileId);
                        foreach ($groupedIdentifyMethods as $identifyMethods) {
                                foreach ($identifyMethods as $identifyMethod) {
                                        $event = new SignRequestCanceledEvent(
                                                $signRequest,
                                                $libreSignFile,
                                                $identifyMethod,
                                        );
                                        $this->eventDispatcher->dispatchTyped($event);
                                }
                        }
                } catch (\Throwable $e) {
                        $this->logger->error('Error dispatching SignRequestCanceledEvent: ' . $e->getMessage(), ['exception' => $e]);
                }
        }

        public function deleteRequestSignature(array $data): void {
                if (!empty($data['uuid'])) {
                        $signatures = $this->signRequestMapper->getByFileUuid($data['uuid']);
                        $fileData = $this->fileMapper->getByUuid($data['uuid']);
                } elseif (!empty($data['file']['fileId'])) {
                        $signatures = $this->signRequestMapper->getByNodeId($data['file']['fileId']);
                        $fileData = $this->fileMapper->getByFileId($data['file']['fileId']);
                } else {
                        throw new \Exception($this->l10n->t('Please provide either UUID or File object'));
                }
                foreach ($signatures as $signRequest) {
                        $this->signRequestMapper->delete($signRequest);
                }
                $this->fileMapper->delete($fileData);
                $this->fileElementService->deleteVisibleElements($fileData->getId());
        }
}

1	<?php
2
3	declare(strict_types=1);
4	/**
5	* SPDX-FileCopyrightText: 2020-2024 LibreCode coop and contributors
6	* SPDX-License-Identifier: AGPL-3.0-or-later
7	*/
8
9	namespace OCA\Libresign\Service;
10
11	use OCA\Libresign\AppInfo\Application;
12	use OCA\Libresign\Db\File as FileEntity;
13	use OCA\Libresign\Db\FileElementMapper;
14	use OCA\Libresign\Db\FileMapper;
15	use OCA\Libresign\Db\IdentifyMethodMapper;
16	use OCA\Libresign\Db\SignRequest as SignRequestEntity;
17	use OCA\Libresign\Db\SignRequestMapper;
18	use OCA\Libresign\Enum\SignatureFlow;
19	use OCA\Libresign\Events\SignRequestCanceledEvent;
20	use OCA\Libresign\Handler\DocMdpHandler;
21	use OCA\Libresign\Helper\ValidateHelper;
22	use OCA\Libresign\Service\IdentifyMethod\IIdentifyMethod;
23	use OCP\AppFramework\Db\DoesNotExistException;
24	use OCP\EventDispatcher\IEventDispatcher;
25	use OCP\Files\IMimeTypeDetector;
26	use OCP\Files\Node;
27	use OCP\Http\Client\IClientService;
28	use OCP\IAppConfig;
29	use OCP\IL10N;
30	use OCP\IUser;
31	use OCP\IUserManager;
32	use Psr\Log\LoggerInterface;
33	use Sabre\DAV\UUIDUtil;
34
35	class RequestSignatureService {
36	use TFile;
37
38	public function __construct(
39	protected IL10N $l10n,
40	protected IdentifyMethodService $identifyMethod,
41	protected SignRequestMapper $signRequestMapper,
42	protected IUserManager $userManager,
43	protected FileMapper $fileMapper,
44	protected IdentifyMethodMapper $identifyMethodMapper,
45	protected PdfParserService $pdfParserService,
46	protected FileElementService $fileElementService,
47	protected FileElementMapper $fileElementMapper,
48	protected FolderService $folderService,
49	protected IMimeTypeDetector $mimeTypeDetector,
50	protected ValidateHelper $validateHelper,
51	protected IClientService $client,
52	protected DocMdpHandler $docMdpHandler,
53	protected LoggerInterface $logger,
54	protected SequentialSigningService $sequentialSigningService,
55	protected IAppConfig $appConfig,
56	protected IEventDispatcher $eventDispatcher,
57	) {
58	}	56✔
59
60	public function save(array $data): FileEntity {
61	$file = $this->saveFile($data);	14✔
62	$this->saveVisibleElements($data, $file);	14✔
63	if (!isset($data['status'])) {	14✔
64	$data['status'] = $file->getStatus();	12✔
65	}
66	$this->sequentialSigningService->setFile($file);	14✔
67	$this->associateToSigners($data, $file->getId());	14✔
68	return $file;	14✔
69	}
70
71	/**
72	* Save file data
73	*
74	* @param array{?userManager: IUser, ?signRequest: SignRequest, name: string, callback: string, uuid?: ?string, status: int, file?: array{fileId?: int, fileNode?: Node}} $data
75	*/
76	public function saveFile(array $data): FileEntity {
77	if (!empty($data['uuid'])) {	15✔
78	$file = $this->fileMapper->getByUuid($data['uuid']);	1✔
79	return $this->updateStatus($file, $data['status'] ?? 0);	1✔
80	}
81	$fileId = null;	15✔
82	if (isset($data['file']['fileNode']) && $data['file']['fileNode'] instanceof Node) {	15✔
83	$fileId = $data['file']['fileNode']->getId();	1✔
84	} elseif (!empty($data['file']['fileId'])) {	14✔
85	$fileId = $data['file']['fileId'];	×
86	}
87	if (!is_null($fileId)) {	15✔
88	try {
89	$file = $this->fileMapper->getByFileId($fileId);	1✔
90	return $this->updateStatus($file, $data['status'] ?? 0);	×
91	} catch (\Throwable) {	1✔
92	}
93	}
94
95	$node = $this->getNodeFromData($data);	15✔
96
97	$file = new FileEntity();	15✔
98	$file->setNodeId($node->getId());	15✔
99	if ($data['userManager'] instanceof IUser) {	15✔
100	$file->setUserId($data['userManager']->getUID());	15✔
101	} elseif ($data['signRequest'] instanceof SignRequestEntity) {	×
102	$file->setSignRequestId($data['signRequest']->getId());	×
103	}
104	$file->setUuid(UUIDUtil::getUUID());	15✔
105	$file->setCreatedAt(new \DateTime('now', new \DateTimeZone('UTC')));	15✔
106	$metadata = $this->getFileMetadata($node);	15✔
107	$file->setName($this->removeExtensionFromName($data['name'], $metadata));	15✔
108	$file->setMetadata($metadata);	15✔
109	if (!empty($data['callback'])) {	15✔
110	$file->setCallback($data['callback']);	×
111	}
112	if (isset($data['status'])) {	15✔
113	$file->setStatus($data['status']);	2✔
114	} else {
115	$file->setStatus(FileEntity::STATUS_ABLE_TO_SIGN);	13✔
116	}
117
118	if (isset($data['signatureFlow']) && is_string($data['signatureFlow'])) {	15✔
119	try {
120	$signatureFlow = \OCA\Libresign\Enum\SignatureFlow::from($data['signatureFlow']);	×
121	$file->setSignatureFlowEnum($signatureFlow);	×
122	} catch (\ValueError) {	×
123	$this->setSignatureFlowFromGlobalConfig($file);	×
124	}
125	} else {
126	$this->setSignatureFlowFromGlobalConfig($file);	15✔
127	}
128
129	$this->fileMapper->insert($file);	15✔
130	return $file;	15✔
131	}
132
133	private function setSignatureFlowFromGlobalConfig(FileEntity $file): void {
134	$globalFlowValue = $this->appConfig->getValueString(Application::APP_ID, 'signature_flow', SignatureFlow::PARALLEL->value);	15✔
135	$globalFlow = SignatureFlow::from($globalFlowValue);	15✔
136	$file->setSignatureFlowEnum($globalFlow);	15✔
137	}
138
139	private function updateStatus(FileEntity $file, int $status): FileEntity {
140	if ($status > $file->getStatus()) {	1✔
141	$file->setStatus($status);	×
142	/** @var FileEntity */
143	return $this->fileMapper->update($file);	×
144	}
145	return $file;	1✔
146	}
147
148	private function getFileMetadata(\OCP\Files\Node $node): array {
149	$metadata = [];	18✔
150	if ($extension = strtolower($node->getExtension())) {	18✔
151	$metadata = [	17✔
152	'extension' => $extension,	17✔
153	];	17✔
154	if ($metadata['extension'] === 'pdf') {	17✔
155	$metadata = array_merge(	16✔
156	$metadata,	16✔
157	$this->pdfParserService	16✔
158	->setFile($node)	16✔
159	->getPageDimensions()	16✔
160	);	16✔
161	}
162	}
163	return $metadata;	18✔
164	}
165
166	private function removeExtensionFromName(string $name, array $metadata): string {
167	if (!isset($metadata['extension'])) {	15✔
168	return $name;	×
169	}
170	$extensionPattern = '/\.' . preg_quote($metadata['extension'], '/') . '$/i';	15✔
171	$result = preg_replace($extensionPattern, '', $name);	15✔
172	return $result ?? $name;	15✔
173	}
174
175	private function deleteIdentifyMethodIfNotExits(array $users, int $fileId): void {
176	$file = $this->fileMapper->getById($fileId);	13✔
177	$signRequests = $this->signRequestMapper->getByFileId($fileId);	13✔
178	foreach ($signRequests as $key => $signRequest) {	13✔
179	$identifyMethods = $this->identifyMethod->getIdentifyMethodsFromSignRequestId($signRequest->getId());	1✔
180	if (empty($identifyMethods)) {	1✔
181	$this->unassociateToUser($file->getNodeId(), $signRequest->getId());	×
182	continue;	×
183	}
184	foreach ($identifyMethods as $methodName => $list) {	1✔
185	foreach ($list as $method) {	1✔
186	$exists[$key]['identify'][$methodName] = $method->getEntity()->getIdentifierValue();	1✔
187	if (!$this->identifyMethodExists($users, $method)) {	1✔
188	$this->unassociateToUser($file->getNodeId(), $signRequest->getId());	1✔
189	continue 3;	1✔
190	}
191	}
192	}
193	}
194	}
195
196	private function identifyMethodExists(array $users, IIdentifyMethod $identifyMethod): bool {
197	foreach ($users as $user) {	1✔
198	if (!empty($user['identifyMethods'])) {	1✔
199	foreach ($user['identifyMethods'] as $data) {	×
200	if ($identifyMethod->getEntity()->getIdentifierKey() !== $data['method']) {	×
201	continue;	×
202	}
203	if ($identifyMethod->getEntity()->getIdentifierValue() === $data['value']) {	×
204	return true;	×
205	}
206	}
207	} else {
208	foreach ($user['identify'] as $method => $value) {	1✔
209	if ($identifyMethod->getEntity()->getIdentifierKey() !== $method) {	1✔
210	continue;	×
211	}
212	if ($identifyMethod->getEntity()->getIdentifierValue() === $value) {	1✔
213	return true;	×
214	}
215	}
216	}
217	}
218	return false;	1✔
219	}
220
221	/**
222	* @return SignRequestEntity[]
223	*
224	* @psalm-return list<SignRequestEntity>
225	*/
226	private function associateToSigners(array $data, int $fileId): array {
227	$return = [];	14✔
228	if (!empty($data['users'])) {	14✔
229	$this->deleteIdentifyMethodIfNotExits($data['users'], $fileId);	13✔
230
231	$this->sequentialSigningService->resetOrderCounter();	13✔
232	$fileStatus = $data['status'] ?? null;	13✔
233
234	foreach ($data['users'] as $user) {	13✔
235	$userProvidedOrder = isset($user['signingOrder']) ? (int)$user['signingOrder'] : null;	13✔
236	$signingOrder = $this->sequentialSigningService->determineSigningOrder($userProvidedOrder);	13✔
237	$signerStatus = $user['status'] ?? null;	13✔
238
239	if (isset($user['identifyMethods'])) {	13✔
240	foreach ($user['identifyMethods'] as $identifyMethod) {	×
241	$return[] = $this->associateToSigner(	×
242	identifyMethods: [	×
243	$identifyMethod['method'] => $identifyMethod['value'],	×
244	],	×
245	displayName: $user['displayName'] ?? '',	×
246	description: $user['description'] ?? '',	×
247	notify: empty($user['notify']) && $this->isStatusAbleToNotify($fileStatus),	×
248	fileId: $fileId,	×
249	signingOrder: $signingOrder,	×
250	fileStatus: $fileStatus,	×
251	signerStatus: $signerStatus,	×
252	);	×
253	}
254	} else {
255	$return[] = $this->associateToSigner(	13✔
256	identifyMethods: $user['identify'],	13✔
257	displayName: $user['displayName'] ?? '',	13✔
258	description: $user['description'] ?? '',	13✔
259	notify: empty($user['notify']) && $this->isStatusAbleToNotify($fileStatus),	13✔
260	fileId: $fileId,	13✔
261	signingOrder: $signingOrder,	13✔
262	fileStatus: $fileStatus,	13✔
263	signerStatus: $signerStatus,	13✔
264	);	13✔
265	}
266	}
267	}
268	return $return;	14✔
269	}
270
271	private function isStatusAbleToNotify(?int $status): bool {
272	return in_array($status, [	13✔
273	FileEntity::STATUS_ABLE_TO_SIGN,	13✔
274	FileEntity::STATUS_PARTIAL_SIGNED,	13✔
275	]);	13✔
276	}
277
278	private function associateToSigner(
279	array $identifyMethods,
280	string $displayName,
281	string $description,
282	bool $notify,
283	int $fileId,
284	int $signingOrder = 0,
285	?int $fileStatus = null,
286	?int $signerStatus = null,
287	): SignRequestEntity {
288	$identifyMethodsIncances = $this->identifyMethod->getByUserData($identifyMethods);	13✔
289	if (empty($identifyMethodsIncances)) {	13✔
290	throw new \Exception($this->l10n->t('Invalid identification method'));	×
291	}
292	$signRequest = $this->getSignRequestByIdentifyMethod(	13✔
293	current($identifyMethodsIncances),	13✔
294	$fileId	13✔
295	);	13✔
296	$displayName = $this->getDisplayNameFromIdentifyMethodIfEmpty($identifyMethodsIncances, $displayName);	13✔
297	$this->setDataToUser($signRequest, $displayName, $description, $fileId);	13✔
298
299	$signRequest->setSigningOrder($signingOrder);	13✔
300
301	$isNewSignRequest = !$signRequest->getId();	13✔
302	$currentStatus = $signRequest->getStatusEnum();	13✔
303
304	if ($isNewSignRequest \|\| $currentStatus === \OCA\Libresign\Enum\SignRequestStatus::DRAFT) {	13✔
305	$desiredStatus = $this->determineInitialStatus($signingOrder, $fileStatus, $signerStatus, $currentStatus, $fileId);	13✔
306	$this->updateStatusIfAllowed($signRequest, $currentStatus, $desiredStatus, $isNewSignRequest);	13✔
307	}
308
309	$this->saveSignRequest($signRequest);	13✔
310
311	$shouldNotify = $notify && $signRequest->getStatusEnum() === \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;	13✔
312
313	foreach ($identifyMethodsIncances as $identifyMethod) {	13✔
314	$identifyMethod->getEntity()->setSignRequestId($signRequest->getId());	13✔
315	$identifyMethod->willNotifyUser($shouldNotify);	13✔
316	$identifyMethod->save();	13✔
317	}
318	return $signRequest;	13✔
319	}
320
321	private function updateStatusIfAllowed(
322	SignRequestEntity $signRequest,
323	\OCA\Libresign\Enum\SignRequestStatus $currentStatus,
324	\OCA\Libresign\Enum\SignRequestStatus $desiredStatus,
325	bool $isNewSignRequest,
326	): void {
327	if ($isNewSignRequest \|\| $this->sequentialSigningService->isStatusUpgrade($currentStatus, $desiredStatus)) {	13✔
328	$signRequest->setStatusEnum($desiredStatus);	13✔
329	}
330	}
331
332	private function determineInitialStatus(
333	int $signingOrder,
334	?int $fileStatus = null,
335	?int $signerStatus = null,
336	?\OCA\Libresign\Enum\SignRequestStatus $currentStatus = null,
337	?int $fileId = null,
338	): \OCA\Libresign\Enum\SignRequestStatus {
339	// If fileStatus is explicitly DRAFT (0), keep signer as DRAFT
340	// This allows adding new signers in DRAFT mode even when file is not in DRAFT status
341	if ($fileStatus === FileEntity::STATUS_DRAFT) {	15✔
342	return \OCA\Libresign\Enum\SignRequestStatus::DRAFT;	×
343	}
344
345	// If file status is ABLE_TO_SIGN, apply flow-based logic
346	if ($fileStatus === FileEntity::STATUS_ABLE_TO_SIGN) {	15✔
347	if ($this->sequentialSigningService->isOrderedNumericFlow()) {	15✔
348	// In ordered flow, only first signer (order 1) should be ABLE_TO_SIGN
349	// Others remain DRAFT until their turn
350	return $signingOrder === 1	1✔
351	? \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN	1✔
352	: \OCA\Libresign\Enum\SignRequestStatus::DRAFT;	1✔
353	}
354	// In parallel flow, all can sign - ignore individual signer status if file is ABLE_TO_SIGN
355	return \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;	14✔
356	}
357
358	// Handle explicit signer status when file status is not DRAFT or ABLE_TO_SIGN
359	if ($signerStatus !== null) {	×
360	$desiredStatus = \OCA\Libresign\Enum\SignRequestStatus::from($signerStatus);	×
361	if ($currentStatus !== null && !$this->sequentialSigningService->isStatusUpgrade($currentStatus, $desiredStatus)) {	×
362	return $currentStatus;	×
363	}
364
365	// Validate status transition based on signing order
366	if ($fileId !== null) {	×
367	return $this->sequentialSigningService->validateStatusByOrder($desiredStatus, $signingOrder, $fileId);	×
368	}
369
370	return $desiredStatus;	×
371	}
372
373	// Default fallback based on flow type
374	if (!$this->sequentialSigningService->isOrderedNumericFlow()) {	×
375	return \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN;	×
376	}
377
378	return $signingOrder === 1	×
379	? \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN	×
380	: \OCA\Libresign\Enum\SignRequestStatus::DRAFT;	×
381	}
382
383	/**
384	* @param IIdentifyMethod[] $identifyMethodsIncances
385	* @param string $displayName
386	* @return string
387	*/
388	private function getDisplayNameFromIdentifyMethodIfEmpty(array $identifyMethodsIncances, string $displayName): string {
389	if (!empty($displayName)) {	13✔
390	return $displayName;	×
391	}
392	foreach ($identifyMethodsIncances as $identifyMethod) {	13✔
393	if ($identifyMethod->getName() === 'account') {	13✔
394	return $this->userManager->get($identifyMethod->getEntity()->getIdentifierValue())->getDisplayName();	2✔
395	}
396	}
397	foreach ($identifyMethodsIncances as $identifyMethod) {	11✔
398	if ($identifyMethod->getName() !== 'account') {	11✔
399	return $identifyMethod->getEntity()->getIdentifierValue();	11✔
400	}
401	}
402	return '';	×
403	}
404
405	private function saveVisibleElements(array $data, FileEntity $file): array {
406	if (empty($data['visibleElements'])) {	17✔
407	return [];	15✔
408	}
409	$elements = $data['visibleElements'];	2✔
410	foreach ($elements as $key => $element) {	2✔
411	$element['fileId'] = $file->getId();	2✔
412	$elements[$key] = $this->fileElementService->saveVisibleElement($element);	2✔
413	}
414	return $elements;	2✔
415	}
416
417	public function validateNewRequestToFile(array $data): void {
418	$this->validateNewFile($data);	7✔
419	$this->validateUsers($data);	6✔
420	$this->validateHelper->validateFileStatus($data);	2✔
421	}
422
423	public function validateNewFile(array $data): void {
424	if (empty($data['name'])) {	7✔
425	throw new \Exception($this->l10n->t('Name is mandatory'));	1✔
426	}
427	$this->validateHelper->validateNewFile($data);	6✔
428	}
429
430	public function validateUsers(array $data): void {
431	if (empty($data['users'])) {	6✔
432	throw new \Exception($this->l10n->t('Empty users list'));	3✔
433	}
434	if (!is_array($data['users'])) {	3✔
435	// TRANSLATION This message will be displayed when the request to API with the key users has a value that is not an array
436	throw new \Exception($this->l10n->t('User list needs to be an array'));	1✔
437	}
438	foreach ($data['users'] as $user) {	2✔
439	if (!array_key_exists('identify', $user)) {	2✔
440	throw new \Exception('Identify key not found');	×
441	}
442	$this->identifyMethod->setAllEntityData($user);	2✔
443	}
444	}
445
446	public function saveSignRequest(SignRequestEntity $signRequest): void {
447	if ($signRequest->getId()) {	15✔
448	$this->signRequestMapper->update($signRequest);	1✔
449	} else {
450	$this->signRequestMapper->insert($signRequest);	14✔
451	}
452	}
453
454	/**
455	* @psalm-suppress MixedMethodCall
456	*/
457	private function setDataToUser(SignRequestEntity $signRequest, string $displayName, string $description, int $fileId): void {
458	$signRequest->setFileId($fileId);	13✔
459	if (!$signRequest->getUuid()) {	13✔
460	$signRequest->setUuid(UUIDUtil::getUUID());	13✔
461	}
462	if (!empty($displayName)) {	13✔
463	$signRequest->setDisplayName($displayName);	13✔
464	}
465	if (!empty($description)) {	13✔
466	$signRequest->setDescription($description);	×
467	}
468	if (!$signRequest->getId()) {	13✔
469	$signRequest->setCreatedAt(new \DateTime('now', new \DateTimeZone('UTC')));	13✔
470	}
471	}
472
473	private function getSignRequestByIdentifyMethod(IIdentifyMethod $identifyMethod, int $fileId): SignRequestEntity {
474	try {
475	$signRequest = $this->signRequestMapper->getByIdentifyMethodAndFileId($identifyMethod, $fileId);	13✔
476	} catch (DoesNotExistException) {	13✔
477	$signRequest = new SignRequestEntity();	13✔
478	}
479	return $signRequest;	13✔
480	}
481
482	public function unassociateToUser(int $fileId, int $signRequestId): void {
483	$signRequest = $this->signRequestMapper->getByFileIdAndSignRequestId($fileId, $signRequestId);	2✔
484	$deletedOrder = $signRequest->getSigningOrder();	2✔
485	$groupedIdentifyMethods = $this->identifyMethod->getIdentifyMethodsFromSignRequestId($signRequestId);	2✔
486
487	$this->dispatchCancellationEventIfNeeded($signRequest, $fileId, $groupedIdentifyMethods);	2✔
488
489	try {
490	$this->signRequestMapper->delete($signRequest);	2✔
491	foreach ($groupedIdentifyMethods as $identifyMethods) {	2✔
492	foreach ($identifyMethods as $identifyMethod) {	2✔
493	$identifyMethod->delete();	2✔
494	}
495	}
496	$visibleElements = $this->fileElementMapper->getByFileIdAndSignRequestId($fileId, $signRequestId);	2✔
497	foreach ($visibleElements as $visibleElement) {	2✔
498	$this->fileElementMapper->delete($visibleElement);	×
499	}
500
501	$this->sequentialSigningService->reorderAfterDeletion($fileId, $deletedOrder);	2✔
502	} catch (\Throwable) {	×
503	}
504	}
505
506	private function dispatchCancellationEventIfNeeded(
507	SignRequestEntity $signRequest,
508	int $fileId,
509	array $groupedIdentifyMethods,
510	): void {
511	if ($signRequest->getStatus() !== \OCA\Libresign\Enum\SignRequestStatus::ABLE_TO_SIGN->value) {	2✔
NEW 512	return;	×
513	}
514
515	try {
516	$libreSignFile = $this->fileMapper->getByFileId($fileId);	2✔
517	foreach ($groupedIdentifyMethods as $identifyMethods) {	2✔
518	foreach ($identifyMethods as $identifyMethod) {	2✔
519	$event = new SignRequestCanceledEvent(	2✔
520	$signRequest,	2✔
521	$libreSignFile,	2✔
522	$identifyMethod,	2✔
523	);	2✔
524	$this->eventDispatcher->dispatchTyped($event);	2✔
525	}
526	}
NEW 527	} catch (\Throwable $e) {	×
NEW 528	$this->logger->error('Error dispatching SignRequestCanceledEvent: ' . $e->getMessage(), ['exception' => $e]);	×
529	}
530	}
531
532	public function deleteRequestSignature(array $data): void {
533	if (!empty($data['uuid'])) {	2✔
534	$signatures = $this->signRequestMapper->getByFileUuid($data['uuid']);	×
535	$fileData = $this->fileMapper->getByUuid($data['uuid']);	×
536	} elseif (!empty($data['file']['fileId'])) {	2✔
537	$signatures = $this->signRequestMapper->getByNodeId($data['file']['fileId']);	2✔
538	$fileData = $this->fileMapper->getByFileId($data['file']['fileId']);	2✔
539	} else {
540	throw new \Exception($this->l10n->t('Please provide either UUID or File object'));	×
541	}
542	foreach ($signatures as $signRequest) {	2✔
543	$this->signRequestMapper->delete($signRequest);	2✔
544	}
545	$this->fileMapper->delete($fileData);	2✔
546	$this->fileElementService->deleteVisibleElements($fileData->getId());	2✔
547	}
548	}

LibreSign / libresign / 20210417471

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous