19875236052

Committed 02 Dec 2025 10:12PM UTC coverage: 41.686%. First build

Build # 19875236052

Build Type

Pull #4464

github

Committed by

web-flow

Commit Message

Merge 8eae8d550 into da0973853

Pull Request Pull Request #4464: refactor: attach document

Run Details

113 of 256 new or added lines in 15 files covered. (44.14%)

5122 of 12287 relevant lines covered (41.69%)

4.18 hits per line

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

55.13

/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 OCA\Libresign\Service\IdentifyMethodService;
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(true);
                        $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 {
                $page = $page ?? 1;
                $length = $length ?? (int)$this->appConfig->getValueInt(Application::APP_ID, 'length_of_page', 100);
                $data = $this->idDocsMapper->list($filter, $page, $length);
                $data['pagination']->setRouteName('ocs.libresign.File.list');
                return [
                        'data' => $data['data'],
                        'pagination' => $data['pagination']->getPagination($page, $length, $filter)
                ];
        }

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

LibreSign / libresign / 19875236052

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