Changeset 5d188ab in murachi


Ignore:
Timestamp:
Sep 22, 2015, 1:41:28 PM (9 years ago)
Author:
antonioaraujob <aaraujo@…>
Branches:
master
Children:
0c30a25
Parents:
6c39b8a
Message:

Agregadas funciones para a los recursos de Murachi para registrar estadísticas básicas de uso: número de firmas reaizadas, número de firmas incompletas y número de verificaciones de firmas realizadas.

Location:
murachi/src/main/java/ve/gob/cenditel/murachi
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • murachi/src/main/java/ve/gob/cenditel/murachi/MURACHIStatistic.java

    rfc4d3bb r5d188ab  
    7272           
    7373            sql = "CREATE TABLE VERIFICATIONS " +
    74                     "(VERIFICATION_ID SERIAL PRIMARY KEY NOT NULL)";
     74                    "(VERIFICATION_ID SERIAL PRIMARY KEY NOT NULL,"+
     75                        "TYPE CHAR(4) NOT NULL)";
    7576            stmt.executeUpdate(sql);                       
    7677            System.out.println("table VERIFICATIONS created!");
    … …  
    7980           
    8081            sql = "CREATE TABLE SIGNATURES_ERROR " +
    81                     "(SIGNATURE_ERROR_ID SERIAL PRIMARY KEY NOT NULL)";
     82                    "(SIGNATURE_ERROR_ID SERIAL PRIMARY KEY NOT NULL, "+
     83                        "TYPE CHAR(4) NOT NULL)";
    8284            stmt.executeUpdate(sql);
    8385            System.out.println("table SIGNATURE_ERROR created!");
    … …  
    148150   
    149151    /**
     152     * Incrementa en una unidad la cuenta de las firmas incompletas realizadas con el servicio
     153     *
     154     * @param type tipo de firma: 0->PDF, 1->BDOC
     155     *
     156     */
     157    public void incrementErrorSignatures(int type) {
     158        Connection c = null;
     159        Statement stmt = null;
     160        try {
     161           Class.forName("org.postgresql.Driver");
     162           
     163           //c = DriverManager.getConnection("jdbc:postgresql://localhost:5432/databasemurachi", databaseLogin, databasePassword);
     164           c = DriverManager.getConnection(databaseConnection, databaseLogin, databasePassword);
     165           
     166           c.setAutoCommit(false);
     167           //System.out.println("Opened database successfully");
     168
     169           stmt = c.createStatement();
     170           String signatureType = "";
     171           
     172           if (type == 0) {
     173                   signatureType = "pdf";
     174           }else if (type == 1){
     175                   signatureType = "bdoc";
     176           }else{
     177                   signatureType = "unknown";
     178           }
     179                   
     180           String sql = "INSERT INTO SIGNATURES_ERROR (TYPE) VALUES ('"+ signatureType +"');";
     181           stmt.executeUpdate(sql);
     182           stmt.close();
     183           c.commit();
     184           c.close();
     185        } catch (Exception e) {
     186                logger.error(e.getClass().getName()+": "+ e.getMessage());
     187            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
     188        }
     189        //System.out.println("Records created successfully");
     190    }
     191   
     192   
     193    /**
     194     * Incrementa en una unidad la cuenta de las verificaciones de firmas realizadas con el servicio
     195     *
     196     * @param type tipo de firma: 0->PDF, 1->BDOC
     197     *
     198     */
     199    public void incrementVerifications(int type) {
     200        Connection c = null;
     201        Statement stmt = null;
     202        try {
     203           Class.forName("org.postgresql.Driver");
     204           
     205           //c = DriverManager.getConnection("jdbc:postgresql://localhost:5432/databasemurachi", databaseLogin, databasePassword);
     206           c = DriverManager.getConnection(databaseConnection, databaseLogin, databasePassword);
     207           
     208           c.setAutoCommit(false);
     209           //System.out.println("Opened database successfully");
     210
     211           stmt = c.createStatement();
     212           String signatureType = "";
     213           
     214           if (type == 0) {
     215                   signatureType = "pdf";
     216           }else if (type == 1){
     217                   signatureType = "bdoc";
     218           }else{
     219                   signatureType = "unkn";
     220           }
     221                   
     222           String sql = "INSERT INTO VERIFICATIONS (TYPE) VALUES ('"+ signatureType +"');";
     223           stmt.executeUpdate(sql);
     224           stmt.close();
     225           c.commit();
     226           c.close();
     227        } catch (Exception e) {
     228                logger.error(e.getClass().getName()+": "+ e.getMessage());
     229            System.err.println( e.getClass().getName()+": "+ e.getMessage() );
     230        }
     231       
     232    }
     233   
     234   
     235   
     236    /**
    150237     * Retorna el número de firmas realizadas exitosamente con el servicio.
    151238     *

  • murachi/src/main/java/ve/gob/cenditel/murachi/MurachiRESTWS.java

    r6c39b8a r5d188ab  
    625625                jsonObject = verifyALocalFile(fileId);
    626626                logger.info("/firmados: " + jsonObject.toString());
    627                
     627                               
    628628                return Response.status(200).entity(jsonObject.toString()).build();
    629629        }
    … …  
    840840                                logger.info("/{"+idFile+"}: "+ result);
    841841                               
     842                                // registrar la verificacion exitosa en el contador de verificaciones
     843                                registerAVerification(1);
     844                               
    842845                                return Response.status(200).entity(result).build();
    843846                        }
    … …  
    850853                                logger.info("/{"+idFile+"}: "+ result);
    851854                               
     855                                // registrar la verificacion exitosa en el contador de verificaciones
     856                                registerAVerification(0);
     857                               
    852858                                return Response.status(200).entity(result).build();                             
    853859                        }
    … …  
    855861                        else
    856862                        {
     863                                // registrar la verificacion exitosa en el contador de verificaciones
     864                                registerAVerification(2);
     865                               
    857866                                jsonObject.put("fileExist", "true");
    858867                                jsonObject.put("error", "extension not supported");
    … …  
    956965                        String mime = getMimeType(path);
    957966                        System.out.println("mimetype : " + mime);
    958                        
    959                        
     967                                               
    960968                        if (mime.equals("application/zip")) {
    961969                                jsonObject = verifySignaturesInBdoc(path, false);
    962970                                result = jsonObject.toString();
    963971                                logger.info("/{"+idFile+"}: "+ result);
     972                               
     973                                // registrar la verificacion exitosa en el contador de verificaciones
     974                                registerAVerification(1);
    964975                               
    965976                                return jsonObject;
    … …  
    972983                                result = jsonObject.toString();
    973984                                logger.info("/{"+idFile+"}: "+ result);
     985                               
     986                                // registrar la verificacion exitosa en el contador de verificaciones
     987                                registerAVerification(0);
    974988                               
    975989                                return jsonObject;                             
    … …  
    980994                                jsonObject.put("fileExist", "true");
    981995                                jsonObject.put("error", "extension not supported");
     996                               
     997                                // registrar la verificacion exitosa en el contador de verificaciones
     998                                registerAVerification(2);
     999                               
    9821000                                return jsonObject;
    9831001                        }                       
    … …  
    18331851
    18341852                if (postsignPar == null) {
     1853                       
     1854                        // registrar error de firma en estadisticas
     1855                        registerASignatureError(0);
     1856                                               
    18351857                        logger.error("solicitud mal formada.");
    18361858                        result = "\"error\":\"solicitud mal formada\"";
     1859                       
    18371860                        return Response.status(400).entity(result).build();     
    18381861                }
    … …  
    18411864                String signature = postsignPar.getSignature();
    18421865                if (signature == null) {
     1866                       
     1867                        // registrar error de firma en estadisticas
     1868                        registerASignatureError(0);
     1869                       
    18431870                        logger.debug("signature == null");
    18441871                        logger.error("solicitud mal formada: no esta especificada la firma realizada en el cliente.");
    … …  
    18691896               
    18701897                if (fileId == null) {
     1898                       
     1899                        // registrar error de firma en estadisticas
     1900                        registerASignatureError(0);                     
     1901                       
    18711902                        System.out.println("fileId == null");
    18721903                        logger.error("Error en completacion de firma: identificador de archivo nulo");
    … …  
    18781909               
    18791910                if (stamper == null) {
     1911                        // registrar error de firma en estadisticas
     1912                        registerASignatureError(0);
     1913                       
    18801914                        System.out.println("stamper == null");
    18811915                        logger.error("Error en completacion de firma: estructura PdfStamper nula");
    … …  
    18871921               
    18881922                if (sgn == null) {
     1923                        // registrar error de firma en estadisticas
     1924                        registerASignatureError(0);
     1925
    18891926                        System.out.println("sgn == null");
    18901927                        logger.error("Error en completacion de firma: estructura PdfPKCS7 nula");
    … …  
    18951932                }
    18961933                if (hash == null) {
     1934                        // registrar error de firma en estadisticas
     1935                        registerASignatureError(0);
     1936
    18971937                        System.out.println("hash == null");
    18981938                        logger.error("Error en completacion de firma: hash nulo");
    … …  
    19021942                }
    19031943                if (cal == null) {
     1944                        // registrar error de firma en estadisticas
     1945                        registerASignatureError(0);
     1946
    19041947                        System.out.println("cal == null");
    19051948                        logger.error("Error en completacion de firma: estructura de fecha nula");
    … …  
    19101953                }
    19111954                if (sap == null) {
     1955                        // registrar error de firma en estadisticas
     1956                        registerASignatureError(0);
     1957
    19121958                        System.out.println("sap == null");
    19131959                        logger.error("Error en completacion de firma: estructura de apariencia de firma pdf nula");
    … …  
    19181964                }
    19191965                if (os == null) {
     1966                        // registrar error de firma en estadisticas
     1967                        registerASignatureError(0);
     1968
    19201969                        System.out.println("os == null");
    19211970                        logger.error("Error en completacion de firma: bytes de archivo nulos");
    … …  
    19441993                       
    19451994                }catch(DocumentException e) {
     1995                        // registrar error de firma en estadisticas
     1996                        registerASignatureError(0);
     1997
     1998                       
    19461999                        System.out.println("throw new IOException");
    19472000                        logger.error("postsignPdf: ocurrio una excepcion", e);
    … …  
    19512004                       
    19522005                } catch (IOException e) {
     2006                        // registrar error de firma en estadisticas
     2007                        registerASignatureError(0);
     2008
    19532009                        System.out.println("IOException e");
    19542010                        logger.error("postsignPdf: ocurrio una excepcion", e);
    … …  
    19842040               
    19852041                // registrar la firma exitosa en el contador de firmas
    1986                 MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
    1987                 statistic.incrementSignatures(0);
    1988                
     2042                registerASignature(0);
     2043                               
    19892044                return Response.status(200).entity(jsonFinalResult.toString()).build();
    19902045        }
    … …  
    26362691                } catch(IOException e)
    26372692                {
     2693                        // registrar error de firma en estadisticas
     2694                        registerASignatureError(1);
     2695                       
    26382696                        presignHash.setError(e.getMessage());
    26392697                        presignHash.setHash("");
    … …  
    26412699                } catch(CertificateException e)
    26422700                {
     2701                        // registrar error de firma en estadisticas
     2702                        registerASignatureError(1);
     2703
    26432704                        presignHash.setError(e.getMessage());
    26442705                        presignHash.setHash("");
    26452706                        return Response.status(500).entity(presignHash).build();
    26462707                }
    2647                        
    2648                        
     2708                                               
    26492709                // creacion del json
    26502710                JSONObject jsonHash = new JSONObject();
    … …  
    27512811                        //e.printStackTrace();
    27522812                       
     2813                        // registrar error de firma en estadisticas
     2814                        registerASignatureError(1);
     2815                       
    27532816                        JSONObject jsonError = new JSONObject();
    27542817                                               
    … …  
    27742837               
    27752838                // registrar la firma exitosa en el contador de firmas
    2776                 MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
    2777                 statistic.incrementSignatures(1);
     2839                //MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
     2840                //statistic.incrementSignatures(1);             
     2841                registerASignature(1);
    27782842               
    27792843                return Response.status(200).entity(jsonFinalResult.toString()).build();
    … …  
    28822946                    if (is == null)
    28832947                    {
     2948                        // registrar error de firma en estadisticas
     2949                                registerASignatureError(1);
     2950                               
    28842951                        logger.debug("is: null");
    28852952                        result = "\"error\":\"archivo pasado al recurso es nulo.\"";
    … …  
    40934160               
    40944161                if (presignPar == null) {
     4162                // registrar error de firma en estadisticas
     4163                        registerASignatureError(1);
     4164                       
    40954165                        logger.error("solicitud mal formada.");
    40964166                        result = "\"error\":\"solicitud mal formada\"";
    … …  
    41014171                String containerId = presignPar.getFileId();           
    41024172                if (containerId == null) {
     4173                // registrar error de firma en estadisticas
     4174                        registerASignatureError(1);
     4175                       
    41034176                        logger.debug("containerId == null");
    41044177                        logger.error("solicitud mal formada: no esta especificado el identificador del contenedor.");
    … …  
    41114184                String certHex = presignPar.getCertificate();           
    41124185                if (certHex == null) {
     4186                // registrar error de firma en estadisticas
     4187                        registerASignatureError(1);
     4188                       
    41134189                        logger.debug("certHex == null");
    41144190                        logger.error("solicitud mal formada: no esta especificado el certificado firmante en hexadecimal.");
    … …  
    41204196                String city = presignPar.getCity();
    41214197                if (city == null) {
     4198                // registrar error de firma en estadisticas
     4199                        registerASignatureError(1);
     4200                       
    41224201                        logger.debug("city == null");
    41234202                        logger.error("solicitud mal formada: no esta especificada la ciudad donde se realiza la firma.");
    … …  
    41294208                String state = presignPar.getState();
    41304209                if (state == null) {
     4210                // registrar error de firma en estadisticas
     4211                        registerASignatureError(1);
     4212                       
    41314213                        logger.debug("state == null");
    41324214                        logger.error("solicitud mal formada: no esta especificado el estado donde se realiza la firma.");
    … …  
    41384220                String postalCode = presignPar.getPostalCode();
    41394221                if (postalCode == null) {
     4222                // registrar error de firma en estadisticas
     4223                        registerASignatureError(1);
     4224                       
    41404225                        logger.debug("state == null");
    41414226                        logger.error("solicitud mal formada: no esta especificado el codigo postal donde se realiza la firma.");
    … …  
    41474232                String country = presignPar.getCountry();
    41484233                if (country == null) {
     4234                // registrar error de firma en estadisticas
     4235                        registerASignatureError(1);
     4236                       
    41494237                        logger.debug("country == null");
    41504238                        logger.error("solicitud mal formada: no esta especificado el pais donde se realiza la firma.");
    … …  
    41564244                String role = presignPar.getRole();
    41574245                if (role == null) {
     4246                // registrar error de firma en estadisticas
     4247                        registerASignatureError(1);
     4248                       
    41584249                        logger.debug("role == null");
    41594250                        logger.error("solicitud mal formada: no esta especificado el rol del firmante.");
    … …  
    41884279               
    41894280                if (!f.exists()) {
     4281                // registrar error de firma en estadisticas
     4282                        registerASignatureError(1);
     4283                       
    41904284                        logger.error("el contenedor "+ fullPathContainerId + " no existe.");
    41914285                        result = "\"error\":\"el contenedor "+ fullPathContainerId + " no existe\"";
    … …  
    43074401                } catch(IOException e)
    43084402                {
     4403                // registrar error de firma en estadisticas
     4404                        registerASignatureError(1);
     4405                       
     4406                // registrar error de firma en estadisticas
     4407                        registerASignatureError(1);
    43094408                        presignHash.setError(e.getMessage());
    43104409                        presignHash.setHash("");
    … …  
    43124411                } catch(CertificateException e)
    43134412                {
     4413                // registrar error de firma en estadisticas
     4414                        registerASignatureError(1);
     4415                       
    43144416                        presignHash.setError(e.getMessage());
    43154417                        presignHash.setHash("");
    43164418                        return Response.status(500).entity(presignHash).build();
    43174419                } catch (ClassNotFoundException e) {
     4420                // registrar error de firma en estadisticas
     4421                        registerASignatureError(1);
     4422                       
    43184423                        presignHash.setError(e.getMessage());
    43194424                        presignHash.setHash("");
    … …  
    44054510               
    44064511                if (postsignPar == null) {
     4512                // registrar error de firma en estadisticas
     4513                        registerASignatureError(1);
     4514                       
    44074515                        logger.error("solicitud mal formada.");
    44084516                        result = "\"error\":\"solicitud mal formada\"";
    … …  
    44134521                String signature = postsignPar.getSignature();
    44144522                if (signature == null) {
     4523                // registrar error de firma en estadisticas
     4524                        registerASignatureError(1);
     4525                       
    44154526                        logger.debug("signature == null");
    44164527                        logger.error("solicitud mal formada: no esta especificada la firma realizada en el cliente.");
    … …  
    44234534                String containerId = postsignPar.getContainerId();
    44244535                if (containerId == null) {
     4536                // registrar error de firma en estadisticas
     4537                        registerASignatureError(1);
     4538                       
    44254539                        logger.debug("containerId == null");
    44264540                        logger.error("solicitud mal formada: no esta especificado el identificador del contenedor.");
    … …  
    44404554               
    44414555                if (!f.exists()) {
     4556                // registrar error de firma en estadisticas
     4557                        registerASignatureError(1);
     4558                       
    44424559                        logger.error("el contenedor "+ serializedContainerId + " no existe.");
    44434560                        result = "\"error\":\"el contenedor "+ serializedContainerId + " no existe\"";
    … …  
    45354652                } catch (ClassNotFoundException e) {
    45364653                        //e.printStackTrace();
     4654               
     4655                        // registrar error de firma en estadisticas
     4656                        registerASignatureError(1);
    45374657                       
    45384658                        JSONObject jsonError = new JSONObject();
    … …  
    45444664                        return Response.status(500).entity(jsonError).build();                         
    45454665                } catch (DSSException e) {
     4666                       
     4667                // registrar error de firma en estadisticas
     4668                        registerASignatureError(1);
     4669                       
    45464670                        JSONObject jsonError = new JSONObject();
    45474671                       
    … …  
    45674691               
    45684692                // registrar la firma exitosa en el contador de firmas
    4569                 MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
    4570                 statistic.incrementSignatures(1);
    4571 
     4693                registerASignature(1);
    45724694               
    45734695                return Response.status(200).entity(jsonFinalResult.toString()).build();
    … …  
    50255147                 
    50265148                 
     5149                 
    50275150                  //statistic.incrementSignatures(0);
    50285151                 
    … …  
    50355158                  int countSignaturesError = statistic.countOfSiganturesFailed();
    50365159                  jsonObject.put("numeroDeFimasIncompletas", Integer.toString(countSignaturesError));
     5160                  logger.debug("firmas incorrectas: "+ Integer.toString(countSignaturesError));
    50375161                 
    50385162                  int countVerifications = statistic.countOfVerifications();
    50395163                  jsonObject.put("numeroDeVerificaciones", Integer.toString(countVerifications));
     5164                  logger.debug("verificaciones realizadas correctamente: "+ Integer.toString(countVerifications));
    50405165                 
    50415166                  result = jsonObject.toString();
    … …  
    50445169          }
    50455170         
     5171          /**
     5172           * Registra un evento de firma electrónica en la base de datos de estadisticas
     5173           * @param type 0-> PDF; 1->BDOC; 2->UNKN
     5174           */
     5175          private void registerASignature(int type) {
     5176                        // registrar la verificacion exitosa en el contador de verificaciones
     5177                          MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
     5178                          statistic.incrementSignatures(type);
     5179                  }
    50465180         
     5181          /**
     5182           * Registra un evento de verificacion de firma electrónica en la base de datos de estadisticas
     5183           * @param type 0-> PDF; 1->BDOC; 2->UNKN
     5184           */
     5185          private void registerAVerification(int type) {
     5186                  // registrar la verificacion exitosa en el contador de verificaciones
     5187                  MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
     5188                  statistic.incrementVerifications(type);                 
     5189          }
     5190         
     5191          /**
     5192           * Registra un evento de firma electrónica incompleta en la base de datos de estadisticas
     5193           * @param type 0-> PDF; 1->BDOC; 2->UNKN
     5194           */
     5195          private void registerASignatureError(int type) {
     5196                  // registrar la verificacion exitosa en el contador de verificaciones
     5197                  MURACHIStatistic statistic = new MURACHIStatistic(databaseHost, databasePort, databaseName, databaseLogin, databasePassword);
     5198                  statistic.incrementErrorSignatures(type);       
     5199          }
     5200     
     5201         
     5202       
     5203         
    50475204       
    50485205         
    … …  
    60166173       
    60176174       
    6018        
     6175        @POST
     6176        @Path("/phpcargas")
     6177        @Consumes(MediaType.MULTIPART_FORM_DATA)
     6178        @Produces(MediaType.APPLICATION_JSON)
     6179        @Authenticator
     6180        public Response uploadPHP(FormDataMultiPart formParams) throws MurachiException {
     6181               
     6182                logger.info("recurso /phpcargas");
     6183                logger.debug("  uploadPHP...");
     6184               
     6185                // cadena con la respuesta
     6186                String result = "";
     6187               
     6188                String fileId = "";
     6189               
     6190                if (formParams == null) {
     6191                        logger.error("solicitud mal formada.");
     6192                        result = "\"error\":\"solicitud mal formada\"";
     6193                        return Response.status(400).entity(result).build();
     6194                }
     6195               
     6196                Map<String, List<FormDataBodyPart>> fieldsByName = formParams.getFields();
     6197                logger.debug("  contenido de Map: " + Integer.toString(fieldsByName.size()));
     6198               
     6199                for (List<FormDataBodyPart> fields : fieldsByName.values())
     6200            {
     6201                for (FormDataBodyPart field : fields)
     6202                {
     6203                    InputStream is = field.getEntityAs(InputStream.class);
     6204                   
     6205                    if (is == null)
     6206                    {
     6207                        logger.debug("is: null");
     6208                        result = "\"error\":\"archivo pasado al recurso es nulo.\"";
     6209                                return Response.status(500).entity(result).build();
     6210                    }             
     6211                   
     6212                    FormDataContentDisposition file = field.getFormDataContentDisposition();               
     6213                    String fileName = file.getFileName();
     6214                    logger.debug("fileName: " + fileName);                 
     6215                    /*
     6216                    if (fileName == null)
     6217                    {
     6218                        logger.debug("fileName: null");
     6219                        result = "\"error\":\"nombre del archivo pasado al recurso es nulo. Debe especificar un nombre de archivo.\"";
     6220                                return Response.status(500).entity(result).build();
     6221                    }               
     6222                   
     6223                    String mimeType = field.getMediaType().toString();                             
     6224                    logger.debug("mimeType: " + mimeType);
     6225                   
     6226                    if (mimeType == null)
     6227                    {
     6228                        logger.debug("mimeType: null");
     6229                        result = "\"error\":\"tipo mime del archivo pasado al recurso es nulo.\"";
     6230                                return Response.status(500).entity(result).build();
     6231                    }
     6232                    */
     6233                                                   
     6234                    try
     6235                    {
     6236                        //addFileToBDOCContainer(is, fileName, mimeType, c);
     6237                       
     6238                        fileId = UUID.randomUUID().toString();
     6239                                System.out.println(fileId);
     6240                               
     6241                                saveToDisk(is, null, fileId);
     6242                        logger.info("se guardó el archivo" + fileId + "en el disco");
     6243                    }
     6244                    catch(Exception e)
     6245                    {
     6246                        logger.debug("excepcion: " + e.getMessage());                   
     6247                                result = "\"error\":\"no se pudo guardar el archivo en el servidor.\"";
     6248                                return Response.status(500).entity(result).build();
     6249                    }               
     6250                                   
     6251                }
     6252            }           
     6253               
     6254                //logger.debug("cantidad de DataFile del contenedor: " + Integer.toString(c.getDataFiles().size()));
     6255                //String fileId = UUID.randomUUID().toString();
     6256                //System.out.println("id contenedor serializado: "+fileId);
     6257                               
     6258                // establecer el nombre del archivo a serializar
     6259                //String serializedContainerId = SERVER_UPLOAD_LOCATION_FOLDER + fileId + "-serialized";
     6260                //logger.debug("        id de contenedor serializado: "+ serializedContainerId);
     6261       
     6262                result = "{\"fileId\":\""+ fileId +"\"}";
     6263                logger.debug(result);
     6264               
     6265                logger.debug("  {containerId:"+ fileId+"}");
     6266                return Response.status(200).entity(result).build();
     6267        }
    60196268       
    60206269       
Note: See TracChangeset for help on using the changeset viewer.