Skip to main content

API Rest - Upload client example

work in progress, la documentazione di seguito è parziale e non ancora completa

Di seguito verranno riportati codici di esempio utili per creare un client che interagisca correttamente con i server.

Upload API  - V4V1 - curl

curl --location --request POST "'https://digital-archive-upload.test.teamsystem.digital/v4/digital/v1/input-package"package' \
--header "'accept: application/json"json' \
--header "'X-App-Name: <app_name>"' \
--header "'X-App-Version: <app_version>"' \
--header "'X-Request-ID: <request_id>"' \
--header "'X-Correlation-ID: "<correlation_id>"' \
--header "'X-User-ID: <user_id>"' \
--header "'Authorization: <bearer_token>" \
--header "Content-Type: application/json"' \
--form "'fileMetadata=\"{\\\"hash_256\\\":\\\"<file_hash>\\\a66593d9627f4a8f84ac6554bc8e75f50985bdac8eac70e7d4835b3a945d4e5d\",\\\"name\\\":\\\"<file_name.eml>\\\file_name_1667815432976.xml\",\\\"externalApplicationId\\\":\\\"<external_application_id>\\\test\"}\";type=application/json"json' \
--form "'details=\"{  \\\"tipologia_documentale\\\": \\\"2056\\\1001\",  \\\"soggetti\\\": [{  \"tipo\": \"PG\",  \"ruolo\": \"SER\",  \"denominazione\": \"Test Spa\",  \"codice_fiscale\": \"12345677889\",  \"id_paese\": \"IT\"},{  \"tipo\": \"PG\",  \"ruolo\": \"DESTINATARIO\",  \"denominazione\": \"Test Spa\",  \"codice_fiscale\": \"12345677889\",  \"id_paese\": \"IT\"}  ],  \\\"custom_metadata\\\": {},
  \\\"modalita_formazione\\\tipo_formato\": \"FPR12\",\"identificativo_sdi\": \"aaabbbccccddd\",\"codice_tipo_documento\": \"TD01\"  },  \"modalita_formazione\": \"A\\\",  \\\"riservato\\\": false,  \\\"verifica\": {\"firmato_digitalmente\": true,\"sigillato_elettronicamente\": false,\"marcatura_temporale\": false,\"conformita_copie_immagine\": false  },  \"versione\": \"1\",  \"anno_riferimento\": 2022,  \"allegati\": { \\\"firmato_digitalmente\\\": true,
    \\\"sigillato_elettronicamente\\\": false,
    \\\"marcatura_temporale\\\": false,
    \\\"conformita_copie_immagine\\\": false
  },
  \\\"versione\\\": \\\"1\\\",
  \\\"anno_riferimento\\\": 2022,
  \\\"allegati\\\": { \\\"numero_allegati\\\": 0 },  \\\"chiave_descrittiva\\\": { \\\"oggetto\\\": \\\"Altre Comunicazioni\\\" },  \\\"dati_registrazione\\\": {
    \\\"tipologia_flusso\\\": \\\"I\\\U\",
    \\\"tipo_registro\\\": \\\"NESSUNO\\\",
    \\\"data\\\": \\\"2022-12-30T23:00:00.000Z\\\",
    \\\"numero\\\": \\\"2022\\\"  }
}
\";type=application/json"json' \
--form 'holderUuid="holder=\"{\\\4633c44b-02ce-4c8c-aada-7f7385d3ef29\"countryId\\\":\\\"IT\\\",\\\"taxId\\\":\\\"tax_id\\\",\\\"vatNumber\\\":\\\"vat_number\\\"}\";type=application/json"json' \
--form 'submitterUuid="submitter=\"{\\\4633c44b-02ce-4c8c-aada-7f7385d3ef29\"username\\\":\\\"submitter_username\\\"}\";type=application/json"json' \
--form "'file=@\"1m\""@"/home/cicuz/Desktop/fastlane-docs/original.xml"

Upload API  - V4V1 - C#

using System.Net.Http;

using (var client = new HttpClient())
{
    String destinationPostUri = this.Configuration.ApiClient.Configuration.BasePath + "/v4/digital/v1/input-package";
    client.Timeout = new TimeSpan(0, 10, 0);
    client.MaxResponseContentBufferSize = 320*1024*1024;

    client.DefaultRequestHeaders.Add("cache-control", "no-cache");
    client.DefaultRequestHeaders.Add("accept", "application/json");
    client.DefaultRequestHeaders.Add("Connection", "keep-alive");
    client.DefaultRequestHeaders.Add("User-Agent", this.Configuration.ApiClient.ParameterToString(userAgent));
    client.DefaultRequestHeaders.Add("X-App-Name", this.Configuration.ApiClient.ParameterToString(xAppName));
    client.DefaultRequestHeaders.Add("X-App-Version", this.Configuration.ApiClient.ParameterToString(xAppVersion));
    client.DefaultRequestHeaders.Add("X-Request-ID", this.Configuration.ApiClient.ParameterToString(xRequestID)); // header parameter
    client.DefaultRequestHeaders.Add("X-Correlation-ID", this.Configuration.ApiClient.ParameterToString(xCorrelationID)); // header parameter
    client.DefaultRequestHeaders.Add("X-User-ID", this.Configuration.ApiClient.ParameterToString(xUserID)); // header parameter
    client.DefaultRequestHeaders.Add("X-Item-ID", this.Configuration.ApiClient.ParameterToString(xItemID)); // header parameter
    client.DefaultRequestHeaders.Add("X-Manager-ID", this.Configuration.ApiClient.ParameterToString(xManagerID)); // header parameter
    client.DefaultRequestHeaders.Add("Authorization", "Bearer " + this.Configuration.AccessToken)xUserID.SecurityToken.Replace("Bearer", "").Trim());
    client.DefaultRequestHeaders.Add("Accept", "*/*");

    logManager.LogInfo($"destinationPostUri: {destinationPostUri} fileMetadata: {fileMetadata.ToJson()} {Environment.NewLine}  details: {details.ToJson()} submitter: {submitter.ToJson()} holder: {holder.ToJson()} ");

    // we need to send a request with multipart/form-data
    var multiForm = new MultipartFormDataContent("----MyBoundary");

    // add API method parameters
    multiForm.Add(new StringContent(fileMetadata.ToJson(), Encoding.UTF8, "application/json"), "fileMetadata");
    multiForm.Add(new StringContent(details.ToJson(), Encoding.UTF8, "application/json"), "details");
    multiForm.Add(new StringContent(holder.ToJson()$"\"{holderUuId}\"", Encoding.UTF8, "application/json"), "holder"holderUuid");
    multiForm.Add(new StringContent(submitter.ToJson()$"\"{submitterUuId}\"", Encoding.UTF8, "application/json"), "submitter"submitterUuid");
    multiForm.Add(new StreamContent(new MemoryStream(fileContent)), "file", fileMetadata.Name);

    // send request to API
    var response = await client.PostAsync(destinationPostUri, multiForm);

    if (response.StatusCode != System.Net.HttpStatusCode.Created)
    {
      throw EvaluateAndThrowException(response, fileMetadata.Name, fileMetadata.Hash256, submitter.Username,submitterUuId, xCorrelationID);
    }
    else
    {
      String result = response.Content.ReadAsStringAsync().Result;
      return new ApiResponse<UploadResponse>((int)response.StatusCode,
                                             response.Headers.ToDictionary(x => x.Key, x => string.Join(",", x.Value)),
                                             (UploadResponse)JsonConvert.DeserializeObject(result, typeof(UploadResponse), this.Configuration.ApiClient.serializerSettings));
    }
}

Upload API - V4V1 - Nodejs (axios)

const axiosrequest = require("axios");
const FormData = require("form-data"request");
const fs = require("fs");

const datauriToInvoke = newarchiveListenerPusherEnvironment.getInputPackagedigitalV1ApiBaseUrl() FormData()+ "/digital/v1/backoffice/input-package";
(asyncconsole.log(`Invoking (of ${uriToInvoke} fileMetadata: ${fileMetadataPayload} details: ${detailsPayload}`) => {
  const fileMetadata = {
    hash_256: "<file_hash>",
    name: "<file_name.eml>",
    externalApplicationId: "<external_application_id>",
  };

const details = {
    tipologia_documentale: "2056",
    soggetti: [],
    custom_metadata: {},
    modalita_formazione: "A",
    riservato: false,
    verifica: {
      firmato_digitalmente: true,
      sigillato_elettronicamente: false,
      marcatura_temporale: false,
      conformita_copie_immagine: false,
    },
    versione: "1",
    anno_riferimento: 2022,
    allegati: { numero_allegati: 0 },
    chiave_descrittiva: { oggetto: "Altre Comunicazioni" },
    dati_registrazione: {
      tipologia_flusso: "I",
      tipo_registro: "NESSUNO",
      data: "2022-12-30T23:00:00.000Z",
      numero: "2022",
    },
  };

  const holder = {
    countryId: "IT",
    taxId: "tx_id",
    vatNumber: "vat_number",
  };

  const submitter = { username: "submitter_username" };

  // Add the required fields to the multipart payload
  data.append("fileMetadata", JSON.stringify(fileMetadata), {
    contentType: "application/json",
  });
  data.append("details", JSON.stringify(details), {
    contentType: "application/json",
  });
  data.append("holder", JSON.stringify(holder), {
    contentType: "application/json",
  });
  data.append("submitter", JSON.stringify(submitter), {
    contentType: "application/json",
  });

  // Add the file as a stream to the multipart payload
  data.append("file", fs.createReadStream("./file_path"));

  // Configure the request object
  const configoptions = {
  method: "post"POST",
  url: "https://digital-archive-upload.test.teamsystem.digital/v4/input-package",uriToInvoke,
  headers: {
    accept:"accept": "application/json",
    "Accept": "*/*",
    "X-App-Name": "<app_name>"archiveListenerPusherEnvironment.getAppName(),
    "X-App-Version": "<app_version>"archiveListenerPusherEnvironment.getAppVersion(),
    "X-Request-ID": "<request_id>"uuidv1(),
    "X-Correlation-ID": "<correlation_id>",correlationId,
    "X-User-ID": "<user_id>"archiveListenerPusherEnvironment.getAppName(),
    Authorization:"X-Item-ID": archiveListenerPusherEnvironment.getAppName(),
    "<auth_token>X-Manager-ID": payload.getSubmitterUuid(),
    "Authorization": "Bearer " + archiveListenerPusherEnvironment.getInputPackagedigitalV1ApiM2MToken(),
    "Content-Type": "application/json",
    ...data.getHeaders("cache-control": "no-cache",
    "Connection": "keep-alive",
    "User-Agent": archiveListenerPusherEnvironment.getAppName(),
  },
  data:formData: data,{
    fileMetadata: {
      value: fileMetadataPayload,
      options: {
        contentType: "application/json"
      }
    },
    details: {
      value: detailsPayload,
      options: {
        contentType: "application/json"
      }
    },
    holderUuid: {
      value: `"${payload.getHolderUuid()}"`,
      options: {
        contentType: "application/json"
      }
    },
    submitterUuid: {
      value: `"${payload.getSubmitterUuid()}"`,
      options: {
        contentType: "application/json"
      }
    },
    file: {
      value: fs.createReadStream(resourceToUpload),
      options: {
        filename: payload.getFileMetadata().getName(),
        contentType: "application/octet-stream"
      }
    }
  }
};

tryrequest(options, (error, response, body) => {
  //if Perform(error) thethrow requestnew constError(error);
  responseif (response.statusCode !== await200) axios(config);{
    console.log("PRESERVATIONthrow ID",new Error(response.data)statusMessage);
  }
  catchconst (error)entity {= console.error(error)JSON.parse(body);
  }return entity;
})();

Upload API - V4V1 - Java (OkHttpClient)

OkHttpClient client = new OkHttpClient().newBuilder().build();
MediaType mediaType = MediaType.parse("application/json");

String fileMetadataPayload = getPayload(payload.getFileMetadata());
String detailsPayload = getPayload(payload.getDetails());
String uriToInvoke = archiveListenerPusherEnvironment.getInputPackagedigitalV1ApiBaseUrl() + "/digital/v1/backoffice/input-package";
log.info(m, "Invoking of " + uriToInvoke + " fileMetadata: " + fileMetadataPayload + " details: " + detailsPayload);

RequestBody body = new MultipartBody.Builder().setType(MultipartBody.FORM)
  .addFormDataPart("fileMetadata", null,
                   RequestBody.create(MediaType.parse("application/json"),fileMetadataPayload.getBytes(StandardCharsets.UTF_8) "{\"hash_256\":\"<hash_file>\",\"name\":\"<file_name.eml>\",\"externalApplicationId\":\"<external_application_id>\"}".getBytes()))
  .addFormDataPart("details", null,
                   RequestBody.create(MediaType.parse("application/json"), "{
  \"tipologia_documentale\": \"2056\",
  \"soggetti\": [],
  \"custom_metadata\": {},
  \"modalita_formazione\": \"A\",
  \"riservato\": false,
  \"verifica\": {
    \"firmato_digitalmente\": true,
    \"sigillato_elettronicamente\": false,
    \"marcatura_temporale\": false,
    \"conformita_copie_immagine\": false
  },
  \"versione\": \"1\",
  \"anno_riferimento\": 2022,
  \"allegati\": { \"numero_allegati\": 0 },
  \"chiave_descrittiva\": { \"oggetto\": \"Altre Comunicazioni\" },
  \"dati_registrazione\": {
    \"tipologia_flusso\": \"I\",
    \"tipo_registro\": \"NESSUNO\",
    \"data\": \"2022-12-30T23:00:00.000Z\",
    \"numero\": \"2022\"
  }
}
".detailsPayload.getBytes()StandardCharsets.UTF_8)))
  .addFormDataPart("holder"holderUuid", null,
                   RequestBody.create(MediaType.parse("application/json"), "{\"countryId\": + payload.getHolderUuid() + "\"IT\",\"taxId\":\"<tax_id>\",\"vatNumber\":\"<vat_number>\"}".getBytes()))
  .addFormDataPart("submitter"submitterUuid", null,
                   RequestBody.create(MediaType.parse("application/json"), "{\"username\": + payload.getSubmitterUuid() + "\"<submitter_username>\"}".getBytes()))
  .addFormDataPart("file","file_name" payload.getFileMetadata().getName(),
                   RequestBody.create(MediaType.parse("application/octet-stream"), new File("file_path"))resourceToUpload))
  .build();

//https://digital-archive-upload.test.teamsystem.digital/digital/v1/backoffice/input-package
Request request = new Request.Builder()
  .url("https://digital-archive-upload.test.teamsystem.digital/v4/input-package")uriToInvoke)
  .method("POST", body)
  .addHeader("accept", "application/json")
  .addHeader("Accept", "*/*")
  .addHeader("X-App-Name", "<app_name>"archiveListenerPusherEnvironment.getAppName())
  .addHeader("X-App-Version", "<app_version>"archiveListenerPusherEnvironment.getAppVersion())
  .addHeader("X-Request-ID", "<request_id>"UUID.randomUUID().toString())
  .addHeader("X-Correlation-ID", "<correlation_id>")correlationId)
  .addHeader("X-User-ID", archiveListenerPusherEnvironment.getAppName())
  .addHeader("<user_id>X-Item-ID", archiveListenerPusherEnvironment.getAppName())
  .addHeader("X-Manager-ID", payload.getSubmitterUuid())
  .addHeader("Authorization", "<auth_token>Bearer " + archiveListenerPusherEnvironment.getInputPackagedigitalV1ApiM2MToken())
  .addHeader("Content-Type", "application/json")
  .addHeader("cache-control", "no-cache")
  .addHeader("Connection", "keep-alive")
  .addHeader("User-Agent", archiveListenerPusherEnvironment.getAppName())
  .addHeader("Content-Type", "application/json")
  .build();


Response response = client.newCall(request).execute();
if (!response.isSuccessful()) {
  throw new Exception(response.message());
}
ResponseBody responseBody = response.body();
if (responseBody == null)
{
  throw new UnexpectedException("Response body from digital v1 is null. Unexpected empty response");
}
DigitalV1Response entity = mapper.readValue(responseBody.string(), DigitalV1Response.class);
return entity;

 

Back to top