Massen-SMS (Bulk) Sendung löschen

DELETE

/bulks/{id}

Entfernen Sie die Bulk-Sendung nach der ID . Endpunkt-Antwort hat keinen Body und sendet im Erfolgsfall den HTTP-Code 204, wenn die SMS entfernt wurde, oder 404, wenn sie nicht existiert. Achtung! Die Sendung wird auch aus dem Einzelverbindungsnachweis gelöscht. Spätere Reklamationen sind daher wegen fehlender Rückverfolgbarkeit ausgeschlossen.

Authorizations

token

Parameters

Path Parameters

required

string

Bulk ID

Responses

204

Die Entität wurde gelöscht

401

Kunden-Nr oder API Key sind ungültig oder inaktiv!

403

Account ist noch nicht innerhalb von 24h nach Registrierung aktiviert. Bitte warten oder Support kontaktieren

404

Quelle nicht gefunden

429

Die IP-Adresse wurde vorübergehend blockiert, da in kurzer Zeit viele Anfragen mit ungültigen Anmeldeinformationen gesendet wurden. Bitte warten Sie und versuchen Sie es später.

Code Samples

#!/usr/bin/env bash
curl -X DELETE https://api.lox24.eu/bulks/da0fa78c-4699-11ea-a637-96000028b339 \
  -H 'X-LOX24-AUTH-TOKEN: 1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx'

using Newtonsoft.Json.Linq;
using System;
using System.IO;
using System.Net;
using System.Text;

namespace Lox24.Api
{
    class client
    {
        static void Main()
        {
            string key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";

            var id = "851b600d-901e-11ea-aa81-96000028b339";
            string url = "https://api.lox24.eu/bulks/" + id;

            var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
            httpWebRequest.ReadWriteTimeout = 100000;
            httpWebRequest.Accept = "application/json";
            httpWebRequest.Method = "DELETE";
            //httpWebRequest.KeepAlive = true;
            httpWebRequest.Headers.Add("X-LOX24-AUTH-TOKEN", key);
            httpWebRequest.Credentials = CredentialCache.DefaultNetworkCredentials;

            try
            {
                using (HttpWebResponse resp = (HttpWebResponse)httpWebRequest.GetResponse())
                {
                    int respCode = (int)resp.StatusCode;
                    if(resp.StatusCode == HttpStatusCode.NoContent) { //204
                        Console.WriteLine("Success: bulk was deleted");
                    } else {
                        Console.WriteLine("Error: something went wrong, code({0})", respCode);
                        Stream respStream = resp.GetResponseStream();
                        using (StreamReader sr = new StreamReader(respStream, Encoding.UTF8))
                        {
                            string responseText = sr.ReadToEnd();

                            JObject parsed = JObject.Parse(responseText);

                            foreach (var pair in parsed)
                            {
                                Console.WriteLine("{0}: {1}", pair.Key, pair.Value);
                            }
                        }
                    }

                }

            }
            catch (System.Net.WebException ex)
            {
                var webResponse = ex.Response as System.Net.HttpWebResponse;
                Console.WriteLine("Error:{0}", webResponse.StatusCode);

                switch (webResponse.StatusCode)
                {
                    case HttpStatusCode.Unauthorized: // 401
                        Console.WriteLine("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpStatusCode.Forbidden: // 403
                        Console.WriteLine("Error:403 Account isn't activated. Please wait or contact to support!");
                        break;
                    case HttpStatusCode.NotFound: // 404
                        Console.WriteLine("Error:404 Resource not found");
                        break;
                    case HttpStatusCode.InternalServerError: // 500
                    case HttpStatusCode.BadGateway: //502
                    case HttpStatusCode.ServiceUnavailable: // 503
                    case HttpStatusCode.GatewayTimeout: // 504
                        Console.WriteLine("System error! Please contact to LOX24 support!");
                        break;
                }
            }
        }
    }

package main

import (
  "fmt"
  "log"
  "net/http"
)

func main() {

  const Method = "DELETE"
  const URL = "https://api.lox24.eu/bulks/981f6497-a03e-11ea-b2e9-b8ca3a65338c"
  const Token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"


  client := &http.Client{}

  req, err := http.NewRequest(Method, URL, nil)
  if err != nil {
    log.Fatal(err)
  }

  req.Header.Add("X-LOX24-AUTH-TOKEN", Token)
  req.Header.Add("Accept", "application/json")

  res, err := client.Do(req)
  if err != nil {
    log.Fatal(err)
  }

  defer res.Body.Close()

  switch res.StatusCode {
  case 204:
    fmt.Println("Bulk and related sms was deleted!")
  case 401:
    fmt.Println("Error: code = 401 - Client ID or API key isn't active or invalid!")
  case 403:
    fmt.Println("Error: code = 403 - Account isn't activated. Please wait or contact to support!")
  case 404:
    fmt.Println("Error: code = 404 - Resource not found")
  default:
    fmt.Printf("Error: code = %d\n", res.StatusCode)
  }
}

package eu.lox24.doc.bulks;

import org.json.JSONObject;

import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class DeleteBulksItem {

    public static void main(String[] args) {

        var key = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";

        var id = "851b600d-901e-11ea-aa81-96000028b339";
        var url = "https://api.lox24.eu/bulks/" + id;

        var httpRequest = HttpRequest.newBuilder(URI.create(url))
                .timeout(Duration.ofMillis(100000))
                .setHeader("Accept", "application/json") // or application/ld+json
                .setHeader("X-LOX24-AUTH-TOKEN", key)
                .DELETE()
                .build();

        var client = HttpClient.newBuilder()
                .version(HttpClient.Version.HTTP_1_1) // Http 1.1 clients are kept alive be default
                .build();

        try {
            var httpResponse = client.send(httpRequest, HttpResponse.BodyHandlers.ofString());

            if (httpResponse.statusCode() == HttpURLConnection.HTTP_NO_CONTENT) {
                System.out.println("Success: bulk was deleted");
                System.out.println("Response text : \n" + httpResponse.body());

            } else {

                System.out.println("Error: something went wrong " + httpResponse.statusCode());
                System.out.println("Response text : \n" + httpResponse.body());

                JSONObject parsed = new JSONObject(httpResponse.body());

                parsed.keys().forEachRemaining(jsonKey -> System.out.println(jsonKey + ":" + parsed.get(jsonKey)));


                switch (httpResponse.statusCode()) {

                    case HttpURLConnection.HTTP_UNAUTHORIZED: // 401
                        System.out.println("Error:401 Client ID or API key isn't active or invalid!");
                        break;
                    case HttpURLConnection.HTTP_FORBIDDEN: // 403
                        System.out.println("Error:403 Account isn't activated. Please wait or contact to support!");
                        break;
                    case HttpURLConnection.HTTP_NOT_FOUND: // 404
                        System.out.println("Error:404 Resource not found");
                        break;
                    case HttpURLConnection.HTTP_INTERNAL_ERROR: // 500
                    case HttpURLConnection.HTTP_BAD_GATEWAY: //502
                    case HttpURLConnection.HTTP_UNAVAILABLE: // 503
                    case HttpURLConnection.HTTP_GATEWAY_TIMEOUT: // 504
                        System.out.println("System error! Please contact to LOX24 support!");
                        break;
                }

            }

        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

const host = 'api.lox24.eu';
const token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx";

var id = '20f39273-0566-11ea-a637-96000028b339';

const https = require('https');
const options = {
    hostname: host,
    path: '/bulks/' + id,
    method: 'DELETE',
    headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'X-LOX24-AUTH-TOKEN': token
    }
}

const req = https.request(options, res => {
    if (res.statusCode == 204) {
        console.log("Success: code = 204 - bulks resource deleted");
        res.on('data', d => { process.stdout.write(d) })
    } else if (res.statusCode == 401) {
        console.log("Error: code = 401 - Client ID or API key isn't active or invalid!");
    } else if (res.statusCode == 403) {
        console.log("Error: code = 403 - Account isn't activated. Please wait or contact to support!");
    } else if (res.statusCode == 404) {
        console.log("Error: code = 404 - Resource not found");
    }  else {
        console.log("Error: code = " + res.statusCode );
    }
})

req.on('error', error => {
    console.error(error)
})

req.end();

<?php

$token = '1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx';

$id = '11111111-2222-3333-4444-55555555555';
$uri = 'https://api.lox24.eu/bulks/' . $id;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $uri,
    CURLOPT_CUSTOMREQUEST => 'DELETE',
    CURLOPT_HTTPHEADER => [
        "X-LOX24-AUTH-TOKEN: {$token}",
        'Accept: application/json', // or application/ld+json
    ],
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_TIMEOUT => 20,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
]);

$response = curl_exec($curl);
$code = curl_getinfo($curl, CURLINFO_HTTP_CODE);
curl_close($curl);

if(204 === $code) {
    echo "Bulk with id = {$id} was deleted!";
} elseif(404 === $code) {
    echo "Bulk with id = {$id} not found!";
} else {
    $data = json_decode($response, JSON_OBJECT_AS_ARRAY);
    echo "Error: code = {$code}, data = " . var_export($data, true);
}

import json
import requests


token = "1234567:e3f3a759b6677959b6ebfcxxxxxxxxxx"

bulk_id = "851b600d-901e-11ea-aa81-96000028b339"

url = f'https://api.lox24.eu/bulks/{bulk_id}'


headers = {
    'Accept': 'application/json', # or application/ld+json
    'X-LOX24-AUTH-TOKEN': token,
}

try:
    # timeout is 100 seconds
    res = requests.delete(url, headers=headers, timeout=100)
    if res.status_code != 204: # No Content
        res.raise_for_status()
    else:
        print(f'Success: code = {res.status_code} - bulk was deleted')

except requests.HTTPError:
    if res.status_code == 401:
        print("Error: code = 401 - Client ID or API key isn't active or invalid!")
    elif res.status_code == 403:
        print("Error: code = 403 - Account isn't activated. Please wait or contact to support!")
    elif res.status_code == 404:
        print("Error: code = 404 -  Resource not found")
    elif res.status_code in (500, 502, 503, 504):
        print("System error! Please contact to LOX24 support!")
    else:
        print(f"Error: code {res.status_code}")
    print(json.dumps(res.json(), indent=4))