https://seu.tarragona.cat/sta/resources/js/sta-autofirma-lote.js

1/**
2 * sta-autofirma-lote.js
3 *
4 * API JavaScript intermedia para la firma de ficheros por lotes con AutoFirma
5 * (firma trifásica) en la aplicación STA.
6 *
7 * PREREQUISITOS
8 * -------------
9 * Esta API asume que el navegador ya tiene cargados, en este orden:
10 *   1. autoscript.js  (AutoScript v1.9.0 de AutoFirma)
11 *   2. este fichero   (sta-autofirma-lote.js)
12 *
13 * DEPENDENCIA EXTERNA
14 * -------------------
15 * AutoScript debe haber sido inicializado previamente con:
16 *   AutoScript.cargarAppAfirma('https://127.0.0.1');
17 *   AutoScript.setServlets(storageUrl, retrieverUrl);  // solo si se usa servidor intermedio
18 *
19 * USO
20 * ---
21 * El backend serializa el objeto AutofirmaLoteSignInfo a JSON y lo envía al
22 * navegador. Con ese JSON se invoca:
23 *
24 *   STAAutofirmaLote.firmarLote(params, onSuccess, onError);
25 *
26 * Donde:
27 *   params     {Object}   - El objeto JSON generado por AutofirmaLoteUtils.declararOperacionLote()
28 *   onSuccess  {Function} - Llamada al terminar con éxito.  Recibe el resultado del lote.
29 *   onError    {Function} - Llamada si hay error.           Recibe (errorType, errorMsg).
30 *
31 * NOTAS SOBRE LA API DE AUTOSCRIPT v1.9.0
32 * ----------------------------------------
33 * El objeto público AutoScript expone los métodos de lote con estos nombres:
34 *
35 *   AutoScript.createBatch(algorithm, format, suboperation, extraparams)
36 *     Inicializa un nuevo lote de firma en memoria.
37 *
38 *   AutoScript.addDocumentToBatch(id, datareference, format, suboperation, extraparams)
39 *     Añade un documento al lote activo en memoria.
40 *
41 *   AutoScript.signBatchProcess(stopOnError, preSignerUrl, postSignerUrl, certFilters, successCb, errorCb)
42 *     Lanza la firma trifásica del lote JSON construido con createBatch/addDocumentToBatch.
43 *     NOTA: internamente se llama "signBatchJSON" pero se expone públicamente como "signBatchProcess".
44 *           NO usar "AutoScript.signBatch" — ese método corresponde a la firma por lotes XML (signBatchXML).
45 *
46 * ESTRUCTURA DEL OBJETO params (AutofirmaLoteSignInfo)
47 * ----------------------------------------------------
48 * {
49 *   "operacionId":       "uuid-de-la-operacion",
50 *   "batchPreSignerUrl": "https://host/sta/AutofirmaLote?op=presign&operacionId=...",
51 *   "batchPostSignerUrl":"https://host/sta/AutofirmaLote?op=postsign&operacionId=...",
52 *   "algorithm":         "SHA256withRSA",
53 *   "format":            "CAdES",
54 *   "suboperation":      "sign",
55 *   "stopOnError":       false,
56 *   "documentos": [
57 *     {
58 *       "id":            "docId1",
59 *       "datareference": "https://host/sta/AutofirmaLote?op=getdata&operacionId=...&docId=docId1",
60 *       "format":        "PAdES",
61 *       "suboperation":  "sign",
62 *       "fileName":      "_uf_..._docId1.pdf"
63 *     },
64 *     ...
65 *   ]
66 * }
67 */
68
69var STAAutofirmaLote = (function () {
70
71    'use strict';
72
73    // -------------------------------------------------------------------------
74    // Constantes
75    // -------------------------------------------------------------------------
76
77    var DEFAULT_ALGORITHM    = 'SHA256withRSA';
78    var DEFAULT_SUBOPERATION = 'sign';
79
80    // -------------------------------------------------------------------------
81    // Validación de dependencias
82    // -------------------------------------------------------------------------
83
84    /**
85     * Comprueba que AutoScript está disponible y expone los métodos necesarios.
86     *
87     * En autoscript.js v1.9.0 el método de firma por lotes JSON se expone
88     * públicamente como "signBatchProcess" (no como "signBatchJSON").
89     *
90     * @returns {boolean}
91     */
92    function isAutoScriptDisponible() {
93        return typeof window.AutoScript !== 'undefined' &&
94               window.AutoScript !== null &&
95               typeof window.AutoScript.createBatch === 'function' &&
96               typeof window.AutoScript.addDocumentToBatch === 'function' &&
97               typeof window.AutoScript.signBatchProcess === 'function';
98    }
99
100    // -------------------------------------------------------------------------
101    // Validación de parámetros
102    // -------------------------------------------------------------------------
103
104    /**
105     * Valida el objeto de parámetros recibido del backend.
106     * @param {Object} params
107     * @returns {string|null} Mensaje de error, o null si es válido.
108     */
109    function validarParams(params) {
110        if (!params) {
111            return 'El objeto de parámetros es nulo o indefinido';
112        }
113        if (!params.batchPreSignerUrl) {
114            return 'Falta el parámetro batchPreSignerUrl';
115        }
116        if (!params.batchPostSignerUrl) {
117            return 'Falta el parámetro batchPostSignerUrl';
118        }
119        if (!params.documentos || !Array.isArray(params.documentos) || params.documentos.length === 0) {
120            return 'La lista de documentos está vacía o no es válida';
121        }
122        for (var i = 0; i < params.documentos.length; i++) {
123            var doc = params.documentos[i];

124            if (!doc.id) {
125                return 'El documento en la posición ' + i + ' no tiene id';
126            }
127            if (!doc.datareference) {
128                return 'El documento "' + doc.id + '" no tiene datareference';
129            }
130        }
131        return null;
132    }
133
134    // -------------------------------------------------------------------------
135    // Construcción del lote
136    // -------------------------------------------------------------------------
137
138    /**
139     * Crea el lote en AutoScript y añade todos los documentos.
140     * Internamente usa createBatch + addDocumentToBatch de autoscript.js.
141     *
142     * @param {Object} params - Parámetros procedentes del backend.
143     */
144    function construirLote(params) {
145        var algorithm    = params.algorithm    || DEFAULT_ALGORITHM;
146        var format       = params.format       || 'CAdES';
147        var suboperation = params.suboperation || DEFAULT_SUBOPERATION;
148
149        // Inicializar el lote con la configuración por defecto del conjunto
150        AutoScript.createBatch(algorithm, format, suboperation, null);
151
152        // Añadir cada documento al lote
153        var documentos = params.documentos;
154        for (var i = 0; i < documentos.length; i++) {
155            var doc = documentos[i];
156
157            // null = heredar el valor del lote si el documento no especifica uno propio
158            var docFormat       = doc.format       || null;
159            var docSuboperation = doc.suboperation || null;
160            var extraparams     = buildExtraparams(docFormat || format);
161
162            AutoScript.addDocumentToBatch(
163                doc.id,            // identificador único del documento dentro del lote
164                doc.datareference, // URL op=getdata del servlet trifásico
165                docFormat,         // formato específico del documento (o null → hereda del lote)
166                docSuboperation,   // sub-operación específica (o null → hereda del lote)
167                extraparams        // parámetros extra de firma (o null)
168            );
169        }
170    }
171
172    /**
173     * Construye los parámetros extra (extraparams) adecuados para cada formato.
174     *
175     * @param {string} format - "PAdES", "XAdES" o "CAdES"
176     * @returns {string|null}
177     */
178    function buildExtraparams(format) {
179        if (!format) { return null; }
180        var fmt = format.toUpperCase();
181        if (fmt === 'PADES') {
182            return 'signatureSubFilter=ETSI.CAdES.detached';
183        }
184        if (fmt === 'XADES') {
185            return 'mode=implicit';
186        }
187        return null;
188    }
189
190    // -------------------------------------------------------------------------
191    // Función principal pública
192    // -------------------------------------------------------------------------
193
194    /**
195     * Lanza el proceso de firma por lotes trifásica con AutoFirma.
196     *
197     * Flujo interno:
198     *   1. Valida que AutoScript esté cargado y operativo.
199     *   2. Valida el objeto params.
200     *   3. Construye el lote en memoria (createBatch + addDocumentToBatch).
201     *   4. Lanza la firma trifásica con AutoScript.signBatchProcess.
202     *
203     * @param {Object}   params     - Objeto JSON de AutofirmaLoteSignInfo.
204     * @param {Function} onSuccess  - function(batchResult) — resultado del lote.
205     * @param {Function} onError    - function(errorType, errorMsg).
206     */
207    function firmarLote(params, onSuccess, onError) {
208
209        // 1. Verificar que AutoScript está disponible y es la versión correcta
210        if (!isAutoScriptDisponible()) {
211            var msg = '[STAAutofirmaLote] AutoScript no está disponible o no expone ' +
212                      'signBatchProcess. Compruebe que autoscript.js v1.9.0 está cargado.';
213            console.error(msg);
214            if (typeof onError === 'function') {
215                onError('AUTOSCRIPT_NOT_FOUND', msg);
216            }
217            return;
218        }
219
220        // 2. Validar parámetros del backend
221        var errorValidacion = validarParams(params);
222        if (errorValidacion) {
223            console.error('[STAAutofirmaLote] Parámetros inválidos: ' + errorValidacion);
224            if (typeof onError === 'function') {

225                onError('INVALID_PARAMS', errorValidacion);
226            }
227            return;
228        }
229
230        // 3. Construir el lote en AutoScript
231        try {
232            construirLote(params);
233        } catch (e) {
234            var buildMsg = '[STAAutofirmaLote] Error construyendo el lote: ' + e.message;
235            console.error(buildMsg, e);
236            if (typeof onError === 'function') {
237                onError('BATCH_BUILD_ERROR', buildMsg);
238            }
239            return;
240        }
241
242        // 4. Lanzar la firma trifásica
243        //    AutoScript.signBatchProcess es el nombre público de la función interna
244        //    signBatchJSON en autoscript.js v1.9.0.
245        //    Firma: signBatchProcess(stopOnError, preSignerUrl, postSignerUrl,
246        //                           certFilters, successCallback, errorCallback)
247        var stopOnError        = (params.stopOnError === true);
248        var batchPreSignerUrl  = params.batchPreSignerUrl;
249        var batchPostSignerUrl = params.batchPostSignerUrl;
250        var certFilters        = null; // null = usuario elige cualquier certificado
251
252        console.log('[STAAutofirmaLote] Iniciando firma de lote. operacionId=' +
253                    (params.operacionId || 'N/A') +
254                    ', documentos=' + params.documentos.length);
255
256					
257		console.log('[STAAutofirmaLote] batchPreSignerUrl  = ' + params.batchPreSignerUrl);
258		console.log('[STAAutofirmaLote] batchPostSignerUrl = ' + params.batchPostSignerUrl);				
259					
260        AutoScript.signBatchProcess(
261            stopOnError,
262            batchPreSignerUrl,
263            batchPostSignerUrl,
264            certFilters,
265
266            // Callback de éxito
267            function (batchResult) {
268                console.log('[STAAutofirmaLote] Firma de lote completada con éxito.');
269                if (typeof onSuccess === 'function') {
270                    var resultado = batchResult;
271                    if (typeof batchResult === 'string') {
272                        try {
273                            resultado = JSON.parse(batchResult);
274                        } catch (e) {
275                            resultado = { raw: batchResult };
276                        }
277                    }
278                    onSuccess(resultado);
279                }
280            },
281
282            // Callback de error
283            function (errorType, errorMsg) {
284                var msg = '[STAAutofirmaLote] Error en la firma de lote. ' +
285                          'Tipo: ' + errorType + ' | Mensaje: ' + errorMsg;
286                console.error(msg);
287                if (typeof onError === 'function') {
288                    onError(errorType, errorMsg);
289                }
290            }
291        );
292    }
293
294    // -------------------------------------------------------------------------
295    // API pública
296    // -------------------------------------------------------------------------
297
298    return {
299        /**
300         * Lanza el proceso de firma por lotes trifásica con AutoFirma.
301         *
302         * @param {Object}   params     - Objeto JSON de AutofirmaLoteSignInfo.
303         * @param {Function} onSuccess  - Callback de éxito: function(batchResult).
304         * @param {Function} onError    - Callback de error:  function(errorType, errorMsg).
305         */
306        firmarLote: firmarLote
307    };
308
309}());