21182715382

Committed 20 Jan 2026 06:23PM UTC coverage: 44.208%. First build

Build # 21182715382

Build Type

Pull #6243

github

Committed by

web-flow

Commit Message

Merge e224ea5b9 into ec977726d

Pull Request Pull Request #6243: feat: unified search

Run Details

4 of 86 new or added lines in 2 files covered. (4.65%)

7037 of 15918 relevant lines covered (44.21%)

4.92 hits per line

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

48.6

/lib/Db/SignRequestMapper.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\Db;

use OCA\Libresign\Enum\FileStatus;
use OCA\Libresign\Enum\SignRequestStatus;
use OCA\Libresign\Helper\Pagination;
use OCA\Libresign\Service\IdentifyMethod\IIdentifyMethod;
use OCA\Libresign\Service\IdentifyMethodService;
use OCP\AppFramework\Db\DoesNotExistException;
use OCP\AppFramework\Db\Entity;
use OCP\AppFramework\Db\QBMapper;
use OCP\DB\QueryBuilder\IQueryBuilder;
use OCP\IDBConnection;
use OCP\IL10N;
use OCP\IURLGenerator;
use OCP\IUser;

/**
 * Class SignRequestMapper
 *
 * @package OCA\Libresign\DB
 * @template-extends QBMapper<SignRequest>
 */
class SignRequestMapper extends QBMapper {
        /**
         * @var SignRequest[]
         */
        private $signers = [];
        private bool $firstNotification = false;

        public function __construct(
                IDBConnection $db,
                protected IL10N $l10n,
                protected FileMapper $fileMapper,
                private IURLGenerator $urlGenerator,
        ) {
                parent::__construct($db, 'libresign_sign_request');
        }

        /**
         * @return boolean true when is the first notification
         */
        public function incrementNotificationCounter(SignRequest $signRequest, string $method): bool {
                $this->db->beginTransaction();
                try {
                        $fromDatabase = $this->getById($signRequest->getId());
                        $metadata = $fromDatabase->getMetadata();
                        if (!isset($metadata['notify'])) {
                                $this->firstNotification = true;
                        }

                        $notificationEntry = [
                                'method' => $method,
                                'date' => time(),
                        ];

                        if (!empty($fromDatabase->getDescription())) {
                                $notificationEntry['description'] = $fromDatabase->getDescription();
                        }

                        $metadata['notify'][] = $notificationEntry;
                        $fromDatabase->setMetadata($metadata);
                        $this->update($fromDatabase);
                        $this->db->commit();
                } catch (\Throwable) {
                        $this->db->rollBack();
                }
                return $this->firstNotification;
        }

        /**
         * @inheritDoc
         */
        #[\Override]
        public function update(Entity $entity): SignRequest {
                /** @var SignRequest */
                $signRequest = parent::update($entity);
                $this->signers[$signRequest->getId()] = $signRequest;
                return $signRequest;
        }

        /**
         * Get sign request by UUID
         *
         * @throws DoesNotExistException
         */
        public function getByUuid(string $uuid): SignRequest {
                foreach ($this->signers as $signRequest) {
                        if ($signRequest->getUuid() === $uuid) {
                                return $signRequest;
                        }
                }
                $qb = $this->db->getQueryBuilder();

                $qb->select('*')
                        ->from($this->getTableName())
                        ->where(
                                $qb->expr()->eq('uuid', $qb->createNamedParameter($uuid))
                        );
                /** @var SignRequest */
                $signRequest = $this->findEntity($qb);
                if (!isset($this->signers[$signRequest->getId()])) {
                        $this->signers[$signRequest->getId()] = $signRequest;
                }
                return $signRequest;
        }

        public function getByEmailAndFileId(string $email, int $fileId): SignRequest {
                $qb = $this->db->getQueryBuilder();

                $qb->select('*')
                        ->from($this->getTableName())
                        ->where(
                                $qb->expr()->eq('email', $qb->createNamedParameter($email))
                        )
                        ->andWhere(
                                $qb->expr()->eq('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT))
                        );
                /** @var SignRequest */
                return $this->findEntity($qb);
        }

        public function getByIdentifyMethodAndFileId(IIdentifyMethod $identifyMethod, int $fileId): SignRequest {
                $qb = $this->db->getQueryBuilder();
                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_identify_method', 'im', 'sr.id = im.sign_request_id')
                        ->where($qb->expr()->eq('im.identifier_key', $qb->createNamedParameter($identifyMethod->getEntity()->getIdentifierKey())))
                        ->andWhere($qb->expr()->eq('im.identifier_value', $qb->createNamedParameter($identifyMethod->getEntity()->getIdentifierValue())))
                        ->andWhere($qb->expr()->eq('sr.file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT)));
                /** @var SignRequest */
                return $this->findEntity($qb);
        }

        /**
         * Get all signers by fileId
         *
         * @return SignRequest[]
         */
        public function getByFileId(int $fileId): array {
                $qb = $this->db->getQueryBuilder();

                $qb->select('*')
                        ->from($this->getTableName())
                        ->where(
                                $qb->expr()->eq('file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT))
                        );
                /** @var SignRequest[] */
                $signers = $this->findEntities($qb);
                foreach ($signers as $signRequest) {
                        $this->signers[$signRequest->getId()] = $signRequest;
                }
                return $signers;
        }

        public function flushCache(?int $signRequestId = null): void {
                if ($signRequestId !== null) {
                        unset($this->signers[$signRequestId]);
                } else {
                        $this->signers = [];
                }
        }

        /**
         * @throws DoesNotExistException
         */
        public function getById(int $signRequestId): SignRequest {
                if (isset($this->signers[$signRequestId])) {
                        return $this->signers[$signRequestId];
                }
                $qb = $this->db->getQueryBuilder();

                $qb->select('*')
                        ->from($this->getTableName())
                        ->where(
                                $qb->expr()->eq('id', $qb->createNamedParameter($signRequestId, IQueryBuilder::PARAM_INT))
                        );

                /** @var SignRequest */
                $signRequest = $this->findEntity($qb);
                if (!isset($this->signers[$signRequest->getId()])) {
                        $this->signers[$signRequest->getId()] = $signRequest;
                }
                return $signRequest;
        }

        /**
         * Get sign requests of child files from an envelope for the same signer
         *
         * @return SignRequest[]
         */
        public function getByEnvelopeChildrenAndIdentifyMethod(int $parentFileId, int $signRequestId): array {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from('libresign_file', 'f')
                        ->innerJoin('f', $this->getTableName(), 'sr', $qb->expr()->eq('sr.file_id', 'f.id'))
                        ->innerJoin('sr', 'libresign_identify_method', 'im', $qb->expr()->eq('im.sign_request_id', 'sr.id'))
                        ->innerJoin('im', 'libresign_identify_method', 'im2',
                                $qb->expr()->andX(
                                        $qb->expr()->eq('im2.sign_request_id', $qb->createNamedParameter($signRequestId, IQueryBuilder::PARAM_INT)),
                                        $qb->expr()->eq('im2.identifier_key', 'im.identifier_key'),
                                        $qb->expr()->eq('im2.identifier_value', 'im.identifier_value')
                                )
                        )
                        ->where(
                                $qb->expr()->eq('f.parent_file_id', $qb->createNamedParameter($parentFileId, IQueryBuilder::PARAM_INT))
                        );

                /** @var SignRequest[] */
                $signRequests = $this->findEntities($qb);
                foreach ($signRequests as $signRequest) {
                        if (!isset($this->signers[$signRequest->getId()])) {
                                $this->signers[$signRequest->getId()] = $signRequest;
                        }
                }
                return $signRequests;
        }

        /**
         * @return \Generator<IdentifyMethod>
         */
        public function findRemindersCandidates(): \Generator {
                $qb = $this->db->getQueryBuilder();
                $qb->select(
                        'sr.id AS sr_id',
                        'sr.file_id AS sr_file_id',
                        'sr.uuid AS sr_uuid',
                        'sr.display_name AS sr_display_name',
                        'sr.description AS sr_description',
                        'sr.metadata AS sr_metadata',
                        'sr.signed_hash AS sr_signed_hash',
                        'sr.created_at AS sr_created_at',
                        'sr.signed AS sr_signed',

                        'im.id AS im_id',
                        'im.mandatory AS im_mandatory',
                        'im.code AS im_code',
                        'im.identifier_key AS im_identifier_key',
                        'im.identifier_value AS im_identifier_value',
                        'im.attempts AS im_attempts',
                        'im.identified_at_date AS im_identified_at_date',
                        'im.last_attempt_date AS im_last_attempt_date',
                        'im.sign_request_id AS im_sign_request_id',
                        'im.metadata AS im_metadata',
                )
                        ->from('libresign_sign_request', 'sr')
                        ->join('sr', 'libresign_identify_method', 'im', 'sr.id = im.sign_request_id')
                        ->join('sr', 'libresign_file', 'f', 'sr.file_id = f.id')
                        ->where($qb->expr()->isNull('sr.signed'))
                        ->andWhere($qb->expr()->neq('im.identifier_value', $qb->createNamedParameter('deleted_users')))
                        ->andWhere($qb->expr()->in('f.status', $qb->createNamedParameter([
                                FileStatus::ABLE_TO_SIGN->value,
                                FileStatus::PARTIAL_SIGNED->value
                        ], IQueryBuilder::PARAM_INT_ARRAY)))
                        ->setParameter('st', [1,2], IQueryBuilder::PARAM_INT_ARRAY)
                        ->orderBy('sr.id', 'ASC');

                $result = $qb->executeQuery();
                try {
                        /** @var array<string, mixed> $row */
                        while ($row = $result->fetch()) {
                                $signRequest = new SignRequest();
                                $identifyMethod = new IdentifyMethod();
                                foreach ($row as $key => $value) {
                                        $prop = $identifyMethod->columnToProperty(substr($key, 3));
                                        if (str_starts_with($key, 'sr_')) {
                                                $signRequest->{'set' . lcfirst($prop)}($value);
                                        } else {
                                                $identifyMethod->{'set' . lcfirst($prop)}($value);
                                        }
                                }
                                $signRequest->resetUpdatedFields();
                                $identifyMethod->resetUpdatedFields();
                                if (!isset($this->signers[$signRequest->getId()])) {
                                        $this->signers[$signRequest->getId()] = $signRequest;
                                }
                                yield $identifyMethod;
                        }
                } finally {
                        $result->closeCursor();
                }
        }

        /**
         * Get all signers by multiple fileId
         * Includes signers from both the files themselves and their children files (for envelopes)
         *
         * @return SignRequest[]
         */
        public function getByMultipleFileId(array $fileId) {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_file', 'f', $qb->expr()->eq('sr.file_id', 'f.id'))
                        ->where(
                                $qb->expr()->orX(
                                        $qb->expr()->in('f.id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT_ARRAY)),
                                        $qb->expr()->in('f.parent_file_id', $qb->createNamedParameter($fileId, IQueryBuilder::PARAM_INT_ARRAY))
                                )
                        )
                        ->orderBy('sr.id', 'ASC');

                /** @var SignRequest[] */
                return $this->findEntities($qb);
        }

        /**
         * Get all signers by fileId
         *
         * @return SignRequest[]
         */
        public function getByNodeId(int $nodeId) {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_file', 'f', 'sr.file_id = f.id')
                        ->where(
                                $qb->expr()->eq('f.node_id', $qb->createNamedParameter($nodeId, IQueryBuilder::PARAM_INT))
                        );

                /** @var SignRequest[] */
                $signers = $this->findEntities($qb);
                return $signers;
        }

        /**
         * Get all signers by File Uuid
         *
         * @param string $nodeId
         * @return SignRequest[]
         */
        public function getByFileUuid(string $uuid) {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_file', 'f', 'sr.file_id = f.id')
                        ->where(
                                $qb->expr()->eq('f.uuid', $qb->createNamedParameter($uuid))
                        );

                /** @var SignRequest[] */
                $signers = $this->findEntities($qb);
                foreach ($signers as $signRequest) {
                        if (!isset($this->signers[$signRequest->getId()])) {
                                $this->signers[$signRequest->getId()] = $signRequest;
                        }
                }
                return $signers;
        }

        public function getBySignerUuidAndUserId(string $uuid): SignRequest {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->where(
                                $qb->expr()->eq('sr.uuid', $qb->createNamedParameter($uuid))
                        );

                /** @var SignRequest */
                $signRequest = $this->findEntity($qb);
                if (!isset($this->signers[$signRequest->getId()])) {
                        $this->signers[$signRequest->getId()] = $signRequest;
                }
                return $signRequest;
        }

        public function getByFileIdAndUserId(int $file_id): SignRequest {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_file', 'f', 'sr.file_id = f.id')
                        ->where(
                                $qb->expr()->eq('f.node_id', $qb->createNamedParameter($file_id, IQueryBuilder::PARAM_INT))
                        );

                /** @var SignRequest */
                return $this->findEntity($qb);
        }

        public function getByFileIdAndEmail(int $file_id, string $email): SignRequest {
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->join('sr', 'libresign_file', 'f', 'sr.file_id = f.id')
                        ->where(
                                $qb->expr()->eq('f.node_id', $qb->createNamedParameter($file_id, IQueryBuilder::PARAM_INT))
                        )
                        ->andWhere(
                                $qb->expr()->eq('sr.email', $qb->createNamedParameter($email))
                        );

                /** @var SignRequest */
                return $this->findEntity($qb);
        }

        public function getByFileIdAndSignRequestId(int $fileId, int $signRequestId): SignRequest {
                if (isset($this->signers[$signRequestId])) {
                        return $this->signers[$signRequestId];
                }
                $qb = $this->db->getQueryBuilder();

                $qb->select('sr.*')
                        ->from($this->getTableName(), 'sr')
                        ->where(
                                $qb->expr()->eq('sr.file_id', $qb->createNamedParameter($fileId))
                        )
                        ->andWhere(
                                $qb->expr()->eq('sr.id', $qb->createNamedParameter($signRequestId))
                        );

                $signRequest = $this->findEntity($qb);
                if (!isset($this->signers[$signRequest->getId()])) {
                        $this->signers[$signRequest->getId()] = $signRequest;
                }
                /** @var SignRequest */
                return end($this->signers);
        }

        /**
         * @return array{data: list<File>, pagination: Pagination}
         */
        public function getFilesAssociatedFilesWithMe(
                IUser $user,
                array $filter,
                ?int $page = null,
                ?int $length = null,
                ?array $sort = [],
        ): array {
                $filter['email'] = $user->getEMailAddress();
                $filter['length'] = $length;
                $filter['page'] = $page;
                $pagination = $this->getFilesAssociatedFilesWithMeStmt($user->getUID(), $filter, $sort);
                $pagination->setMaxPerPage($length);
                $pagination->setCurrentPage($page);
                $currentPageResults = $pagination->getCurrentPageResults();

                $data = [];
                foreach ($currentPageResults as $row) {
                        $file = new File();
                        $data[] = $file->fromRow($row);
                }
                /** @var array{data: list<File>, pagination: Pagination} */
                return [
                        'data' => $data,
                        'pagination' => $pagination,
                ];
        }

        public function getFilesToSearchProvider(IUser $user, string $fileName, int $limit, int $offset): array {
                $filter = [
                        'page' => ($offset / $limit) + 1,
                        'length' => $limit,
                        'fileName' => $fileName,
                ];

                $sort = [
                        'sortBy' => 'created_at',
                        'sortDirection' => 'desc',
                ];

                $qb = $this->getFilesAssociatedFilesWithMeQueryBuilder($user->getUID(), $filter, false, $sort);

                $result = $qb->executeQuery();
                $files = [];

                while ($row = $result->fetch()) {
                        try {
                                $file = File::fromRow($row);

                                $files[] = $file;
                        } catch (\Exception $e) {
                                continue;
                        }
                }

                $result->closeCursor();

                return $files;
        }

        /**
         * @param array<SignRequest> $signRequests
         * @return FileElement[][]
         */
        public function getVisibleElementsFromSigners(array $signRequests): array {
                $signRequestIds = array_map(fn (SignRequest $signRequest): int => $signRequest->getId(), $signRequests);
                if (!$signRequestIds) {
                        return [];
                }
                $qb = $this->db->getQueryBuilder();

                $qb->select('fe.*')
                        ->from('libresign_file_element', 'fe')
                        ->where(
                                $qb->expr()->in('fe.sign_request_id', $qb->createParameter('signRequestIds'))
                        );

                $return = [];
                foreach (array_chunk($signRequestIds, 1000) as $signRequestIdsChunk) {
                        $qb->setParameter('signRequestIds', $signRequestIdsChunk, IQueryBuilder::PARAM_INT_ARRAY);
                        $cursor = $qb->executeQuery();
                        while ($row = $cursor->fetch()) {
                                $return[$row['sign_request_id']][] = (new FileElement())->fromRow($row);
                        }
                }
                return $return;
        }

        /**
         * @param array<SignRequest> $signRequests
         * @return array<array-key, array<array-key, \OCP\AppFramework\Db\Entity&\OCA\Libresign\Db\IdentifyMethod>>
         */
        public function getIdentifyMethodsFromSigners(array $signRequests): array {
                $signRequestIds = array_map(fn (SignRequest $signRequest): int => $signRequest->getId(), $signRequests);
                if (!$signRequestIds) {
                        return [];
                }
                $qb = $this->db->getQueryBuilder();
                $qb->select('im.*')
                        ->from('libresign_identify_method', 'im')
                        ->where(
                                $qb->expr()->in('im.sign_request_id', $qb->createParameter('signRequestIds'))
                        )
                        ->orderBy('im.mandatory', 'DESC')
                        ->addOrderBy('im.identified_at_date', 'ASC');

                $return = [];
                foreach (array_chunk($signRequestIds, 1000) as $signRequestIdsChunk) {
                        $qb->setParameter('signRequestIds', $signRequestIdsChunk, IQueryBuilder::PARAM_INT_ARRAY);
                        $cursor = $qb->executeQuery();
                        while ($row = $cursor->fetch()) {
                                $identifyMethod = new IdentifyMethod();
                                $return[$row['sign_request_id']][$row['identifier_key']] = $identifyMethod->fromRow($row);
                        }
                }
                return $return;
        }

        public function getMyLibresignFile(string $userId, ?array $filter = []): File {
                $qb = $this->getFilesAssociatedFilesWithMeQueryBuilder(
                        userId: $userId,
                        filter: $filter,
                );
                $cursor = $qb->executeQuery();
                $row = $cursor->fetch();
                if (!$row) {
                        throw new DoesNotExistException('LibreSign file not found');
                }

                $file = new File();
                return $file->fromRow($row);
        }

        private function getFilesAssociatedFilesWithMeQueryBuilder(
                        string $userId,
                        array $filter = [],
                        bool $count = false,
                        array $sort = []
                ): IQueryBuilder {
                $qb = $this->db->getQueryBuilder();
                $qb->from('libresign_file', 'f')
                        ->leftJoin('f', 'libresign_sign_request', 'sr', 'sr.file_id = f.id')
                        ->leftJoin('f', 'libresign_identify_method', 'im', $qb->expr()->eq('sr.id', 'im.sign_request_id'))
                        ->leftJoin('f', 'libresign_id_docs', 'id', 'id.file_id = f.id');
                if ($count) {
                        $qb->select($qb->func()->count())
                                ->setFirstResult(0)
                                ->setMaxResults(null);
                } else {
                        $qb->select(
                                'f.id',
                                'f.node_id',
                                'f.signed_node_id',
                                'f.user_id',
                                'f.uuid',
                                'f.name',
                                'f.status',
                                'f.metadata',
                                'f.created_at',
                                'f.signature_flow',
                                'f.docmdp_level',
                                'f.node_type',
                                'f.parent_file_id'
                        )
                                ->groupBy(
                                        'f.id',
                                        'f.node_id',
                                        'f.signed_node_id',
                                        'f.user_id',
                                        'f.uuid',
                                        'f.name',
                                        'f.status',
                                        'f.created_at',
                                        'f.signature_flow',
                                        'f.docmdp_level',
                                        'f.node_type',
                                        'f.parent_file_id'
                                );
                        // metadata is a json column, the right way is to use f.metadata::text
                        // when the database is PostgreSQL. The problem is that the command
                        // addGroupBy add quotes over all text send as argument. With
                        // PostgreSQL json columns don't have problem if not added to group by.
                        if ($qb->getConnection()->getDatabaseProvider() !== IDBConnection::PLATFORM_POSTGRES) {
                                $qb->addGroupBy('f.metadata');
                        }
                        if (isset($filter['length']) && isset($filter['page'])) {
                                $qb->setFirstResult($filter['length'] * ($filter['page'] - 1));
                                $qb->setMaxResults($filter['length']);
                        }
                }

                $or = [
                        $qb->expr()->eq('f.user_id', $qb->createNamedParameter($userId)),
                        $qb->expr()->andX(
                                $qb->expr()->eq('im.identifier_key', $qb->createNamedParameter(IdentifyMethodService::IDENTIFY_ACCOUNT)),
                                $qb->expr()->eq('im.identifier_value', $qb->createNamedParameter($userId)),
                                $qb->expr()->neq('f.status', $qb->createNamedParameter(FileStatus::DRAFT->value)),
                                $qb->expr()->neq('sr.status', $qb->createNamedParameter(SignRequestStatus::DRAFT->value)),
                        )
                ];
                $qb->where($qb->expr()->orX(...$or))
                        ->andWhere($qb->expr()->isNull('id.id'));

                if ($filter) {
                        if (isset($filter['email']) && filter_var($filter['email'], FILTER_VALIDATE_EMAIL)) {
                                $or[] = $qb->expr()->andX(
                                        $qb->expr()->eq('im.identifier_key', $qb->createNamedParameter(IdentifyMethodService::IDENTIFY_EMAIL)),
                                        $qb->expr()->eq('im.identifier_value', $qb->createNamedParameter($filter['email']))
                                );
                        }
                        if (!empty($filter['signer_uuid']) && !empty($filter['parentFileId'])) {
                                $qb->leftJoin('f', 'libresign_file', 'parent', $qb->expr()->eq('f.parent_file_id', 'parent.id'));
                                $qb->innerJoin('parent', 'libresign_sign_request', 'psr', $qb->expr()->eq('psr.file_id', 'parent.id'))
                                        ->andWhere($qb->expr()->eq('psr.uuid', $qb->createNamedParameter($filter['signer_uuid'])));
                        } elseif (!empty($filter['signer_uuid'])) {
                                $qb->andWhere(
                                        $qb->expr()->eq('sr.uuid', $qb->createNamedParameter($filter['signer_uuid']))
                                );
                        }
                        if (!empty($filter['nodeIds'])) {
                                $qb->andWhere(
                                        $qb->expr()->orX(
                                                $qb->expr()->in('f.node_id', $qb->createNamedParameter($filter['nodeIds'], IQueryBuilder::PARAM_INT_ARRAY)),
                                                $qb->expr()->in('f.signed_node_id', $qb->createNamedParameter($filter['nodeIds'], IQueryBuilder::PARAM_INT_ARRAY))
                                        )
                                );
                        }
                        if (!empty($filter['fileIds'])) {
                                $qb->andWhere(
                                        $qb->expr()->in('f.id', $qb->createNamedParameter($filter['fileIds'], IQueryBuilder::PARAM_INT_ARRAY))
                                );
                        }
                        if (!empty($filter['status'])) {
                                $qb->andWhere(
                                        $qb->expr()->in('f.status', $qb->createNamedParameter($filter['status'], IQueryBuilder::PARAM_INT_ARRAY))
                                );
                        }
                        if (!empty($filter['start'])) {
                                $start = (new \DateTime('@' . $filter['start'], new \DateTimeZone('UTC')))->format('Y-m-d H:i:s');
                                $qb->andWhere(
                                        $qb->expr()->gte('f.created_at', $qb->createNamedParameter($start, IQueryBuilder::PARAM_STR))
                                );
                        }
                        if (!empty($filter['end'])) {
                                $end = (new \DateTime('@' . $filter['end'], new \DateTimeZone('UTC')))->format('Y-m-d H:i:s');
                                $qb->andWhere(
                                        $qb->expr()->lte('f.created_at', $qb->createNamedParameter($end, IQueryBuilder::PARAM_STR))
                                );
                        }
                        if (!empty($filter['fileName'])) {
                                $qb->andWhere(
                                        $qb->expr()->like('f.name', $qb->createNamedParameter('%' . $this->db->escapeLikeParameter($filter['fileName']) . '%'))
                                );
                        }
                        if (!empty($filter['parentFileId'])) {
                                $qb->andWhere(
                                        $qb->expr()->eq('f.parent_file_id', $qb->createNamedParameter($filter['parentFileId'], IQueryBuilder::PARAM_INT))
                                );
                        } else {
                                $qb->andWhere($qb->expr()->isNull('f.parent_file_id'));
                        }
                }

                if (!empty($sort['sortBy']) && !empty($sort['sortDirection'])) {
                        switch ($sort['sortBy']) {
                                case 'name':
                                case 'status':
                                        $qb->orderBy(
                                                $qb->func()->lower('f.' . $sort['sortBy']),
                                                $sort['sortDirection'] == 'asc' ? 'asc' : 'desc'
                                        );
                                        break;
                                case 'created_at':
                                        $qb->orderBy(
                                                'f.' . $sort['sortBy'],
                                                $sort['sortDirection'] == 'asc' ? 'asc' : 'desc'
                                        );
                        }
                }

                return $qb;
        }

        private function getFilesAssociatedFilesWithMeStmt(
                string $userId,
                ?array $filter = [],
                ?array $sort = [],
        ): Pagination {
                $qb = $this->getFilesAssociatedFilesWithMeQueryBuilder($userId, $filter, false, $sort);

                $countQb = $this->getFilesAssociatedFilesWithMeQueryBuilder(
                        userId: $userId,
                        filter: $filter,
                        count: true,
                );

                $pagination = new Pagination($qb, $this->urlGenerator, $countQb);
                return $pagination;
        }

        public function getTextOfSignerStatus(int $status): string {
                return SignRequestStatus::from($status)->getLabel($this->l10n);
        }
}

LibreSign / libresign / 21182715382

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