19878986893

Committed 03 Dec 2025 01:16AM UTC coverage: 41.576%. First build

Build # 19878986893

Build Type

Pull #4464

github

Committed by

web-flow

Commit Message

Merge 3ee0f466e into da0973853

Pull Request Pull Request #4464: refactor: attach document

Run Details

117 of 302 new or added lines in 16 files covered. (38.74%)

5123 of 12322 relevant lines covered (41.58%)

4.17 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 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 {
                $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 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	}	31✔
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✔
NEW 58	throw new LibresignException(json_encode([	×
NEW 59	'type' => 'danger',	×
NEW 60	'file' => $fileIndex,	×
NEW 61	'message' => $this->l10n->t('Invalid file type.')	×
NEW 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✔
NEW 69	} catch (\Exception $e) {	×
NEW 70	throw new LibresignException(json_encode([	×
NEW 71	'type' => 'danger',	×
NEW 72	'file' => $fileIndex,	×
NEW 73	'message' => $e->getMessage()	×
NEW 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(array $files, SignRequest $signRequest): void {
NEW 112	foreach ($files as $fileIndex => $file) {	×
NEW 113	$this->validateTypeOfFile($fileIndex, $file);	×
114	}
NEW 115	foreach ($files as $fileData) {	×
NEW 116	$dataToSave = $fileData;	×
NEW 117	$dataToSave['signRequest'] = $signRequest;	×
NEW 118	$dataToSave['name'] = $fileData['name'] ?? $fileData['type'];	×
NEW 119	$file = $this->requestSignatureService->saveFile($dataToSave);	×
120
NEW 121	$this->idDocsMapper->save($file->getId(), $signRequest->getId(), null, $fileData['type']);	×
122	}
123	}
124
125	public function list(array $filter, ?int $page = null, ?int $length = null): array {
126	$page = $page ?? 1;	1✔
127	$length = $length ?? (int)$this->appConfig->getValueInt(Application::APP_ID, 'length_of_page', 100);	1✔
128	$data = $this->idDocsMapper->list($filter, $page, $length);	1✔
129	$data['pagination']->setRouteName('ocs.libresign.File.list');	1✔
130	return [	1✔
131	'data' => $data['data'],	1✔
132	'pagination' => $data['pagination']->getPagination($page, $length, $filter)	1✔
133	];	1✔
134	}
135
136	public function deleteIdDoc(int $nodeId, IUser $user): void {
NEW 137	$this->validateHelper->validateIdDocIsOwnedByUser($nodeId, $user->getUID());	×
NEW 138	$idDocs = $this->idDocsMapper->getByUserIdAndNodeId($user->getUID(), $nodeId);	×
NEW 139	$this->idDocsMapper->delete($idDocs);	×
NEW 140	$file = $this->fileMapper->getById($idDocs->getFileId());	×
NEW 141	$this->fileMapper->delete($file);	×
142	}
143
144	public function getIdDocsByUser(IUser $user): array {
NEW 145	$idDocs = $this->idDocsMapper->getByUserId($user->getUID());	×
NEW 146	$files = [];	×
NEW 147	foreach ($idDocs as $idDoc) {	×
NEW 148	$file = $this->fileMapper->getById($idDoc->getFileId());	×
NEW 149	$files[] = [	×
NEW 150	'nodeId' => $file->getNodeId(),	×
NEW 151	'fileId' => $idDoc->getFileId(),	×
NEW 152	'type' => $idDoc->getFileType(),	×
NEW 153	'name' => $file->getName(),	×
NEW 154	];	×
155	}
NEW 156	return $files;	×
157	}
158	}

LibreSign / libresign / 19878986893

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