$ch = curl_init('http://your-server-ip:HTTP_PORT/api/gateways');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-API-Key: HTTP_API_TOKEN'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'smsc_id' => 'mysmsc-id-example',
    'host' => 'smpp.mygateway.com',
    'port' => 2775,
    'username' => 'myusername',
    'password' => 'mypassw',
    'enq_interval' => 30,
    'src_autodetect' => true,
    'dst_autodetect' => true,
    'tx_binds' => 0,
    'rx_binds' => 0,
    'trx_binds' => 1,
    'smpp_version' => '3.4',
    'is_gsm7' => true,
    'is_secure' => false,
    'enabled' => true,
]));

$response = curl_exec($ch);
curl_close($ch);

echo $response;
                        
                    

  
                        
fetch('http://your-server-ip:HTTP_PORT/api/gateways', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-API-Key': 'HTTP_API_TOKEN'
    },
    body: JSON.stringify({
        smsc_id: 'mysmsc-id-example',
        host: 'smpp.mygateway.com',
        port: 2775,
        username: 'myusername',
        password: 'mypassw',
        enq_interval: 30,
        src_autodetect: true,
        dst_autodetect: true,
        tx_binds: 0,
        rx_binds: 0,
        trx_binds: 1,
        smpp_version: '3.4',
        is_gsm7: true,
        is_secure: false,
        enabled: true
    })
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                        
                    

                        
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	url := "http://your-server-ip:HTTP_PORT/api/gateways"
	payload := map[string]interface{}{
		"smsc_id":        "mysmsc-id-example",
		"host":           "smpp.mygateway.com",
		"port":           2775,
		"username":       "myusername",
		"password":       "mypassw",
		"enq_interval":   30,
		"src_autodetect": true,
		"dst_autodetect": true,
		"tx_binds":       0,
		"rx_binds":       0,
		"trx_binds":      1,
		"smpp_version":   "3.4",
		"is_gsm7":        true,
		"is_secure":      false,
		"enabled":        true,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error making request:", err)
		return
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}
                        
                    

                        
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        JsonObject json = new JsonObject();
        json.addProperty("smsc_id", "mysmsc-id-example");
        json.addProperty("host", "smpp.mygateway.com");
        json.addProperty("port", 2775);
        json.addProperty("username", "myusername");
        json.addProperty("password", "mypassw");
        json.addProperty("enq_interval", 30);
        json.addProperty("src_autodetect", true);
        json.addProperty("dst_autodetect", true);
        json.addProperty("tx_binds", 0);
        json.addProperty("rx_binds", 0);
        json.addProperty("trx_binds", 1);
        json.addProperty("smpp_version", "3.4");
        json.addProperty("is_gsm7", true);
        json.addProperty("is_secure", false);
        json.addProperty("enabled", true);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://your-server-ip:HTTP_PORT/api/gateways"))
                .header("Content-Type", "application/json")
                .header("X-API-Key", "HTTP_API_TOKEN")
                .POST(HttpRequest.BodyPublishers.ofString(json.toString()))
                .build();

        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
                        
                    

  
                        
$ch = curl_init('http://your-server-ip:HTTP_PORT/api/clients');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'Content-Type: application/json',
    'X-API-Key: HTTP_API_TOKEN'
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
    'username' => 'myclient1',
    'password' => 'qwerty123',
    'allow_ip' => '11.22.33.44,55.66.77.88',
    'throughput' => 0,
    'binds' => 3,
    'enabled' => true,
]));

$response = curl_exec($ch);
curl_close($ch);

echo $response;
                        
                    

  
                        
fetch('http://your-server-ip:HTTP_PORT/api/clients', {
    method: 'POST',
    headers: {
        'Content-Type': 'application/json',
        'X-API-Key': 'HTTP_API_TOKEN'
    },
    body: JSON.stringify({
        username: 'myclient1',
        password: 'qwerty123',
        allow_ip: '11.22.33.44,55.66.77.88',
        throughput: 0,
        binds: 3,
        enabled: true
    })
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                        
                    

                        
package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
)

func main() {
	url := "http://your-server-ip:HTTP_PORT/api/clients"
	payload := map[string]interface{}{
		"username":       "myclient1",
		"password":       "qwerty123",
        "allow_ip":       "11.22.33.44,55.66.77.88",
		"throughput":     0,
		"binds":          3,
		"enabled":        true,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		fmt.Println("Error marshaling JSON:", err)
		return
	}

	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		fmt.Println("Error creating request:", err)
		return
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		fmt.Println("Error making request:", err)
		return
	}
	defer resp.Body.Close()

	var result map[string]interface{}
	json.NewDecoder(resp.Body).Decode(&result)
	fmt.Println(result)
}
                        
                    

                        
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();

        JsonObject json = new JsonObject();
        json.addProperty("username", "myclient1");
        json.addProperty("password", "qwerty123");
        json.addProperty("allow_ip", "11.22.33.44,55.66.77.88");
        json.addProperty("throughput", 0);
        json.addProperty("binds", 3);
        json.addProperty("enabled", true);

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://your-server-ip:HTTP_PORT/api/clients"))
                .header("Content-Type", "application/json")
                .header("X-API-Key", "HTTP_API_TOKEN")
                .POST(HttpRequest.BodyPublishers.ofString(json.toString()))
                .build();

        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
                        
                    

  
                            
$message = json_encode([
    'smsc_id' => 'mysmsc-id-example',
    'msg_id' => '074b8a96-f983-4b0b-8079-4d4c8502ff02',
    'sender' => 'Mysender',
    'receiver' => '390991234567',
    'message' => 'I am test SMS message',
]);

$nsq = fsockopen(NSQ_SMS_OUT_HOST, NSQ_SMS_OUT_PORT, $errno, $errstr, 5);

if (!$nsq) {
    exit("Connection error: $errstr ($errno)\n");
}

$body = implode("\n", [$message]);
$payload = sprintf("MPUB %s\n%s%s", NSQ_SMS_OUT_TOPIC, strlen($body), "\n" . $body);

fwrite($nsq, $payload);

fclose($nsq);
                            
                        

  
                            
const nsq = require('nsqjs');

const message = JSON.stringify({
    'smsc_id': 'mysmsc-id-example',
    'msg_id': '074b8a96-f983-4b0b-8079-4d4c8502ff02',
    'sender': 'Mysender',
    'receiver': '390991234567',
    'message': 'I am test SMS message'
});

const writer = new nsq.Writer(NSQ_SMS_OUT_HOST, NSQ_SMS_OUT_PORT);

writer.connect();

writer.on('ready', () => {
    writer.publish(NSQ_SMS_OUT_TOPIC, message, err => {
    if (err) {
        console.error('Submit error: ', err);
    } else {
        console.log('Sent to NSQ!');
    }
    writer.close();
    });
});

writer.on('closed', () => {
    console.log('Closed!');
});
                            
                        

                            
package main

import (
    "encoding/json"
    "fmt"
    "log"

    "github.com/nsqio/go-nsq"
)

type SMSMessage struct {
    SMSCID   string `json:"smsc_id"`
    MsgID    string `json:"msg_id"`
    Sender   string `json:"sender"`
    Receiver string `json:"receiver"`
    Message  string `json:"message"`
}

func main() {
    message := SMSMessage{
        SMSCID:   "mysmsc-id-example",
        MsgID:    "074b8a96-f983-4b0b-8079-4d4c8502ff02",
        Sender:   "Mysender",
        Receiver: "390991234567",
        Message:  "I am test SMS message",
    }

    messageJSON, err := json.Marshal(message)
    if err != nil {
        log.Fatalf("JSON Encoding error: %v", err)
    }

    config := nsq.NewConfig()
    nsqAddress := fmt.Sprintf("%s:%s", NSQ_SMS_OUT_HOST, NSQ_SMS_OUT_PORT)
    producer, err := nsq.NewProducer(nsqAddress, config)
    if err != nil {
        log.Fatalf("Can't init producer: %v", err)
    }

    err = producer.Publish(NSQ_SMS_OUT_TOPIC, messageJSON)
    if err != nil {
        log.Fatalf("Can't submit the message: %v", err)
    }

    fmt.Println("Sent to NSQ!")

    producer.Stop()
}
                            
                        

                            
import com.github.brainlag.nsq.NSQConfig;
import com.github.brainlag.nsq.NSQProducer;
import java.nio.charset.StandardCharsets;

public class SendSMS {
    public static void main(String[] args) {
        String message = "{\n" +
                "    \"smsc_id\": \"mysmsc-id-example\",\n" +
                "    \"msg_id\": \"074b8a96-f983-4b0b-8079-4d4c8502ff02\",\n" +
                "    \"sender\": \"Mysender\",\n" +
                "    \"receiver\": \"390991234567\",\n" +
                "    \"message\": \"I am test SMS message\"\n" +
                "}";

        try {
            sendToNSQ(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void sendToNSQ(String message) throws Exception {
        NSQConfig config = new NSQConfig();

        NSQProducer producer = new NSQProducer();
        producer.addAddress(NSQ_SMS_OUT_HOST, NSQ_SMS_OUT_PORT);

        producer.start();

        try {
            producer.produce(NSQ_SMS_OUT_TOPIC, message.getBytes(StandardCharsets.UTF_8));
            System.out.println("Sent to NSQ!");
        } finally {
            producer.shutdown();
        }
    }
}
                            
                        

  
                            
$message = json_encode([
    'client_id' => 1234,
    'msg_id' => '074b8a96-f983-4b0b-8079-4d4c8502ff02',
    'status' => 'delivered',
    'err_code' => 0,
]);

$nsq = fsockopen(NSQ_DLR_OUT_HOST, NSQ_DLR_OUT_PORT, $errno, $errstr, 5);

if (!$nsq) {
    exit("Connection error: $errstr ($errno)\n");
}

$body = implode("\n", [$message]);
$payload = sprintf("MPUB %s\n%s%s", NSQ_DLR_OUT_TOPIC, strlen($body), "\n" . $body);

fwrite($nsq, $payload);

fclose($nsq);
                            
                        

  
                            
const nsq = require('nsqjs');

const message = JSON.stringify({
    'client_id': 1234,
    'msg_id': '074b8a96-f983-4b0b-8079-4d4c8502ff02',
    'status': 'delivered',
    'err_code': 0
});

const writer = new nsq.Writer(NSQ_DLR_OUT_HOST, NSQ_DLR_OUT_PORT);

writer.connect();

writer.on('ready', () => {
    writer.publish(NSQ_DLR_OUT_TOPIC, message, err => {
    if (err) {
        console.error('Submit error: ', err);
    } else {
        console.log('Sent to NSQ!');
    }
    writer.close();
    });
});

writer.on('closed', () => {
    console.log('Closed!');
});
                            
                        

                            
package main

import (
    "encoding/json"
    "fmt"
    "log"

    "github.com/nsqio/go-nsq"
)

type DLRMessage struct {
    ClientID string `json:"client_id"`
    MsgID    string `json:"msg_id"`
    Status   string `json:"status"`
    ErrCode  string `json:"err_code"`
}

func main() {
    message := DLRMessage{
        ClientID: 1234,
        MsgID:    "074b8a96-f983-4b0b-8079-4d4c8502ff02",
        Status:   "delivered",
        ErrCode:  0,
    }

    messageJSON, err := json.Marshal(message)
    if err != nil {
        log.Fatalf("JSON Encoding error: %v", err)
    }

    config := nsq.NewConfig()
    nsqAddress := fmt.Sprintf("%s:%s", NSQ_DLR_OUT_HOST, NSQ_DLR_OUT_PORT)
    producer, err := nsq.NewProducer(nsqAddress, config)
    if err != nil {
        log.Fatalf("Can't init producer: %v", err)
    }

    err = producer.Publish(NSQ_DLR_OUT_TOPIC, messageJSON)
    if err != nil {
        log.Fatalf("Can't submit the message: %v", err)
    }

    fmt.Println("Sent to NSQ!")

    producer.Stop()
}
                            
                        

                            
import com.github.brainlag.nsq.NSQConfig;
import com.github.brainlag.nsq.NSQProducer;
import java.nio.charset.StandardCharsets;

public class SendDLR {
    public static void main(String[] args) {
        String message = "{\n" +
                "    \"client_id\": 1234,\n" +
                "    \"msg_id\": \"074b8a96-f983-4b0b-8079-4d4c8502ff02\",\n" +
                "    \"status\": \"delivered\",\n" +
                "    \"err_code\": 0,\n" +
                "}";

        try {
            sendToNSQ(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static void sendToNSQ(String message) throws Exception {
        NSQConfig config = new NSQConfig();

        NSQProducer producer = new NSQProducer();
        producer.addAddress(NSQ_DLR_OUT_HOST, NSQ_DLR_OUT_PORT);

        producer.start();

        try {
            producer.produce(NSQ_DLR_OUT_TOPIC, message.getBytes(StandardCharsets.UTF_8));
            System.out.println("Sent to NSQ!");
        } finally {
            producer.shutdown();
        }
    }
}
                            
                        

  
                        
$readerUrl = "http://NSQ_SMS_IN_HOST:NSQ_SMS_IN_PORT/channel/lookup?topic=NSQ_SMS_IN_TOPIC&channel=data";

while (true) {
    $response = file_get_contents($readerUrl);
    $messages = json_decode($response, true);

    foreach ($messages as $msg) {
        $sms = json_decode($msg['body'], true);
        print_r($sms);
    }

    sleep(1);
}
                        
                    

  
                        
const nsq = require('nsqjs');
const JSONStream = require('JSONStream');

const reader = new nsq.Reader(NSQ_SMS_IN_TOPIC, 'data', {
    nsqdTCPAddresses: `${NSQ_SMS_IN_HOST}:${NSQ_SMS_IN_PORT}`,
});

reader.connect();

reader.on('message', (msg) => {
    const messageBody = msg.body.toString();
    const sms = JSON.parse(messageBody);
    console.log(sms);
    msg.finish();
});

reader.on('error', (err) => {
    console.error('Error:', err);
});

reader.on('nsqd_connected', (host, port) => {
    console.log(`Connected to NSQD at ${host}:${port}`);
});
                        
                    

                        
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/nsqio/go-nsq"
)

type MessageHandler struct{}

func (h *MessageHandler) HandleMessage(m *nsq.Message) error {
    var sms map[string]interface{}
    if err := json.Unmarshal(m.Body, &sms); err != nil {
        log.Printf("Error unmarshalling message: %v", err)
        return err
    }
    fmt.Printf("Received SMS: %v\n", sms)
    return nil
}

func main() {
    config := nsq.NewConfig()
    address := fmt.Sprintf("%s:%d", NSQ_SMS_IN_HOST, NSQ_SMS_IN_PORT)
    consumer, err := nsq.NewConsumer(NSQ_SMS_IN_TOPIC, "data", config)
    if err != nil {
        log.Fatal(err)
    }

    consumer.AddHandler(&MessageHandler{})

    err = consumer.ConnectToNSQD(address)
    if err != nil {
        log.Fatal(err)
    }

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan

    consumer.Stop()
}
                        
                    

                        
import com.github.brainlag.nsq.NSQConsumer;
import com.github.brainlag.nsq.NSQMessage;
import com.github.brainlag.nsq.NSQConfig;
import com.github.brainlag.nsq.lookup.DefaultNSQLookup;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.Executors;
import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        DefaultNSQLookup lookup = new DefaultNSQLookup();
        lookup.addLookupAddress(NSQ_SMS_IN_HOST, NSQ_SMS_IN_PORT);

        NSQConfig config = new NSQConfig();

        NSQConsumer consumer = new NSQConsumer(
                lookup, NSQ_SMS_IN_TOPIC, "data",
                (NSQMessage message) -> {
                    String messageBody = new String(message.getMessage(), StandardCharsets.UTF_8);
                    JSONObject sms = new JSONObject(messageBody);
                    System.out.println("Received SMS: " + sms.toString());
                    message.finished();
                });

        consumer.setExecutor(Executors.newFixedThreadPool(2));

        consumer.start();
    }
}
                        
                    

  
                        
$readerUrl = "http://NSQ_DLR_IN_HOST:NSQ_DLR_IN_PORT/channel/lookup?topic=NSQ_DLR_IN_TOPIC&channel=data";

while (true) {
    $response = file_get_contents($readerUrl);
    $messages = json_decode($response, true);

    foreach ($messages as $msg) {
        $dlr = json_decode($msg['body'], true);
        print_r($dlr);
    }

    sleep(1);
}
                        
                    

  
                        
const nsq = require('nsqjs');
const JSONStream = require('JSONStream');

const reader = new nsq.Reader(NSQ_DLR_IN_TOPIC, 'data', {
    nsqdTCPAddresses: `${NSQ_DLR_IN_HOST}:${NSQ_DLR_IN_PORT}`,
});

reader.connect();

reader.on('message', (msg) => {
    const messageBody = msg.body.toString();
    const dlr = JSON.parse(messageBody);
    console.log(dlr);
    msg.finish();
});

reader.on('error', (err) => {
    console.error('Error:', err);
});

reader.on('nsqd_connected', (host, port) => {
    console.log(`Connected to NSQD at ${host}:${port}`);
});
                        
                    

                        
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "os"
    "os/signal"
    "syscall"

    "github.com/nsqio/go-nsq"
)

type MessageHandler struct{}

func (h *MessageHandler) HandleMessage(m *nsq.Message) error {
    var dlr map[string]interface{}
    if err := json.Unmarshal(m.Body, &dlr); err != nil {
        log.Printf("Error unmarshalling message: %v", err)
        return err
    }
    fmt.Printf("Received DLR: %v\n", sms)
    return nil
}

func main() {
    config := nsq.NewConfig()
    address := fmt.Sprintf("%s:%d", NSQ_DLR_IN_HOST, NSQ_DLR_IN_PORT)
    consumer, err := nsq.NewConsumer(NSQ_DLR_IN_TOPIC, "data", config)
    if err != nil {
        log.Fatal(err)
    }

    consumer.AddHandler(&MessageHandler{})

    err = consumer.ConnectToNSQD(address)
    if err != nil {
        log.Fatal(err)
    }

    sigChan := make(chan os.Signal, 1)
    signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
    <-sigChan

    consumer.Stop()
}
                        
                    

                        
import com.github.brainlag.nsq.NSQConsumer;
import com.github.brainlag.nsq.NSQMessage;
import com.github.brainlag.nsq.NSQConfig;
import com.github.brainlag.nsq.lookup.DefaultNSQLookup;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.Executors;
import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        DefaultNSQLookup lookup = new DefaultNSQLookup();
        lookup.addLookupAddress(NSQ_DLR_IN_HOST, NSQ_DLR_IN_PORT);

        NSQConfig config = new NSQConfig();

        NSQConsumer consumer = new NSQConsumer(
                lookup, NSQ_DLR_IN_TOPIC, "data",
                (NSQMessage message) -> {
                    String messageBody = new String(message.getMessage(), StandardCharsets.UTF_8);
                    JSONObject dlr = new JSONObject(messageBody);
                    System.out.println("Received DLR: " + dlr.toString());
                    message.finished();
                });

        consumer.setExecutor(Executors.newFixedThreadPool(2));

        consumer.start();
    }
}
                        
                    

  
                            
$ch = curl_init('http://your-server-ip:HTTP_PORT/api/gateways');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: HTTP_API_TOKEN']);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
                            
                        

  
                            
fetch('http://your-server-ip:HTTP_PORT/api/gateways', {
    headers: {
        'X-API-Key': 'HTTP_API_TOKEN'
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                            
                        

                            
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "http://your-server-ip:HTTP_PORT/api/gateways", nil)
    req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}
                            
                        

                            
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://your-server-ip:HTTP_PORT/api/gateways"))
                .header("X-API-Key", "HTTP_API_TOKEN")
                .build();

        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
                            
                        

  
                            
$ch = curl_init('http://your-server-ip:HTTP_PORT/api/clients');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: HTTP_API_TOKEN']);
$response = curl_exec($ch);
curl_close($ch);

echo $response;
                            
                        

  
                            
fetch('http://your-server-ip:HTTP_PORT/api/clients', {
    headers: {
        'X-API-Key': 'HTTP_API_TOKEN'
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                            
                        

                            
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    req, _ := http.NewRequest("GET", "http://your-server-ip:HTTP_PORT/api/clients", nil)
    req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

    client := &http.Client{}
    resp, _ := client.Do(req)
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println(string(body))
}
                            
                        

                            
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://your-server-ip:HTTP_PORT/api/clients"))
                .header("X-API-Key", "HTTP_API_TOKEN")
                .build();

        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}
                            
                        

  
                            
$params = [
    'dateFrom' => '2024-08-25',
    'dateTo' => '2024-08-26',
    'smscIds' => ['mysmsc-id-example'],
];

$url = "http://your-server-ip:HTTP_PORT/api/gateways/logs?" . http_build_query($params);

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: HTTP_API_TOKEN']);
$response = curl_exec($ch);
curl_close($ch);

print_r(json_decode($response, true));
                            
                        

  
                            
const params = new URLSearchParams({
    dateFrom: '2024-08-25',
    dateTo: '2024-08-26',
    'smscIds[]': 'mysmsc-id-example'
});

fetch(`http://your-server-ip:HTTP_PORT/api/gateways/logs?${params.toString()}`, {
    headers: {
        'X-API-Key': 'HTTP_API_TOKEN'
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                            
                        

                            
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

func main() {
    params := url.Values{
        "dateFrom":  {"2024-08-25"},
        "dateTo":    {"2024-08-26"},
        "smscIds[]": {"mysmsc-id-example"},
    }

    reqURL := fmt.Sprintf("%s?%s", "http://your-server-ip:HTTP_PORT/api/gateways/logs", params.Encode())
    req, _ := http.NewRequest("GET", reqURL, nil)
    req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

    resp, _ := http.DefaultClient.Do(req)
    defer resp.Body.Close()

    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)

    fmt.Println(result)
}
                            
                        

                            
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.StringJoiner;

public class Main {
    public static void main(String[] args) throws Exception {
        Map params = Map.of(
            "dateFrom", "2024-08-25",
            "dateTo", "2024-08-26",
            "smscIds[]", "mysmsc-id-example"
        );

        StringJoiner sj = new StringJoiner("&");
        for (Map.Entry entry : params.entrySet()) {
            sj.add(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8) + "=" 
                + URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));
        }

        String url = "http://your-server-ip:HTTP_PORT/api/gateways/logs?" + sj.toString();

        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .header("X-API-Key", "HTTP_API_TOKEN")
            .build();

        HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}                                
                            
                        

                            
$curl = curl_init();

curl_setopt_array($curl, array(
    CURLOPT_URL => 'http://your-server-ip:HTTP_PORT/api/gateways/logs/download?files[]=2024-08-251234.log',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => array(
    'X-API-Key: HTTP_API_TOKEN'
    ),
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;
                            
                        

                            
fetch('http://your-server-ip:HTTP_PORT/api/gateways/logs/download?files[]=2024-08-251234.log', {
    method: 'GET',
    headers: {
        'X-API-Key': 'HTTP_API_TOKEN'
    }
})
.then(response => response.text())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
                            
                        

                            
package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    client := &http.Client{}
    req, err := http.NewRequest("GET", "http://your-server-ip:HTTP_PORT/api/gateways/logs/download?files[]=2024-08-251234.log", nil)
    if err != nil {
        fmt.Println("Error creating request:", err)
        return
    }

    req.Header.Set("X-API-Key", "HTTP_API_TOKEN")

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error making request:", err)
        return
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response body:", err)
        return
    }

    fmt.Println(string(body))
}
                            
                        

                            
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("http://your-server-ip:HTTP_PORT/api/gateways/logs/download?files[]=2024-08-251234.log"))
                .header("X-API-Key", "HTTP_API_TOKEN")
                .build();

        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}