AI Scoring API: Datei senden

// Dateiprobe in C # senden

Öffentlichkeit Klasse Sendfilestatus
{
   Öffentlichkeit bool success { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge message { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge file_name { bekommen; einstellen; }
   Öffentlichkeit Zeichenfolge file_id { bekommen; einstellen; }
}

Privat statisch leere Sendfileapitest()
{
   Zeichenfolge fileFullPath = $"vollständiger dateipfad einer csv- oder txt-datei";  //erforderlich
   Zeichenfolge apiKey = "hier durch deinen api-schlüssel ersetzen";  //erforderlich       
   int emailAddressColumn = 2;  //erforderlich
   int? ipAddressColumn = 11;  //Optional
   bool? hasHeaderRow = Wahr;  //Optional
   Zeichenfolge returnUrl = null;  //Optional

   VERSUCHEN
   {
       Sendfilestatus sendFileStatus = Datei senden(fileFullPath, apiKey, emailAddressColumn, ipAddressColumn, hasHeaderRow, returnUrl).Result;
       Console.Schreiben(JsonConvert.Serializeobject(sendFileStatus, Formatting.Indented));
   }
   Fang (Ausnahme ex)
   {
       Console.Schreiben(ex.InnerException.Message);
   }

   Console.Schlüssel einlesen();
}

Öffentlichkeit statisch asynchron Task<SendFileStatus> Datei senden(Zeichenfolge fileFullPath, Zeichenfolge apiKey, int emailAddressColumn, 
                                           int? ipAddressColumn = null, bool? hasHeaderRow = null, Zeichenfolge returnUrl = null)
{
   OB (Zeichenfolge.Isnullorempty(fileFullPath))
       Werfen NEU Ausnahme("Fehler: fileFullPath ist erforderlich");
   OB (Zeichenfolge.Isnullorempty(apiKey))
       Werfen NEU Ausnahme("Fehler: apiKey ist erforderlich");

   var fi = NEU Dateiinformation(fileFullPath);
   var fileContents = File.Readallbytes(fi.FullName);
   var fileName = fi.Name;

   Uri uri = NEU Uri(@"https://bulkapi.zerobounce.net/v2/scoring/sendfile");

   Verwenden (var client = NEU Httpclient())
   Verwenden (var request = NEU Httprequestmessage(HttpMethod.Post, uri))
   {
       Multipartformdatacontent multiPartContent = NEU Multipartformdatacontent();
       Bytearray-Inhalt byteArrayContent = NEU Bytearray-Inhalt(fileContents);
       byteArrayContent.Headers.Hinzufügen("Inhaltstyp", "text / csv");
       multiPartContent.Hinzufügen(byteArrayContent, "datei", fileName);
       multiPartContent.Hinzufügen(NEU String-Inhalt(apiKey), "api-schlüssel");
       multiPartContent.Hinzufügen(NEU String-Inhalt(emailAddressColumn.Tostring()), "email_address_column");
       OB (ipAddressColumn != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt(ipAddressColumn.Tostring()), "ip_address_column");
       OB (hasHeaderRow != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt((hasHeaderRow == Wahr) ? "wahr" : "falsch"), "has_header_row");
       OB (returnUrl != null)
           multiPartContent.Hinzufügen(NEU String-Inhalt(returnUrl.Tostring()), "return_url");

       request.Content = multiPartContent;

       Verwenden (var response = erwarten client.Sendasync(request, HttpCompletionOption.ResponseContentRead, CancellationToken.None).Configurewawait(Falsch))
       {
           var content = erwarten response.Content.Readasstringasync();

           OB (response.IsSuccessStatusCode == Falsch)
           {
               var error = $"StatusCode = {(int) response.StatusCode}, Content = {content}";
               Werfen NEU Ausnahme(error);
           }

           Rückkehr JsonConvert.Objekt deserialisieren<Sendfilestatus>(content);
       }
   }
}
   

 <?php

$ curl = curl_init();

curl_setopt_array($ curl, array(
 CURLOPT_URL => "https://bulkapi.zerobounce.net/v2/scoring/sendfile",
 CURLOPT_RETURNTRANSFER => Wahr,
 CURLOPT_ENCODING => "",
 CURLOPT_MAXREDIRS => 10,
 CURLOPT_TIMEOUT => 30,
 CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
 CURLOPT_CUSTOMREQUEST => "POST",
 CURLOPT_POSTFIELDS => "------ WebKitFormBoundary7MA4YWxkTrZu0gW Inhaltsdisposition: Formulardaten; name ="api-schlüssel"Ersetzen durch Ihre ------ WebKitFormBoundary7MA4YWxkTrZu0gW Inhaltsdisposition: Formulardaten; Name ="email_address_column"Ersetzen durch Ihre ------ WebKitFormBoundary7MA4YWxkTrZu0gW--",
 CURLOPT_HTTPHEADER => array(
   Postboten-Token: fae6714d-dc09- 4 e08-b50d-c97030603b61,
   "cache-kontrolle: kein cache",
   "Inhaltstyp: mehrteilig / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 ),
));

$ antwort = curl_exec($ curl);
$ err = curl_error($ curl);

curl_close($ curl);

OB ($ err) {
 echo "Curl-Fehler #:" . $ err;
} sonst {
 echo $ antwort;
}
?>
   

 Okhttpclient client = NEU Okhttpclient();

 Medientyp mediaType = Medientyp.analysieren("mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW");
 Anfrage body = Anfrage.erstellen(mediaType, "------Webkitformboundary7ma4ywxktrzu0gw
Inhalt-Anordnung: form-data; name="api-schlüssel"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw
Inhalt-Anordnung: form-data; name="email_address_column"

replacewithyours
------Webkitformboundary7ma4ywxktrzu0gw--");
 Anfrage request = NEU Anfrage.Baumeister()
   .url("https://bulkapi.zerobounce.net/v2/scoring/sendfile")
   .post(body)
   .Addheader("Inhaltstyp", "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW")
   .Addheader("cache-kontrolle", "kein cache")
   .Addheader("Postbote-Token", 25 d608ba- 6 cb5- 4 c8c- 88 d7-d47276c67d8e)
   .bauen();
 
 Antwort response = client.neuer Anruf(request).ausführen();
   

 einführen http.client

 conn = http.client.HTTPConnection("bulkapi, zerobounce, net")
 
 payload = "------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="api-schlüssel"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW
Content-Disposition: form-data; name="email_address_column"

replacewithyours
------WebKitFormBoundary7MA4YWxkTrZu0gW--"
 
 headers = {
     'inhaltstyp': "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
     'cache-kontrolle': "kein cache",
     "Postbote-Token": bc455eda- 9884-417 e-b16f- 3 a5fef3f7540
     }
 
 conn.request("POST", "v2, sendfile", payload, headers)
 
 res = conn.getresponse()
 data = res.read()
 
 drucken(data.decode("utf- 8"))
   
   

 einführen Stiftung

 lassen headers = [
   "Inhaltstyp": "mehrteilige / Formulardaten; Grenze = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
   "cache-kontrolle": "kein cache",
   "Postbote-Token": 2 f68fcc3-d9b6- 458 b-b613- 56 f6a03e6617
 ]
 lassen parameters = [
   [
     "name": "api-schlüssel",
     "wert": "ersetzen durch ihre"
   ],
   [
     "name": "email_address_column",
     "wert": "ersetzen durch ihre"
   ]
 ]
 
 lassen boundary = "---- WebKitFormBoundary7MA4YWxkTrZu0gW"
 
 var body = ""
 var error: Nserror? = null
 zum param im parameters {
   lassen paramName = param["name"]!
   body += "--(boundary)
"
   body += "Inhaltsdisposition: Formulardaten; Name ="(paramName)""
   OB lassen filename = param["Dateiname"] {
     lassen contentType = param["Inhaltstyp"]!
     lassen fileContent = Zeichenfolge(contentsOfFile: filename, encoding: Zeichenfolge.Codierung.utf8)
     OB (error != null) {
       drucken(error)
     }
     body += "; dateiname ="(filename)"
"
     body += "Inhalt-Art: (contentType)

"
     body += fileContent
   } sonst OB lassen paramValue = param["wert"] {
     body += "

(paramValue)"
   }
 }
 
 lassen request = Nsmutableurlrequest(url: NSURL(string: "https://bulkapi.zerobounce.net/v2/scoring/sendfile")! WIE url, 
                                       cachePolicy: .useProtocolCachePolicy,
                                       timeoutInterval: 10.0)
 request.httpMethod = "POST"
 request.allHTTPHeaderFields = headers
 request.httpBody = postData WIE Daten
 
 lassen session = Urlsession.shared
 lassen dataTask = session.Datenaufgabe(with: request WIE URL-Anfrage, completionHandler: { (data, response, error) -> leere im
   OB (error != null) {
     drucken(error)
   } sonst {
     lassen httpResponse = response WIE? Httpurlresponse
     drucken(httpResponse)
   }
 })
 
 dataTask.fortsetzen()
   

// Bitte wählen Sie die Sprache VB oder C # für den Import von Send Sample #  <Foundation/Foundation.h>

NSDictionary *headers = @{ @"inhaltstyp": @ "multipart / form-data; border = ---- WebKitFormBoundary7MA4YWxkTrZu0gW",
                           @ "cache-kontrolle": @ "kein cache",
                           @ "Postman-Token": @ "92 c5b06e- 624 f- 44 e5-bd86-f537bc6cef67" };
NSArray *parameters = @[ @{ @"name": @"api-schlüssel", @"wert": @ "ersetzen durch ihre" },
                         @{ @"name": @ "email_address_column", @"wert": @ "ersetzen durch ihre" } ];
NSString *boundary = @ "---- WebKitFormBoundary7MA4YWxkTrZu0gW";

NSError *error;
NSMutableString *body = [NSMutableString string];
zum (NSDictionary *param im parameters) {
   [body appendFormat:@"--%@
", boundary];
   OB (param[@"Dateiname"]) {
       [body appendFormat:@ "Inhaltsdisposition: Formulardaten; Name ="%@ "; dateiname ="%@"
", param [@"name"], param [@"fileName"]];
       [body appendFormat:@"Content-Type: %@

", param [@"contentType"]];
       [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"Dateiname"] encoding:NSUTF8StringEncoding error:&error]];
       OB (error) {
           Nslog(@"%@", error);
       }
   } sonst {
       [body appendFormat:@ "Inhaltsdisposition: Formulardaten; Name ="%@"

", param [@"name"]];
       [body appendFormat:@"%@", param[@"wert"]];
   }
}
[body appendFormat:@"
--%@--
", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://bulkapi.zerobounce.net/v2/scoring/sendfile"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                           completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                               OB (error) {
                                                   Nslog(@"%@", error);
                                               } sonst {
                                                   NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                   Nslog(@"%@", httpResponse);
                                               }
                                           }];
[dataTask resume];
   

//N/A