API de puntuación AI: estado del archivo

// Muestra de estado de archivo en C #

Público Clase Estado de los archivos
{
   Público bool success { obtener; conjunto; }
   Público Cuerda file_id { obtener; conjunto; }
   Público Cuerda file_name { obtener; conjunto; }
   Público Cuerda upload_date { obtener; conjunto; }
   Público Cuerda file_status { obtener; conjunto; }
   Público Cuerda complete_percentage { obtener; conjunto; }
   Público Cuerda return_url { obtener; conjunto; }
}

Privado estático vacío Filestatusapitest()
{
   Cuerda apiKey = "reemplace con su clave de api aquí";
   Cuerda fileID = "reemplazar con el ID de archivo devuelto al llamar a la API sendfile";

   Tratar
   {
       Estado de los archivos fileStatus = Filestatusasync(apiKey, fileID).Result;
       Console.Escribir(JsonConvert.Serializeobject(fileStatus, Formatting.Indented));
   }
   Captura (Excepción ex)
   {
       Console.Escribir(ex.InnerException.Message);
   }
   Console.Leer la clave();
}

Público estático asíncrono Task<FileStatus> Filestatusasync(Cuerda apiKey, Cuerda fileID)
{
   Si (Cuerda.Isnullorempty(apiKey))
       Lanzar NUEVO Excepción("Error: se requiere apiKey");
   Si (Cuerda.Isnullorempty(fileID))
       Lanzar NUEVO Excepción("Error: se requiere ID de archivo");

   Uri uri = NUEVO Uri($"https://bulkapi.zerobounce.net/v2/scoring/filestatus?api_key={apiKey}&file_id={fileID}");

   Utilizando (var client = NUEVO Httpclient())
   Utilizando (var request = NUEVO Httprequestmessage(HttpMethod.Get, uri))
   Utilizando (var response = esperar client.Sendasync(request).Configureawait(Falso))
   {
       var content = esperar response.Content.Readasstringasync();

       Si (response.IsSuccessStatusCode == Falso)
       {
           var error = $"StatusCode = {(int) response.StatusCode}, Content = {content}";
           Lanzar NUEVO Excepción(error);
       }

       Regreso JsonConvert.DeserializarObjeto<Estado de los archivos>(content);
   }
}
   

   <?php

   $ curl = curl_init();
   
   curl_setopt_array($ curl, formación(
     CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/filestatus?api_key=replacewithyours&file_id=replacewithyours",
     CURLOPT_RETURNTRANSFER => Cierto,
     CURLOPT_ENCODING => "",
     CURLOPT_MAXREDIRS => 10,
     CURLOPT_TIMEOUT => 30,
     CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
     CURLOPT_CUSTOMREQUEST => "OBTENER",
     CURLOPT_POSTFIELDS => "",
     CURLOPT_HTTPHEADER => formación(
       "Ficha de cartero: 91504 cea-f92f- 46 b0- 97 a4- 338167072887",
       "control de caché: sin caché"
     ),
   ));
   
   $ respuesta = curl_exec($ curl);
   $ err = curl_error($ curl);
   
   curl_close($ curl);
   
   Si ($ err) {
     eco "Error de cURL #:" . $ err;
   } más {
     eco $ respuesta;
   }
   ?>
   

   Okhttpclient client = NUEVO Okhttpclient();

   Solicitud request = NUEVO Solicitud.Constructor()
     .url("https://bulkapi.zerobounce.net/v2/scoring/filestatus?api_key=replacewithyours&file_id=replacewithyours")
     .obtener()
     .addheader("control de caché", "sin caché")
     .addheader("Ficha de cartero", "7 fffd7a4-b2fd- 4 e8b-ac85- 4099411 f27ce")
     .construir();
   
   Respuesta response = client.nueva llamada(request).ejecutar();
   

   importar http.client

   conn = http.client.HTTPConnection("bulkapi, zerobounce, net")
   
   payload = ""
   
   headers = {
       'control de caché': "sin caché",
       'Ficha de cartero': "caa917fe- 45 ce- 45 ae- 9456-2 b039b999dcb"
       }
   
   conn.request("OBTENER", "v2, estado de archivos", payload, headers)
   
   res = conn.getresponse()
   data = res.read()
   
   impresión(data.decode("utf- 8"))
   
   

   // Seleccione el lenguaje VB o C # para File Status Sampleimport Foundation

   dejar headers = [
     "control de caché": "sin caché",
     "Ficha de cartero": "4 f1b92e2- 034 f- 4 fa0- 94 d9-b097d768668a"
   ]
   
   dejar request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/scoring/filestatus?api_key=replacewithyours&file_id=replacewithyours")! COMO url,
                                           cachePolicy: .useProtocolCachePolicy,
                                       timeoutInterval: 10.0)
   request.httpMethod = "OBTENER"
   request.allHTTPHeaderFields = headers
   
   dejar session = Sesión.shared
   dejar dataTask = session.tarea de datos(with: request COMO Solicitud de url, completionHandler: { (data, response, error) -> vacío en
     Si (error != nulo) {
       impresión(error)
     } más {
       dejar httpResponse = response COMO? Httpurlresponse
       impresión(httpResponse)
     }
   })
   
   dataTask.currículum()
   

   #importar <Foundation/Foundation.h>

   NSDictionary *headers = @{ @ "control de caché": @ "sin caché",
                              @ "Cartero-Token": @"5e9c24ae-b577-4e33-8748-83f14e151ae9" };
   
   NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/scoring/filestatus?api_key=replacewithyours&file_id=replacewithyours"]
                                                          cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                      timeoutInterval:10.0];
   [request setHTTPMethod:@"OBTENER"];
   [request setAllHTTPHeaderFields:headers];
   
   NSURLSession *session = [NSURLSession sharedSession];
   NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                               completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                   Si (error) {
                                                       Nslog(@"%@", error);
                                                   } más {
                                                       NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                       Nslog(@"%@", httpResponse);
                                                   }
                                               }];
   [dataTask resume];
   

// N/A