Merge pull request #7447 from LibreSign/backport/7446/stable32

[stable32] fix(Sign): submit each envelope file independently with its UUID

Author: vitormattos

src/components/Draw/Draw.vue

@@ -33,7 +33,7 @@
 
 <script setup lang="ts">
 import { t } from '@nextcloud/l10n'
-import { computed, onBeforeUnmount, onMounted, ref } from 'vue'
+import { computed, nextTick, onBeforeUnmount, onMounted, ref } from 'vue'
 
 import {
 	mdiCloudUpload,
@@ -116,8 +116,8 @@ function close() {
 }
 
 async function save(base64: string) {
-	signatureElementsStore.loadSignatures()
 	await signatureElementsStore.save(props.type, base64)
+	await nextTick()
 	emit('save')
 	close()
 }

src/services/signSubmit.ts

@@ -0,0 +1,332 @@
+/**
+ * SPDX-FileCopyrightText: 2026 LibreCode coop and contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+import type {
+	FileUuidReferenceRecord,
+	SignActionResponseRecord,
+	SignerDetailRecord,
+	SigningJobRecord,
+	UserElementRecord,
+	VisibleElementRecord,
+} from '../types/index'
+
+export type SignResultData = Omit<Partial<SignActionResponseRecord>, 'file' | 'job'> & {
+	file?: Partial<FileUuidReferenceRecord>
+	job?: Partial<SigningJobRecord> & {
+		file?: Partial<FileUuidReferenceRecord>
+	}
+} & Record<string, unknown>
+
+export type SignResult = {
+	status: 'signingInProgress' | 'signed' | 'unknown'
+	data: SignResultData
+}
+
+export type SubmitSignaturePayload = {
+	method?: string
+	token?: string
+	elements?: Array<{
+		documentElementId: number
+		profileNodeId?: number
+	}>
+}
+
+export type SignatureMethodConfig = {
+	method?: string
+	modalCode?: string
+	token?: string
+}
+
+export type VisibleSignatureElement = Partial<Pick<VisibleElementRecord, 'elementId' | 'signRequestId' | 'type'>>
+
+export type SignatureProfileMap = Record<string, {
+	file?: Partial<Pick<UserElementRecord['file'], 'nodeId' | 'url'>>
+} | undefined>
+
+export type EnvelopeSigner = Omit<Partial<Pick<SignerDetailRecord, 'me' | 'signRequestId' | 'sign_request_uuid'>>, 'sign_request_uuid'> & {
+	sign_request_uuid?: string | null
+}
+
+type EnvelopeOwnSigner = EnvelopeSigner & {
+	me: true
+	signRequestId: number
+	sign_request_uuid: string
+	level: 'top' | 'file'
+}
+
+export type EnvelopeFileForSubmission = {
+	signers?: EnvelopeSigner[]
+}
+
+export type SignDocumentForSubmission = {
+	nodeType?: string
+	signers?: EnvelopeSigner[]
+	files?: EnvelopeFileForSubmission[]
+}
+
+export type SignSubmissionAttempt = {
+	result: SignResult
+	signRequestUuid: string
+}
+
+export type SignSubmissionOutcome =
+	| {
+		type: 'signed'
+		payload: Record<string, unknown> & {
+			signRequestUuid: string
+		}
+	}
+	| {
+		type: 'signing-started'
+		payload: {
+			signRequestUuid: string
+			async: true
+		}
+	}
+	| null
+
+export type EnvelopeSubmitRequest = {
+	signRequestUuid: string
+	payload: SubmitSignaturePayload
+}
+
+export function createBaseSubmitSignaturePayload(methodConfig: SignatureMethodConfig = {}): SubmitSignaturePayload {
+	const payload: SubmitSignaturePayload = {
+		method: methodConfig.method,
+	}
+
+	if (methodConfig.token) {
+		payload.token = methodConfig.token
+	}
+
+	return payload
+}
+
+export function buildSubmitSignaturePayload({
+	basePayload,
+	elements,
+	canCreateSignature,
+	signatures,
+}: {
+	basePayload: SubmitSignaturePayload
+	elements: VisibleSignatureElement[]
+	canCreateSignature: boolean
+	signatures: SignatureProfileMap
+}): SubmitSignaturePayload {
+	const payload: SubmitSignaturePayload = { ...basePayload }
+	const mappedElements = mapSubmitSignatureElements(elements, canCreateSignature, signatures)
+
+	if (mappedElements.length > 0) {
+		payload.elements = mappedElements
+	}
+
+	return payload
+}
+
+export function getEnvelopeSubmitRequests({
+	document,
+	basePayload,
+	elements,
+	canCreateSignature,
+	signatures,
+}: {
+	document: SignDocumentForSubmission | null | undefined
+	basePayload: SubmitSignaturePayload
+	elements: VisibleSignatureElement[]
+	canCreateSignature: boolean
+	signatures: SignatureProfileMap
+}): EnvelopeSubmitRequest[] {
+	if (document?.nodeType !== 'envelope') {
+		return []
+	}
+
+	const requests: EnvelopeSubmitRequest[] = []
+
+	for (const signer of getEnvelopeOwnSigners(document)) {
+		if (!isOwnEnvelopeSigner(signer)) {
+			continue
+		}
+
+		const matchingElements = elements.filter((element) => element.signRequestId === signer.signRequestId)
+		const signerElements = signer.level === 'top' && matchingElements.length === 0
+			? elements
+			: matchingElements
+		requests.push({
+			signRequestUuid: signer.sign_request_uuid,
+			payload: buildSubmitSignaturePayload({
+				basePayload,
+				elements: signerElements,
+				canCreateSignature,
+				signatures,
+			}),
+		})
+	}
+
+	return requests
+}
+
+function getEnvelopeOwnSigners(document: SignDocumentForSubmission): Array<EnvelopeSigner & {
+	me: true
+	signRequestId: number
+	sign_request_uuid: string
+	level: 'top' | 'file'
+}> {
+	const ownSigners: EnvelopeOwnSigner[] = []
+	const seen = new Set<string>()
+
+	const addSigner = (signer: EnvelopeSigner, level: 'top' | 'file') => {
+		if (!isOwnEnvelopeSigner(signer)) {
+			return
+		}
+
+		if (seen.has(signer.sign_request_uuid)) {
+			return
+		}
+
+		seen.add(signer.sign_request_uuid)
+		ownSigners.push({
+			...signer,
+			level,
+		})
+	}
+
+	const topOwnSigners: EnvelopeSigner[] = []
+	for (const signer of document.signers ?? []) {
+		if (isOwnEnvelopeSigner(signer)) {
+			topOwnSigners.push(signer)
+		}
+	}
+
+	if (topOwnSigners.length > 0) {
+		for (const signer of topOwnSigners) {
+			addSigner(signer, 'top')
+		}
+
+		return ownSigners
+	}
+
+	const fileOwnSigners: EnvelopeOwnSigner[] = []
+	for (const file of document.files ?? []) {
+		for (const signer of file.signers ?? []) {
+			if (isOwnEnvelopeSigner(signer)) {
+				fileOwnSigners.push({
+					...signer,
+					level: 'file',
+				})
+			}
+		}
+	}
+
+	if (fileOwnSigners.length > 0) {
+		for (const signer of fileOwnSigners) {
+			addSigner(signer, 'file')
+		}
+
+		return ownSigners
+	}
+
+	return ownSigners
+}
+
+export function resolveSignSubmissionOutcome(attempts: SignSubmissionAttempt[]): SignSubmissionOutcome {
+	let signedAttempt: SignSubmissionAttempt | null = null
+	let signingInProgressAttempt: SignSubmissionAttempt | null = null
+
+	for (const attempt of attempts) {
+		if (attempt.result.status === 'signed') {
+			signedAttempt = attempt
+			continue
+		}
+
+		if (attempt.result.status === 'signingInProgress' && !signingInProgressAttempt) {
+			signingInProgressAttempt = attempt
+		}
+	}
+
+	if (signedAttempt) {
+		return {
+			type: 'signed',
+			payload: {
+				...signedAttempt.result.data,
+				signRequestUuid: resolveNavigationUuid(signedAttempt.result.data, signedAttempt.signRequestUuid),
+			},
+		}
+	}
+
+	if (signingInProgressAttempt) {
+		return {
+			type: 'signing-started',
+			payload: {
+				signRequestUuid: resolveNavigationUuid(
+					signingInProgressAttempt.result.data,
+					signingInProgressAttempt.signRequestUuid,
+				),
+				async: true,
+			},
+		}
+	}
+
+	return null
+}
+
+export function resolveNavigationUuid(
+	data: SignResultData | null | undefined,
+	fallbackUuid: string,
+): string {
+	if (typeof data?.file?.uuid === 'string' && data.file.uuid.length > 0) {
+		return data.file.uuid
+	}
+
+	if (typeof data?.job?.file?.uuid === 'string' && data.job.file.uuid.length > 0) {
+		return data.job.file.uuid
+	}
+
+	return fallbackUuid
+}
+
+function mapSubmitSignatureElements(
+	elements: VisibleSignatureElement[],
+	canCreateSignature: boolean,
+	signatures: SignatureProfileMap,
+): NonNullable<SubmitSignaturePayload['elements']> {
+	const payloadElements: NonNullable<SubmitSignaturePayload['elements']> = []
+
+	for (const element of elements) {
+		if (typeof element.elementId !== 'number') {
+			continue
+		}
+
+		const payloadElement: NonNullable<SubmitSignaturePayload['elements']>[number] = {
+			documentElementId: element.elementId,
+		}
+
+		if (canCreateSignature && element.type) {
+			const profileNodeId = signatures[element.type]?.file?.nodeId
+			if (typeof profileNodeId === 'number') {
+				payloadElement.profileNodeId = profileNodeId
+			}
+		}
+
+		payloadElements.push(payloadElement)
+	}
+
+	return payloadElements
+}
+
+function isOwnEnvelopeSigner(signer: EnvelopeSigner): signer is EnvelopeSigner & {
+	me: true
+	signRequestId: number
+	sign_request_uuid: string
+} {
+	if (signer.me !== true) {
+		return false
+	}
+
+	if (typeof signer.signRequestId !== 'number') {
+		return false
+	}
+
+	return typeof signer.sign_request_uuid === 'string' && signer.sign_request_uuid.length > 0
+}

src/tests/components/Draw/Draw.spec.ts

@@ -247,7 +247,7 @@ describe('Draw.vue', () => {
 		expect(wrapper.emitted('close')).toBeTruthy()
 	})
 
-	it('calls store loadSignatures when save is triggered', async () => {
+	it('persists the signature without triggering a parallel reload', async () => {
 		const wrapper = mountDraw({
 			props: {
 				type: 'signature',
@@ -259,16 +259,14 @@ describe('Draw.vue', () => {
 
 		await wrapper.vm.$nextTick()
 
-		const store = useSignatureElementsStore()
-		const originalLoadSignatures = store.loadSignatures
-		store.loadSignatures = vi.fn()
-		store.save = vi.fn()
-
 		wrapper.vm.signatureElementsStore.loadSignatures = vi.fn()
 		wrapper.vm.signatureElementsStore.save = vi.fn()
 
 		const base64Data = 'data:image/png;base64,test'
 		await wrapper.vm.save(base64Data)
+
+		expect(wrapper.vm.signatureElementsStore.loadSignatures).not.toHaveBeenCalled()
+		expect(wrapper.vm.signatureElementsStore.save).toHaveBeenCalledWith('signature', base64Data)
 	})
 
 	it('emits save event after complete flow', async () => {
@@ -283,7 +281,6 @@ describe('Draw.vue', () => {
 
 		await wrapper.vm.$nextTick()
 		const store = wrapper.vm.signatureElementsStore
-		store.loadSignatures = vi.fn()
 		store.save = vi.fn()
 
 		await wrapper.vm.save('data:image/png;base64,test')
@@ -303,7 +300,6 @@ describe('Draw.vue', () => {
 
 		await wrapper.vm.$nextTick()
 		const store = wrapper.vm.signatureElementsStore
-		store.loadSignatures = vi.fn()
 		store.save = vi.fn()
 
 		const closeEmits = wrapper.emitted('close') || []