22047397566

Committed 16 Feb 2026 01:47AM UTC coverage: 51.605%. First build

Build # 22047397566

Build Type

Pull #6891

github

Committed by

web-flow

Commit Message

Merge cc204601c into bdac9dc51

Pull Request Pull Request #6891: feat: add id doc approver workflow

Run Details

171 of 424 new or added lines in 24 files covered. (40.33%)

9145 of 17721 relevant lines covered (51.61%)

6.15 hits per line

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

51.16

/lib/Service/IdDocsService.php

<?php

declare(strict_types=1);
/**
 * SPDX-FileCopyrightText: 2025 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\FileMapper;
use OCA\Libresign\Db\FileTypeMapper;
use OCA\Libresign\Db\IdDocsMapper;
use OCA\Libresign\Db\IdentifyMethod;
use OCA\Libresign\Db\IdentifyMethodMapper;
use OCA\Libresign\Db\SignRequest;
use OCA\Libresign\Db\SignRequest as SignRequestEntity;
use OCA\Libresign\Db\SignRequestMapper;
use OCA\Libresign\Exception\LibresignException;
use OCA\Libresign\Helper\ValidateHelper;
use OCP\AppFramework\Utility\ITimeFactory;
use OCP\IAppConfig;
use OCP\IL10N;
use OCP\IUser;
use Sabre\DAV\UUIDUtil;

class IdDocsService {

        public function __construct(
                private IL10N $l10n,
                private FileTypeMapper $fileTypeMapper,
                private ValidateHelper $validateHelper,
                private RequestSignatureService $requestSignatureService,
                private IdDocsMapper $idDocsMapper,
                private FileMapper $fileMapper,
                private SignRequestMapper $signRequestMapper,
                private IdentifyMethodMapper $identifyMethodMapper,
                private ITimeFactory $timeFactory,
                private IAppConfig $appConfig,
        ) {
        }

        private function validateTypeOfFile(int $fileIndex, array $file): void {
                $profileFileTypes = $this->fileTypeMapper->getTypes();
                if (!array_key_exists($file['type'], $profileFileTypes)) {
                        throw new LibresignException(json_encode([
                                'type' => 'danger',
                                'file' => $fileIndex,
                                'message' => $this->l10n->t('Invalid file type.')
                        ]));
                }
        }

        private function validateIdDoc(int $fileIndex, array $file, IUser $user): void {
                $profileFileTypes = $this->fileTypeMapper->getTypes();
                if (!array_key_exists($file['type'], $profileFileTypes)) {
                        throw new LibresignException(json_encode([
                                'type' => 'danger',
                                'file' => $fileIndex,
                                'message' => $this->l10n->t('Invalid file type.')
                        ]));
                }

                try {
                        $this->validateHelper->validateFileTypeExists($file['type']);
                        $this->validateHelper->validateNewFile($file, ValidateHelper::TYPE_ACCOUNT_DOCUMENT, $user);
                        $this->validateHelper->validateUserHasNoFileWithThisType($user->getUID(), $file['type']);
                } catch (\Exception $e) {
                        throw new LibresignException(json_encode([
                                'type' => 'danger',
                                'file' => $fileIndex,
                                'message' => $e->getMessage()
                        ]));
                }
        }

        public function validateIdDocs(array $files, IUser $user): void {
                foreach ($files as $fileIndex => $file) {
                        $this->validateTypeOfFile($fileIndex, $file);
                        $this->validateIdDoc($fileIndex, $file, $user);
                }
        }

        public function addIdDocs(array $files, IUser $user): void {
                $this->validateIdDocs($files, $user);
                foreach ($files as $fileData) {
                        $dataToSave = $fileData;
                        $dataToSave['userManager'] = $user;
                        $dataToSave['name'] = $fileData['name'] ?? $fileData['type'];
                        $file = $this->requestSignatureService->saveFile($dataToSave);

                        $signRequest = new SignRequestEntity();
                        $signRequest->setFileId($file->getId());
                        $signRequest->setDisplayName($user->getDisplayName());
                        $signRequest->setUuid(UUIDUtil::getUUID());
                        $signRequest->setCreatedAt($this->timeFactory->getDateTime());
                        $this->signRequestMapper->insert($signRequest);

                        $identifyMethod = new IdentifyMethod();
                        $identifyMethod->setSignRequestId($signRequest->getId());
                        $identifyMethod->setIdentifierKey(IdentifyMethodService::IDENTIFY_ACCOUNT);
                        $identifyMethod->setIdentifierValue($user->getUID());
                        $identifyMethod->setMandatory(1);
                        $this->identifyMethodMapper->insert($identifyMethod);

                        $this->idDocsMapper->save($file->getId(), $signRequest->getId(), $user->getUID(), $fileData['type']);
                }
        }

        public function addFilesToDocumentFolder(
                array $files,
                SignRequest $signRequest,
        ): void {
                foreach ($files as $fileIndex => $file) {
                        $this->validateTypeOfFile($fileIndex, $file);
                }
                foreach ($files as $fileData) {
                        $dataToSave = $fileData;
                        $dataToSave['signRequest'] = $signRequest;
                        $dataToSave['name'] = $fileData['name'] ?? $fileData['type'];
                        $file = $this->requestSignatureService->saveFile($dataToSave);

                        $this->idDocsMapper->save($file->getId(), $signRequest->getId(), null, $fileData['type']);
                }
        }

        public function list(array $filter, ?int $page = null, ?int $length = null, array $sort = []): array {
                $page = $page ?? 1;
                $length = $length ?? (int)$this->appConfig->getValueInt(Application::APP_ID, 'length_of_page', 100);
                $data = $this->idDocsMapper->list($filter, $page, $length, $sort);
                $data['pagination']->setRouteName('ocs.libresign.File.list');
                $pagination = $data['pagination']->getPagination($page, $length, $filter);
                return [
                        'data' => $data['data'],
                        'pagination' => $pagination,
                ];
        }

        public function deleteIdDoc(int $nodeId, IUser $user): void {
                if ($this->validateHelper->userCanApproveValidationDocuments($user, false)) {
                        $idDocs = $this->idDocsMapper->getByNodeId($nodeId);
                } else {
                        $this->validateHelper->validateIdDocIsOwnedByUser($nodeId, $user->getUID());
                        $idDocs = $this->idDocsMapper->getByUserIdAndNodeId($user->getUID(), $nodeId);
                }
                $this->idDocsMapper->delete($idDocs);
                $file = $this->fileMapper->getById($idDocs->getFileId());
                $this->fileMapper->delete($file);
        }

        public function deleteIdDocBySignRequest(int $nodeId, SignRequest $signRequest): void {
                $this->validateHelper->validateIdDocBelongsToSignRequest($nodeId, $signRequest->getId());
                $idDocs = $this->idDocsMapper->getBySignRequestIdAndNodeId($signRequest->getId(), $nodeId);
                $this->idDocsMapper->delete($idDocs);
                $file = $this->fileMapper->getById($idDocs->getFileId());
                $this->fileMapper->delete($file);
        }

        public function getIdDocsByUser(IUser $user): array {
                $idDocs = $this->idDocsMapper->getByUserId($user->getUID());
                $files = [];
                foreach ($idDocs as $idDoc) {
                        $file = $this->fileMapper->getById($idDoc->getFileId());
                        $files[] = [
                                'nodeId' => $file->getNodeId(),
                                'fileId' => $idDoc->getFileId(),
                                'type' => $idDoc->getFileType(),
                                'name' => $file->getName(),
                        ];
                }
                return $files;
        }
}

1	<?php
2
3	declare(strict_types=1);
4	/**
5	* SPDX-FileCopyrightText: 2025 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\FileMapper;
13	use OCA\Libresign\Db\FileTypeMapper;
14	use OCA\Libresign\Db\IdDocsMapper;
15	use OCA\Libresign\Db\IdentifyMethod;
16	use OCA\Libresign\Db\IdentifyMethodMapper;
17	use OCA\Libresign\Db\SignRequest;
18	use OCA\Libresign\Db\SignRequest as SignRequestEntity;
19	use OCA\Libresign\Db\SignRequestMapper;
20	use OCA\Libresign\Exception\LibresignException;
21	use OCA\Libresign\Helper\ValidateHelper;
22	use OCP\AppFramework\Utility\ITimeFactory;
23	use OCP\IAppConfig;
24	use OCP\IL10N;
25	use OCP\IUser;
26	use Sabre\DAV\UUIDUtil;
27
28	class IdDocsService {
29
30	public function __construct(
31	private IL10N $l10n,
32	private FileTypeMapper $fileTypeMapper,
33	private ValidateHelper $validateHelper,
34	private RequestSignatureService $requestSignatureService,
35	private IdDocsMapper $idDocsMapper,
36	private FileMapper $fileMapper,
37	private SignRequestMapper $signRequestMapper,
38	private IdentifyMethodMapper $identifyMethodMapper,
39	private ITimeFactory $timeFactory,
40	private IAppConfig $appConfig,
41	) {
42	}	24✔
43
44	private function validateTypeOfFile(int $fileIndex, array $file): void {
45	$profileFileTypes = $this->fileTypeMapper->getTypes();	2✔
46	if (!array_key_exists($file['type'], $profileFileTypes)) {	2✔
47	throw new LibresignException(json_encode([	1✔
48	'type' => 'danger',	1✔
49	'file' => $fileIndex,	1✔
50	'message' => $this->l10n->t('Invalid file type.')	1✔
51	]));	1✔
52	}
53	}
54
55	private function validateIdDoc(int $fileIndex, array $file, IUser $user): void {
56	$profileFileTypes = $this->fileTypeMapper->getTypes();	1✔
57	if (!array_key_exists($file['type'], $profileFileTypes)) {	1✔
58	throw new LibresignException(json_encode([	×
59	'type' => 'danger',	×
60	'file' => $fileIndex,	×
61	'message' => $this->l10n->t('Invalid file type.')	×
62	]));	×
63	}
64
65	try {
66	$this->validateHelper->validateFileTypeExists($file['type']);	1✔
67	$this->validateHelper->validateNewFile($file, ValidateHelper::TYPE_ACCOUNT_DOCUMENT, $user);	1✔
68	$this->validateHelper->validateUserHasNoFileWithThisType($user->getUID(), $file['type']);	1✔
69	} catch (\Exception $e) {	×
70	throw new LibresignException(json_encode([	×
71	'type' => 'danger',	×
72	'file' => $fileIndex,	×
73	'message' => $e->getMessage()	×
74	]));	×
75	}
76	}
77
78	public function validateIdDocs(array $files, IUser $user): void {
79	foreach ($files as $fileIndex => $file) {	2✔
80	$this->validateTypeOfFile($fileIndex, $file);	2✔
81	$this->validateIdDoc($fileIndex, $file, $user);	1✔
82	}
83	}
84
85	public function addIdDocs(array $files, IUser $user): void {
86	$this->validateIdDocs($files, $user);	2✔
87	foreach ($files as $fileData) {	1✔
88	$dataToSave = $fileData;	1✔
89	$dataToSave['userManager'] = $user;	1✔
90	$dataToSave['name'] = $fileData['name'] ?? $fileData['type'];	1✔
91	$file = $this->requestSignatureService->saveFile($dataToSave);	1✔
92
93	$signRequest = new SignRequestEntity();	1✔
94	$signRequest->setFileId($file->getId());	1✔
95	$signRequest->setDisplayName($user->getDisplayName());	1✔
96	$signRequest->setUuid(UUIDUtil::getUUID());	1✔
97	$signRequest->setCreatedAt($this->timeFactory->getDateTime());	1✔
98	$this->signRequestMapper->insert($signRequest);	1✔
99
100	$identifyMethod = new IdentifyMethod();	1✔
101	$identifyMethod->setSignRequestId($signRequest->getId());	1✔
102	$identifyMethod->setIdentifierKey(IdentifyMethodService::IDENTIFY_ACCOUNT);	1✔
103	$identifyMethod->setIdentifierValue($user->getUID());	1✔
104	$identifyMethod->setMandatory(1);	1✔
105	$this->identifyMethodMapper->insert($identifyMethod);	1✔
106
107	$this->idDocsMapper->save($file->getId(), $signRequest->getId(), $user->getUID(), $fileData['type']);	1✔
108	}
109	}
110
111	public function addFilesToDocumentFolder(
112	array $files,
113	SignRequest $signRequest,
114	): void {
115	foreach ($files as $fileIndex => $file) {	×
116	$this->validateTypeOfFile($fileIndex, $file);	×
117	}
118	foreach ($files as $fileData) {	×
119	$dataToSave = $fileData;	×
120	$dataToSave['signRequest'] = $signRequest;	×
121	$dataToSave['name'] = $fileData['name'] ?? $fileData['type'];	×
122	$file = $this->requestSignatureService->saveFile($dataToSave);	×
123
124	$this->idDocsMapper->save($file->getId(), $signRequest->getId(), null, $fileData['type']);	×
125	}
126	}
127
128	public function list(array $filter, ?int $page = null, ?int $length = null, array $sort = []): array {
129	$page = $page ?? 1;	1✔
130	$length = $length ?? (int)$this->appConfig->getValueInt(Application::APP_ID, 'length_of_page', 100);	1✔
131	$data = $this->idDocsMapper->list($filter, $page, $length, $sort);	1✔
132	$data['pagination']->setRouteName('ocs.libresign.File.list');	1✔
133	$pagination = $data['pagination']->getPagination($page, $length, $filter);	1✔
134	return [	1✔
135	'data' => $data['data'],	1✔
136	'pagination' => $pagination,	1✔
137	];	1✔
138	}
139
140	public function deleteIdDoc(int $nodeId, IUser $user): void {
NEW 141	if ($this->validateHelper->userCanApproveValidationDocuments($user, false)) {	×
NEW 142	$idDocs = $this->idDocsMapper->getByNodeId($nodeId);	×
143	} else {
NEW 144	$this->validateHelper->validateIdDocIsOwnedByUser($nodeId, $user->getUID());	×
NEW 145	$idDocs = $this->idDocsMapper->getByUserIdAndNodeId($user->getUID(), $nodeId);	×
146	}
NEW 147	$this->idDocsMapper->delete($idDocs);	×
NEW 148	$file = $this->fileMapper->getById($idDocs->getFileId());	×
NEW 149	$this->fileMapper->delete($file);	×
150	}
151
152	public function deleteIdDocBySignRequest(int $nodeId, SignRequest $signRequest): void {
NEW 153	$this->validateHelper->validateIdDocBelongsToSignRequest($nodeId, $signRequest->getId());	×
NEW 154	$idDocs = $this->idDocsMapper->getBySignRequestIdAndNodeId($signRequest->getId(), $nodeId);	×
155	$this->idDocsMapper->delete($idDocs);	×
156	$file = $this->fileMapper->getById($idDocs->getFileId());	×
157	$this->fileMapper->delete($file);	×
158	}
159
160	public function getIdDocsByUser(IUser $user): array {
161	$idDocs = $this->idDocsMapper->getByUserId($user->getUID());	×
162	$files = [];	×
163	foreach ($idDocs as $idDoc) {	×
164	$file = $this->fileMapper->getById($idDoc->getFileId());	×
165	$files[] = [	×
166	'nodeId' => $file->getNodeId(),	×
167	'fileId' => $idDoc->getFileId(),	×
168	'type' => $idDoc->getFileType(),	×
169	'name' => $file->getName(),	×
170	];	×
171	}
172	return $files;	×
173	}
174	}

LibreSign / libresign / 22047397566

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