smart-me

PUT Creates a Access Token to write on a Card (e.g. NFC)

{{baseUrl}}/api/AccessToken

BODY json

{
  "CardId": 0,
  "UserId": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/AccessToken");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/AccessToken" {:content-type :json
                                                           :form-params {:CardId 0
                                                                         :UserId 0}})

require "http/client"

url = "{{baseUrl}}/api/AccessToken"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/AccessToken"),
    Content = new StringContent("{\n  \"CardId\": 0,\n  \"UserId\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/AccessToken");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/AccessToken"

	payload := strings.NewReader("{\n  \"CardId\": 0,\n  \"UserId\": 0\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/AccessToken HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "CardId": 0,
  "UserId": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/AccessToken")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CardId\": 0,\n  \"UserId\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/AccessToken"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/AccessToken")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/AccessToken")
  .header("content-type", "application/json")
  .body("{\n  \"CardId\": 0,\n  \"UserId\": 0\n}")
  .asString();

const data = JSON.stringify({
  CardId: 0,
  UserId: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/AccessToken');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/AccessToken',
  headers: {'content-type': 'application/json'},
  data: {CardId: 0, UserId: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/AccessToken';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"CardId":0,"UserId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/AccessToken',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CardId": 0,\n  "UserId": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/AccessToken")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/AccessToken',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({CardId: 0, UserId: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/AccessToken',
  headers: {'content-type': 'application/json'},
  body: {CardId: 0, UserId: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/AccessToken');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CardId: 0,
  UserId: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/AccessToken',
  headers: {'content-type': 'application/json'},
  data: {CardId: 0, UserId: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/AccessToken';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"CardId":0,"UserId":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"CardId": @0,
                              @"UserId": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/AccessToken"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/AccessToken" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/AccessToken",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'CardId' => 0,
    'UserId' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/AccessToken', [
  'body' => '{
  "CardId": 0,
  "UserId": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/AccessToken');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CardId' => 0,
  'UserId' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CardId' => 0,
  'UserId' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/AccessToken');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/AccessToken' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CardId": 0,
  "UserId": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/AccessToken' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CardId": 0,
  "UserId": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/AccessToken", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/AccessToken"

payload = {
    "CardId": 0,
    "UserId": 0
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/AccessToken"

payload <- "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/AccessToken")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/api/AccessToken') do |req|
  req.body = "{\n  \"CardId\": 0,\n  \"UserId\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/AccessToken";

    let payload = json!({
        "CardId": 0,
        "UserId": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/AccessToken \
  --header 'content-type: application/json' \
  --data '{
  "CardId": 0,
  "UserId": 0
}'

echo '{
  "CardId": 0,
  "UserId": 0
}' |  \
  http PUT {{baseUrl}}/api/AccessToken \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "CardId": 0,\n  "UserId": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/AccessToken

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CardId": 0,
  "UserId": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/AccessToken")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Account_Login

{{baseUrl}}/api/Account/login

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Account/login");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Account/login")

require "http/client"

url = "{{baseUrl}}/api/Account/login"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Account/login"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Account/login");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Account/login"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Account/login HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Account/login")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Account/login"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Account/login")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Account/login")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Account/login');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Account/login'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Account/login';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Account/login',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Account/login")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Account/login',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Account/login'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Account/login');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Account/login'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Account/login';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Account/login"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Account/login" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Account/login",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Account/login');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Account/login');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Account/login');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Account/login' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Account/login' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Account/login")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Account/login"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Account/login"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Account/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Account/login') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Account/login";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Account/login

http GET {{baseUrl}}/api/Account/login

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Account/login

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Account/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST post -api-Account-login

{{baseUrl}}/api/Account/login

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Account/login");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/Account/login")

require "http/client"

url = "{{baseUrl}}/api/Account/login"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/Account/login"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Account/login");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Account/login"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/Account/login HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/Account/login")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Account/login"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Account/login")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/Account/login")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/Account/login');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/Account/login'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Account/login';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Account/login',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Account/login")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Account/login',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'POST', url: '{{baseUrl}}/api/Account/login'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/Account/login');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'POST', url: '{{baseUrl}}/api/Account/login'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Account/login';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Account/login"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Account/login" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Account/login",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/Account/login');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Account/login');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Account/login');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Account/login' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Account/login' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/Account/login")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Account/login"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Account/login"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Account/login")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/Account/login') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Account/login";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/Account/login

http POST {{baseUrl}}/api/Account/login

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/Account/login

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Account/login")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all available Actions of a Device

{{baseUrl}}/api/Actions/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Actions/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Actions/:id")

require "http/client"

url = "{{baseUrl}}/api/Actions/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Actions/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Actions/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Actions/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Actions/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Actions/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Actions/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Actions/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Actions/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Actions/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Actions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Actions/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Actions/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Actions/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Actions/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Actions/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Actions/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Actions/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Actions/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Actions/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Actions/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Actions/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Actions/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Actions/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Actions/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Actions/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Actions/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Actions/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Actions/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Actions/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Actions/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Actions/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Actions/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Actions/:id

http GET {{baseUrl}}/api/Actions/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Actions/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Actions/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Set an action for the specified device.

{{baseUrl}}/api/Actions

BODY json

{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Actions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/Actions" {:content-type :json
                                                        :form-params {:Actions [{:ObisCode ""
                                                                                 :Value ""}]
                                                                      :DeviceID ""}})

require "http/client"

url = "{{baseUrl}}/api/Actions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/Actions"),
    Content = new StringContent("{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Actions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Actions"

	payload := strings.NewReader("{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/Actions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 92

{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/Actions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Actions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Actions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/Actions")
  .header("content-type", "application/json")
  .body("{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Actions: [
    {
      ObisCode: '',
      Value: ''
    }
  ],
  DeviceID: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/Actions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Actions',
  headers: {'content-type': 'application/json'},
  data: {Actions: [{ObisCode: '', Value: ''}], DeviceID: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Actions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Actions":[{"ObisCode":"","Value":""}],"DeviceID":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Actions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Actions": [\n    {\n      "ObisCode": "",\n      "Value": ""\n    }\n  ],\n  "DeviceID": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/Actions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Actions',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Actions: [{ObisCode: '', Value: ''}], DeviceID: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Actions',
  headers: {'content-type': 'application/json'},
  body: {Actions: [{ObisCode: '', Value: ''}], DeviceID: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/Actions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Actions: [
    {
      ObisCode: '',
      Value: ''
    }
  ],
  DeviceID: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Actions',
  headers: {'content-type': 'application/json'},
  data: {Actions: [{ObisCode: '', Value: ''}], DeviceID: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Actions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Actions":[{"ObisCode":"","Value":""}],"DeviceID":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Actions": @[ @{ @"ObisCode": @"", @"Value": @"" } ],
                              @"DeviceID": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Actions"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Actions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Actions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Actions' => [
        [
                'ObisCode' => '',
                'Value' => ''
        ]
    ],
    'DeviceID' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/Actions', [
  'body' => '{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/Actions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Actions' => [
    [
        'ObisCode' => '',
        'Value' => ''
    ]
  ],
  'DeviceID' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Actions' => [
    [
        'ObisCode' => '',
        'Value' => ''
    ]
  ],
  'DeviceID' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/Actions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Actions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Actions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/Actions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Actions"

payload = {
    "Actions": [
        {
            "ObisCode": "",
            "Value": ""
        }
    ],
    "DeviceID": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Actions"

payload <- "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Actions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/Actions') do |req|
  req.body = "{\n  \"Actions\": [\n    {\n      \"ObisCode\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"DeviceID\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Actions";

    let payload = json!({
        "Actions": (
            json!({
                "ObisCode": "",
                "Value": ""
            })
        ),
        "DeviceID": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/Actions \
  --header 'content-type: application/json' \
  --data '{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}'

echo '{
  "Actions": [
    {
      "ObisCode": "",
      "Value": ""
    }
  ],
  "DeviceID": ""
}' |  \
  http POST {{baseUrl}}/api/Actions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Actions": [\n    {\n      "ObisCode": "",\n      "Value": ""\n    }\n  ],\n  "DeviceID": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/Actions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Actions": [
    [
      "ObisCode": "",
      "Value": ""
    ]
  ],
  "DeviceID": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Actions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the additional information (e.g. Firmware Version) about a device.

{{baseUrl}}/api/AdditionalDeviceInformation/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/AdditionalDeviceInformation/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/AdditionalDeviceInformation/:id")

require "http/client"

url = "{{baseUrl}}/api/AdditionalDeviceInformation/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/AdditionalDeviceInformation/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/AdditionalDeviceInformation/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/AdditionalDeviceInformation/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/AdditionalDeviceInformation/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/AdditionalDeviceInformation/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/AdditionalDeviceInformation/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/AdditionalDeviceInformation/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/AdditionalDeviceInformation/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/AdditionalDeviceInformation/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/AdditionalDeviceInformation/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/AdditionalDeviceInformation/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/AdditionalDeviceInformation/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/AdditionalDeviceInformation/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/AdditionalDeviceInformation/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/AdditionalDeviceInformation/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/AdditionalDeviceInformation/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/AdditionalDeviceInformation/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/AdditionalDeviceInformation/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/AdditionalDeviceInformation/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/AdditionalDeviceInformation/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/AdditionalDeviceInformation/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/AdditionalDeviceInformation/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/AdditionalDeviceInformation/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/AdditionalDeviceInformation/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/AdditionalDeviceInformation/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/AdditionalDeviceInformation/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/AdditionalDeviceInformation/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/AdditionalDeviceInformation/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/AdditionalDeviceInformation/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/AdditionalDeviceInformation/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/AdditionalDeviceInformation/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/AdditionalDeviceInformation/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/AdditionalDeviceInformation/:id

http GET {{baseUrl}}/api/AdditionalDeviceInformation/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/AdditionalDeviceInformation/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/AdditionalDeviceInformation/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates or updates a Custom Device or updates it's values.

{{baseUrl}}/api/CustomDevice

BODY json

{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/CustomDevice");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/CustomDevice" {:content-type :json
                                                             :form-params {:Id ""
                                                                           :Name ""
                                                                           :Serial 0
                                                                           :ValueDate ""
                                                                           :Values [{:Name ""
                                                                                     :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/api/CustomDevice"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/CustomDevice"),
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/CustomDevice");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/CustomDevice"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/CustomDevice HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 129

{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/CustomDevice")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/CustomDevice"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/CustomDevice")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  Name: '',
  Serial: 0,
  ValueDate: '',
  Values: [
    {
      Name: '',
      Value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/CustomDevice');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/CustomDevice',
  headers: {'content-type': 'application/json'},
  data: {Id: '', Name: '', Serial: 0, ValueDate: '', Values: [{Name: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/CustomDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Id":"","Name":"","Serial":0,"ValueDate":"","Values":[{"Name":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/CustomDevice',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "Name": "",\n  "Serial": 0,\n  "ValueDate": "",\n  "Values": [\n    {\n      "Name": "",\n      "Value": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/CustomDevice',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Id: '', Name: '', Serial: 0, ValueDate: '', Values: [{Name: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/CustomDevice',
  headers: {'content-type': 'application/json'},
  body: {Id: '', Name: '', Serial: 0, ValueDate: '', Values: [{Name: '', Value: ''}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/CustomDevice');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  Name: '',
  Serial: 0,
  ValueDate: '',
  Values: [
    {
      Name: '',
      Value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/CustomDevice',
  headers: {'content-type': 'application/json'},
  data: {Id: '', Name: '', Serial: 0, ValueDate: '', Values: [{Name: '', Value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/CustomDevice';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Id":"","Name":"","Serial":0,"ValueDate":"","Values":[{"Name":"","Value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Id": @"",
                              @"Name": @"",
                              @"Serial": @0,
                              @"ValueDate": @"",
                              @"Values": @[ @{ @"Name": @"", @"Value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/CustomDevice"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/CustomDevice" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/CustomDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Id' => '',
    'Name' => '',
    'Serial' => 0,
    'ValueDate' => '',
    'Values' => [
        [
                'Name' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/CustomDevice', [
  'body' => '{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/CustomDevice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'Name' => '',
  'Serial' => 0,
  'ValueDate' => '',
  'Values' => [
    [
        'Name' => '',
        'Value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'Name' => '',
  'Serial' => 0,
  'ValueDate' => '',
  'Values' => [
    [
        'Name' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/CustomDevice');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/CustomDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/CustomDevice' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/CustomDevice", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/CustomDevice"

payload = {
    "Id": "",
    "Name": "",
    "Serial": 0,
    "ValueDate": "",
    "Values": [
        {
            "Name": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/CustomDevice"

payload <- "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/CustomDevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/CustomDevice') do |req|
  req.body = "{\n  \"Id\": \"\",\n  \"Name\": \"\",\n  \"Serial\": 0,\n  \"ValueDate\": \"\",\n  \"Values\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/CustomDevice";

    let payload = json!({
        "Id": "",
        "Name": "",
        "Serial": 0,
        "ValueDate": "",
        "Values": (
            json!({
                "Name": "",
                "Value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/CustomDevice \
  --header 'content-type: application/json' \
  --data '{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    {
      "Name": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/api/CustomDevice \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "Name": "",\n  "Serial": 0,\n  "ValueDate": "",\n  "Values": [\n    {\n      "Name": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/CustomDevice

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Id": "",
  "Name": "",
  "Serial": 0,
  "ValueDate": "",
  "Values": [
    [
      "Name": "",
      "Value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/CustomDevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets a Custom Device by it's ID

{{baseUrl}}/api/CustomDevice/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/CustomDevice/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/CustomDevice/:id")

require "http/client"

url = "{{baseUrl}}/api/CustomDevice/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/CustomDevice/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/CustomDevice/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/CustomDevice/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/CustomDevice/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/CustomDevice/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/CustomDevice/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/CustomDevice/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/CustomDevice/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/CustomDevice/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/CustomDevice/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/CustomDevice/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/CustomDevice/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/CustomDevice/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/CustomDevice/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/CustomDevice/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/CustomDevice/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/CustomDevice/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/CustomDevice/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/CustomDevice/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/CustomDevice/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/CustomDevice/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/CustomDevice/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/CustomDevice/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/CustomDevice/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/CustomDevice/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/CustomDevice/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/CustomDevice/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/CustomDevice/:id

http GET {{baseUrl}}/api/CustomDevice/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/CustomDevice/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/CustomDevice/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Custom Devices

{{baseUrl}}/api/CustomDevice

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/CustomDevice");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/CustomDevice")

require "http/client"

url = "{{baseUrl}}/api/CustomDevice"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/CustomDevice"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/CustomDevice");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/CustomDevice"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/CustomDevice HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/CustomDevice")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/CustomDevice"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/CustomDevice")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/CustomDevice');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/CustomDevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/CustomDevice',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/CustomDevice")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/CustomDevice',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/CustomDevice');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/CustomDevice'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/CustomDevice';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/CustomDevice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/CustomDevice" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/CustomDevice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/CustomDevice');

echo $response->getBody();

setUrl('{{baseUrl}}/api/CustomDevice');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/CustomDevice');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/CustomDevice' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/CustomDevice' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/CustomDevice")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/CustomDevice"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/CustomDevice"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/CustomDevice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/CustomDevice') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/CustomDevice";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/CustomDevice

http GET {{baseUrl}}/api/CustomDevice

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/CustomDevice

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/CustomDevice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets a Device by it's Serial Number. The Serial is the part before the ---.

{{baseUrl}}/api/DeviceBySerial

QUERY PARAMS

serial

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/DeviceBySerial?serial=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/DeviceBySerial" {:query-params {:serial ""}})

require "http/client"

url = "{{baseUrl}}/api/DeviceBySerial?serial="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/DeviceBySerial?serial="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/DeviceBySerial?serial=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/DeviceBySerial?serial="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/DeviceBySerial?serial= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/DeviceBySerial?serial=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/DeviceBySerial?serial="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/DeviceBySerial?serial=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/DeviceBySerial?serial=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/DeviceBySerial?serial=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DeviceBySerial',
  params: {serial: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/DeviceBySerial?serial=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/DeviceBySerial?serial=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/DeviceBySerial?serial=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/DeviceBySerial?serial=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DeviceBySerial',
  qs: {serial: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/DeviceBySerial');

req.query({
  serial: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DeviceBySerial',
  params: {serial: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/DeviceBySerial?serial=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/DeviceBySerial?serial="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/DeviceBySerial?serial=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/DeviceBySerial?serial=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/DeviceBySerial?serial=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/DeviceBySerial');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'serial' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/DeviceBySerial');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'serial' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/DeviceBySerial?serial=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/DeviceBySerial?serial=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/DeviceBySerial?serial=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/DeviceBySerial"

querystring = {"serial":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/DeviceBySerial"

queryString <- list(serial = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/DeviceBySerial?serial=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/DeviceBySerial') do |req|
  req.params['serial'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/DeviceBySerial";

    let querystring = [
        ("serial", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/DeviceBySerial?serial='

http GET '{{baseUrl}}/api/DeviceBySerial?serial='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/DeviceBySerial?serial='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/DeviceBySerial?serial=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates or updates a Device or updates it's values.

{{baseUrl}}/api/Devices

BODY json

{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Devices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/Devices" {:content-type :json
                                                        :form-params {:ActivePower ""
                                                                      :CounterReading ""
                                                                      :CounterReadingExport ""
                                                                      :CounterReadingExportT1 ""
                                                                      :CounterReadingExportT2 ""
                                                                      :CounterReadingT1 ""
                                                                      :CounterReadingT2 ""
                                                                      :Current ""
                                                                      :CurrentL1 ""
                                                                      :CurrentL2 ""
                                                                      :CurrentL3 ""
                                                                      :DeviceEnergyType ""
                                                                      :DigitalInput1 false
                                                                      :Id ""
                                                                      :MeterSubType ""
                                                                      :Name ""
                                                                      :PowerFactor ""
                                                                      :PowerFactorL1 ""
                                                                      :PowerFactorL2 ""
                                                                      :PowerFactorL3 ""
                                                                      :Serial 0
                                                                      :Temperature ""
                                                                      :ValueDate ""
                                                                      :Voltage ""
                                                                      :VoltageL1 ""
                                                                      :VoltageL2 ""
                                                                      :VoltageL3 ""}})

require "http/client"

url = "{{baseUrl}}/api/Devices"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/Devices"),
    Content = new StringContent("{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Devices");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Devices"

	payload := strings.NewReader("{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/Devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 586

{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/Devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Devices"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/Devices")
  .header("content-type", "application/json")
  .body("{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ActivePower: '',
  CounterReading: '',
  CounterReadingExport: '',
  CounterReadingExportT1: '',
  CounterReadingExportT2: '',
  CounterReadingT1: '',
  CounterReadingT2: '',
  Current: '',
  CurrentL1: '',
  CurrentL2: '',
  CurrentL3: '',
  DeviceEnergyType: '',
  DigitalInput1: false,
  Id: '',
  MeterSubType: '',
  Name: '',
  PowerFactor: '',
  PowerFactorL1: '',
  PowerFactorL2: '',
  PowerFactorL3: '',
  Serial: 0,
  Temperature: '',
  ValueDate: '',
  Voltage: '',
  VoltageL1: '',
  VoltageL2: '',
  VoltageL3: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/Devices');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Devices',
  headers: {'content-type': 'application/json'},
  data: {
    ActivePower: '',
    CounterReading: '',
    CounterReadingExport: '',
    CounterReadingExportT1: '',
    CounterReadingExportT2: '',
    CounterReadingT1: '',
    CounterReadingT2: '',
    Current: '',
    CurrentL1: '',
    CurrentL2: '',
    CurrentL3: '',
    DeviceEnergyType: '',
    DigitalInput1: false,
    Id: '',
    MeterSubType: '',
    Name: '',
    PowerFactor: '',
    PowerFactorL1: '',
    PowerFactorL2: '',
    PowerFactorL3: '',
    Serial: 0,
    Temperature: '',
    ValueDate: '',
    Voltage: '',
    VoltageL1: '',
    VoltageL2: '',
    VoltageL3: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ActivePower":"","CounterReading":"","CounterReadingExport":"","CounterReadingExportT1":"","CounterReadingExportT2":"","CounterReadingT1":"","CounterReadingT2":"","Current":"","CurrentL1":"","CurrentL2":"","CurrentL3":"","DeviceEnergyType":"","DigitalInput1":false,"Id":"","MeterSubType":"","Name":"","PowerFactor":"","PowerFactorL1":"","PowerFactorL2":"","PowerFactorL3":"","Serial":0,"Temperature":"","ValueDate":"","Voltage":"","VoltageL1":"","VoltageL2":"","VoltageL3":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ActivePower": "",\n  "CounterReading": "",\n  "CounterReadingExport": "",\n  "CounterReadingExportT1": "",\n  "CounterReadingExportT2": "",\n  "CounterReadingT1": "",\n  "CounterReadingT2": "",\n  "Current": "",\n  "CurrentL1": "",\n  "CurrentL2": "",\n  "CurrentL3": "",\n  "DeviceEnergyType": "",\n  "DigitalInput1": false,\n  "Id": "",\n  "MeterSubType": "",\n  "Name": "",\n  "PowerFactor": "",\n  "PowerFactorL1": "",\n  "PowerFactorL2": "",\n  "PowerFactorL3": "",\n  "Serial": 0,\n  "Temperature": "",\n  "ValueDate": "",\n  "Voltage": "",\n  "VoltageL1": "",\n  "VoltageL2": "",\n  "VoltageL3": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/Devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Devices',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ActivePower: '',
  CounterReading: '',
  CounterReadingExport: '',
  CounterReadingExportT1: '',
  CounterReadingExportT2: '',
  CounterReadingT1: '',
  CounterReadingT2: '',
  Current: '',
  CurrentL1: '',
  CurrentL2: '',
  CurrentL3: '',
  DeviceEnergyType: '',
  DigitalInput1: false,
  Id: '',
  MeterSubType: '',
  Name: '',
  PowerFactor: '',
  PowerFactorL1: '',
  PowerFactorL2: '',
  PowerFactorL3: '',
  Serial: 0,
  Temperature: '',
  ValueDate: '',
  Voltage: '',
  VoltageL1: '',
  VoltageL2: '',
  VoltageL3: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Devices',
  headers: {'content-type': 'application/json'},
  body: {
    ActivePower: '',
    CounterReading: '',
    CounterReadingExport: '',
    CounterReadingExportT1: '',
    CounterReadingExportT2: '',
    CounterReadingT1: '',
    CounterReadingT2: '',
    Current: '',
    CurrentL1: '',
    CurrentL2: '',
    CurrentL3: '',
    DeviceEnergyType: '',
    DigitalInput1: false,
    Id: '',
    MeterSubType: '',
    Name: '',
    PowerFactor: '',
    PowerFactorL1: '',
    PowerFactorL2: '',
    PowerFactorL3: '',
    Serial: 0,
    Temperature: '',
    ValueDate: '',
    Voltage: '',
    VoltageL1: '',
    VoltageL2: '',
    VoltageL3: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/Devices');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ActivePower: '',
  CounterReading: '',
  CounterReadingExport: '',
  CounterReadingExportT1: '',
  CounterReadingExportT2: '',
  CounterReadingT1: '',
  CounterReadingT2: '',
  Current: '',
  CurrentL1: '',
  CurrentL2: '',
  CurrentL3: '',
  DeviceEnergyType: '',
  DigitalInput1: false,
  Id: '',
  MeterSubType: '',
  Name: '',
  PowerFactor: '',
  PowerFactorL1: '',
  PowerFactorL2: '',
  PowerFactorL3: '',
  Serial: 0,
  Temperature: '',
  ValueDate: '',
  Voltage: '',
  VoltageL1: '',
  VoltageL2: '',
  VoltageL3: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/Devices',
  headers: {'content-type': 'application/json'},
  data: {
    ActivePower: '',
    CounterReading: '',
    CounterReadingExport: '',
    CounterReadingExportT1: '',
    CounterReadingExportT2: '',
    CounterReadingT1: '',
    CounterReadingT2: '',
    Current: '',
    CurrentL1: '',
    CurrentL2: '',
    CurrentL3: '',
    DeviceEnergyType: '',
    DigitalInput1: false,
    Id: '',
    MeterSubType: '',
    Name: '',
    PowerFactor: '',
    PowerFactorL1: '',
    PowerFactorL2: '',
    PowerFactorL3: '',
    Serial: 0,
    Temperature: '',
    ValueDate: '',
    Voltage: '',
    VoltageL1: '',
    VoltageL2: '',
    VoltageL3: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ActivePower":"","CounterReading":"","CounterReadingExport":"","CounterReadingExportT1":"","CounterReadingExportT2":"","CounterReadingT1":"","CounterReadingT2":"","Current":"","CurrentL1":"","CurrentL2":"","CurrentL3":"","DeviceEnergyType":"","DigitalInput1":false,"Id":"","MeterSubType":"","Name":"","PowerFactor":"","PowerFactorL1":"","PowerFactorL2":"","PowerFactorL3":"","Serial":0,"Temperature":"","ValueDate":"","Voltage":"","VoltageL1":"","VoltageL2":"","VoltageL3":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ActivePower": @"",
                              @"CounterReading": @"",
                              @"CounterReadingExport": @"",
                              @"CounterReadingExportT1": @"",
                              @"CounterReadingExportT2": @"",
                              @"CounterReadingT1": @"",
                              @"CounterReadingT2": @"",
                              @"Current": @"",
                              @"CurrentL1": @"",
                              @"CurrentL2": @"",
                              @"CurrentL3": @"",
                              @"DeviceEnergyType": @"",
                              @"DigitalInput1": @NO,
                              @"Id": @"",
                              @"MeterSubType": @"",
                              @"Name": @"",
                              @"PowerFactor": @"",
                              @"PowerFactorL1": @"",
                              @"PowerFactorL2": @"",
                              @"PowerFactorL3": @"",
                              @"Serial": @0,
                              @"Temperature": @"",
                              @"ValueDate": @"",
                              @"Voltage": @"",
                              @"VoltageL1": @"",
                              @"VoltageL2": @"",
                              @"VoltageL3": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Devices"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ActivePower' => '',
    'CounterReading' => '',
    'CounterReadingExport' => '',
    'CounterReadingExportT1' => '',
    'CounterReadingExportT2' => '',
    'CounterReadingT1' => '',
    'CounterReadingT2' => '',
    'Current' => '',
    'CurrentL1' => '',
    'CurrentL2' => '',
    'CurrentL3' => '',
    'DeviceEnergyType' => '',
    'DigitalInput1' => null,
    'Id' => '',
    'MeterSubType' => '',
    'Name' => '',
    'PowerFactor' => '',
    'PowerFactorL1' => '',
    'PowerFactorL2' => '',
    'PowerFactorL3' => '',
    'Serial' => 0,
    'Temperature' => '',
    'ValueDate' => '',
    'Voltage' => '',
    'VoltageL1' => '',
    'VoltageL2' => '',
    'VoltageL3' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/Devices', [
  'body' => '{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/Devices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ActivePower' => '',
  'CounterReading' => '',
  'CounterReadingExport' => '',
  'CounterReadingExportT1' => '',
  'CounterReadingExportT2' => '',
  'CounterReadingT1' => '',
  'CounterReadingT2' => '',
  'Current' => '',
  'CurrentL1' => '',
  'CurrentL2' => '',
  'CurrentL3' => '',
  'DeviceEnergyType' => '',
  'DigitalInput1' => null,
  'Id' => '',
  'MeterSubType' => '',
  'Name' => '',
  'PowerFactor' => '',
  'PowerFactorL1' => '',
  'PowerFactorL2' => '',
  'PowerFactorL3' => '',
  'Serial' => 0,
  'Temperature' => '',
  'ValueDate' => '',
  'Voltage' => '',
  'VoltageL1' => '',
  'VoltageL2' => '',
  'VoltageL3' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ActivePower' => '',
  'CounterReading' => '',
  'CounterReadingExport' => '',
  'CounterReadingExportT1' => '',
  'CounterReadingExportT2' => '',
  'CounterReadingT1' => '',
  'CounterReadingT2' => '',
  'Current' => '',
  'CurrentL1' => '',
  'CurrentL2' => '',
  'CurrentL3' => '',
  'DeviceEnergyType' => '',
  'DigitalInput1' => null,
  'Id' => '',
  'MeterSubType' => '',
  'Name' => '',
  'PowerFactor' => '',
  'PowerFactorL1' => '',
  'PowerFactorL2' => '',
  'PowerFactorL3' => '',
  'Serial' => 0,
  'Temperature' => '',
  'ValueDate' => '',
  'Voltage' => '',
  'VoltageL1' => '',
  'VoltageL2' => '',
  'VoltageL3' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/Devices');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/Devices", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Devices"

payload = {
    "ActivePower": "",
    "CounterReading": "",
    "CounterReadingExport": "",
    "CounterReadingExportT1": "",
    "CounterReadingExportT2": "",
    "CounterReadingT1": "",
    "CounterReadingT2": "",
    "Current": "",
    "CurrentL1": "",
    "CurrentL2": "",
    "CurrentL3": "",
    "DeviceEnergyType": "",
    "DigitalInput1": False,
    "Id": "",
    "MeterSubType": "",
    "Name": "",
    "PowerFactor": "",
    "PowerFactorL1": "",
    "PowerFactorL2": "",
    "PowerFactorL3": "",
    "Serial": 0,
    "Temperature": "",
    "ValueDate": "",
    "Voltage": "",
    "VoltageL1": "",
    "VoltageL2": "",
    "VoltageL3": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Devices"

payload <- "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Devices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/Devices') do |req|
  req.body = "{\n  \"ActivePower\": \"\",\n  \"CounterReading\": \"\",\n  \"CounterReadingExport\": \"\",\n  \"CounterReadingExportT1\": \"\",\n  \"CounterReadingExportT2\": \"\",\n  \"CounterReadingT1\": \"\",\n  \"CounterReadingT2\": \"\",\n  \"Current\": \"\",\n  \"CurrentL1\": \"\",\n  \"CurrentL2\": \"\",\n  \"CurrentL3\": \"\",\n  \"DeviceEnergyType\": \"\",\n  \"DigitalInput1\": false,\n  \"Id\": \"\",\n  \"MeterSubType\": \"\",\n  \"Name\": \"\",\n  \"PowerFactor\": \"\",\n  \"PowerFactorL1\": \"\",\n  \"PowerFactorL2\": \"\",\n  \"PowerFactorL3\": \"\",\n  \"Serial\": 0,\n  \"Temperature\": \"\",\n  \"ValueDate\": \"\",\n  \"Voltage\": \"\",\n  \"VoltageL1\": \"\",\n  \"VoltageL2\": \"\",\n  \"VoltageL3\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Devices";

    let payload = json!({
        "ActivePower": "",
        "CounterReading": "",
        "CounterReadingExport": "",
        "CounterReadingExportT1": "",
        "CounterReadingExportT2": "",
        "CounterReadingT1": "",
        "CounterReadingT2": "",
        "Current": "",
        "CurrentL1": "",
        "CurrentL2": "",
        "CurrentL3": "",
        "DeviceEnergyType": "",
        "DigitalInput1": false,
        "Id": "",
        "MeterSubType": "",
        "Name": "",
        "PowerFactor": "",
        "PowerFactorL1": "",
        "PowerFactorL2": "",
        "PowerFactorL3": "",
        "Serial": 0,
        "Temperature": "",
        "ValueDate": "",
        "Voltage": "",
        "VoltageL1": "",
        "VoltageL2": "",
        "VoltageL3": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/Devices \
  --header 'content-type: application/json' \
  --data '{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}'

echo '{
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
}' |  \
  http POST {{baseUrl}}/api/Devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ActivePower": "",\n  "CounterReading": "",\n  "CounterReadingExport": "",\n  "CounterReadingExportT1": "",\n  "CounterReadingExportT2": "",\n  "CounterReadingT1": "",\n  "CounterReadingT2": "",\n  "Current": "",\n  "CurrentL1": "",\n  "CurrentL2": "",\n  "CurrentL3": "",\n  "DeviceEnergyType": "",\n  "DigitalInput1": false,\n  "Id": "",\n  "MeterSubType": "",\n  "Name": "",\n  "PowerFactor": "",\n  "PowerFactorL1": "",\n  "PowerFactorL2": "",\n  "PowerFactorL3": "",\n  "Serial": 0,\n  "Temperature": "",\n  "ValueDate": "",\n  "Voltage": "",\n  "VoltageL1": "",\n  "VoltageL2": "",\n  "VoltageL3": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/Devices

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ActivePower": "",
  "CounterReading": "",
  "CounterReadingExport": "",
  "CounterReadingExportT1": "",
  "CounterReadingExportT2": "",
  "CounterReadingT1": "",
  "CounterReadingT2": "",
  "Current": "",
  "CurrentL1": "",
  "CurrentL2": "",
  "CurrentL3": "",
  "DeviceEnergyType": "",
  "DigitalInput1": false,
  "Id": "",
  "MeterSubType": "",
  "Name": "",
  "PowerFactor": "",
  "PowerFactorL1": "",
  "PowerFactorL2": "",
  "PowerFactorL3": "",
  "Serial": 0,
  "Temperature": "",
  "ValueDate": "",
  "Voltage": "",
  "VoltageL1": "",
  "VoltageL2": "",
  "VoltageL3": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Devices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets a Device by it's ID

{{baseUrl}}/api/Devices/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Devices/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Devices/:id")

require "http/client"

url = "{{baseUrl}}/api/Devices/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Devices/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Devices/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Devices/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Devices/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Devices/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Devices/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Devices/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Devices/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Devices/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Devices/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Devices/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Devices/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Devices/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Devices/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Devices/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Devices/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Devices/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Devices/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Devices/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Devices/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Devices/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Devices/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Devices/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Devices/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Devices/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Devices/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Devices/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Devices/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Devices/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Devices/:id

http GET {{baseUrl}}/api/Devices/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Devices/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Devices/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Devices

{{baseUrl}}/api/Devices

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Devices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Devices")

require "http/client"

url = "{{baseUrl}}/api/Devices"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Devices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Devices"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Devices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Devices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Devices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Devices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Devices")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Devices');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Devices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Devices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Devices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Devices',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Devices');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Devices'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Devices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Devices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Devices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Devices');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Devices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Devices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Devices' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Devices' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Devices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Devices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Devices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Devices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Devices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Devices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Devices

http GET {{baseUrl}}/api/Devices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Devices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Devices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Updates the On-Off Switch on a device. For new implementations please use the -actions- command

{{baseUrl}}/api/Devices/:id

QUERY PARAMS

switchState

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Devices/:id?switchState=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/Devices/:id" {:query-params {:switchState ""}})

require "http/client"

url = "{{baseUrl}}/api/Devices/:id?switchState="

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/Devices/:id?switchState="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Devices/:id?switchState=");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Devices/:id?switchState="

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/Devices/:id?switchState= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/Devices/:id?switchState=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Devices/:id?switchState="))
    .method("PUT", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Devices/:id?switchState=")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/Devices/:id?switchState=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/Devices/:id?switchState=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/Devices/:id',
  params: {switchState: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Devices/:id?switchState=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Devices/:id?switchState=',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Devices/:id?switchState=")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Devices/:id?switchState=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/Devices/:id',
  qs: {switchState: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/Devices/:id');

req.query({
  switchState: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/Devices/:id',
  params: {switchState: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Devices/:id?switchState=';
const options = {method: 'PUT'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Devices/:id?switchState="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Devices/:id?switchState=" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Devices/:id?switchState=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/Devices/:id?switchState=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Devices/:id');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'switchState' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Devices/:id');
$request->setRequestMethod('PUT');
$request->setQuery(new http\QueryString([
  'switchState' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Devices/:id?switchState=' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Devices/:id?switchState=' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/api/Devices/:id?switchState=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Devices/:id"

querystring = {"switchState":""}

response = requests.put(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Devices/:id"

queryString <- list(switchState = "")

response <- VERB("PUT", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Devices/:id?switchState=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/Devices/:id') do |req|
  req.params['switchState'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Devices/:id";

    let querystring = [
        ("switchState", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url '{{baseUrl}}/api/Devices/:id?switchState='

http PUT '{{baseUrl}}/api/Devices/:id?switchState='

wget --quiet \
  --method PUT \
  --output-document \
  - '{{baseUrl}}/api/Devices/:id?switchState='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Devices/:id?switchState=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Devices for an Energy Type

{{baseUrl}}/api/DevicesByEnergy

QUERY PARAMS

meterEnergyType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/DevicesByEnergy" {:query-params {:meterEnergyType ""}})

require "http/client"

url = "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/DevicesByEnergy?meterEnergyType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesByEnergy',
  params: {meterEnergyType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/DevicesByEnergy?meterEnergyType=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesByEnergy',
  qs: {meterEnergyType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/DevicesByEnergy');

req.query({
  meterEnergyType: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesByEnergy',
  params: {meterEnergyType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/DevicesByEnergy?meterEnergyType="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/DevicesByEnergy');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'meterEnergyType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/DevicesByEnergy');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'meterEnergyType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/DevicesByEnergy?meterEnergyType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/DevicesByEnergy"

querystring = {"meterEnergyType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/DevicesByEnergy"

queryString <- list(meterEnergyType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/DevicesByEnergy') do |req|
  req.params['meterEnergyType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/DevicesByEnergy";

    let querystring = [
        ("meterEnergyType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType='

http GET '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/DevicesByEnergy?meterEnergyType='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/DevicesByEnergy?meterEnergyType=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Devices by it's Sub Type (e.g. E-Charging Station)

{{baseUrl}}/api/DevicesBySubType

QUERY PARAMS

meterSubType

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/DevicesBySubType?meterSubType=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/DevicesBySubType" {:query-params {:meterSubType ""}})

require "http/client"

url = "{{baseUrl}}/api/DevicesBySubType?meterSubType="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/DevicesBySubType?meterSubType="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/DevicesBySubType?meterSubType=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/DevicesBySubType?meterSubType="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/DevicesBySubType?meterSubType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/DevicesBySubType?meterSubType=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/DevicesBySubType?meterSubType="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/DevicesBySubType?meterSubType=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/DevicesBySubType?meterSubType=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/DevicesBySubType?meterSubType=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesBySubType',
  params: {meterSubType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/DevicesBySubType?meterSubType=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/DevicesBySubType?meterSubType=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/DevicesBySubType?meterSubType=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/DevicesBySubType?meterSubType=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesBySubType',
  qs: {meterSubType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/DevicesBySubType');

req.query({
  meterSubType: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/DevicesBySubType',
  params: {meterSubType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/DevicesBySubType?meterSubType=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/DevicesBySubType?meterSubType="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/DevicesBySubType?meterSubType=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/DevicesBySubType?meterSubType=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/DevicesBySubType?meterSubType=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/DevicesBySubType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'meterSubType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/DevicesBySubType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'meterSubType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/DevicesBySubType?meterSubType=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/DevicesBySubType?meterSubType=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/DevicesBySubType?meterSubType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/DevicesBySubType"

querystring = {"meterSubType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/DevicesBySubType"

queryString <- list(meterSubType = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/DevicesBySubType?meterSubType=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/DevicesBySubType') do |req|
  req.params['meterSubType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/DevicesBySubType";

    let querystring = [
        ("meterSubType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/DevicesBySubType?meterSubType='

http GET '{{baseUrl}}/api/DevicesBySubType?meterSubType='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/DevicesBySubType?meterSubType='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/DevicesBySubType?meterSubType=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Force a device to send the data every second (if supported). This for about 30s. Don't use this call to force a device to send the data every second for a longer time.

{{baseUrl}}/api/FastSendDeviceValues/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/FastSendDeviceValues/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/FastSendDeviceValues/:id")

require "http/client"

url = "{{baseUrl}}/api/FastSendDeviceValues/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/FastSendDeviceValues/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/FastSendDeviceValues/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/FastSendDeviceValues/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/FastSendDeviceValues/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/FastSendDeviceValues/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/FastSendDeviceValues/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/FastSendDeviceValues/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/FastSendDeviceValues/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/FastSendDeviceValues/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/FastSendDeviceValues/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/FastSendDeviceValues/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/FastSendDeviceValues/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/FastSendDeviceValues/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/FastSendDeviceValues/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/FastSendDeviceValues/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/FastSendDeviceValues/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/FastSendDeviceValues/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/FastSendDeviceValues/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/FastSendDeviceValues/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/FastSendDeviceValues/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/FastSendDeviceValues/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/FastSendDeviceValues/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/FastSendDeviceValues/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/FastSendDeviceValues/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/FastSendDeviceValues/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/FastSendDeviceValues/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/FastSendDeviceValues/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/FastSendDeviceValues/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/FastSendDeviceValues/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/FastSendDeviceValues/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/FastSendDeviceValues/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/FastSendDeviceValues/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/FastSendDeviceValues/:id

http GET {{baseUrl}}/api/FastSendDeviceValues/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/FastSendDeviceValues/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/FastSendDeviceValues/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the Values for a folder or a meter

{{baseUrl}}/api/Folder/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Folder/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Folder/:id")

require "http/client"

url = "{{baseUrl}}/api/Folder/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Folder/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Folder/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Folder/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Folder/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Folder/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Folder/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Folder/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Folder/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Folder/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Folder/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Folder/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Folder/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Folder/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Folder/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Folder/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Folder/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Folder/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Folder/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Folder/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Folder/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Folder/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Folder/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Folder/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Folder/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Folder/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Folder/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Folder/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Folder/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Folder/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Folder/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Folder/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Folder/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Folder/:id

http GET {{baseUrl}}/api/Folder/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Folder/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Folder/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Assign a folder (source) or meter to another folder (target). Can be used to create a folder structure.

{{baseUrl}}/api/folder/assign

QUERY PARAMS

source

target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/assign?source=&target=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/folder/assign" {:query-params {:source ""
                                                                             :target ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/assign?source=&target="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/folder/assign?source=&target="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/assign?source=&target=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/assign?source=&target="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/folder/assign?source=&target= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/assign?source=&target=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/assign?source=&target="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/assign?source=&target=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/assign?source=&target=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/folder/assign?source=&target=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/assign',
  params: {source: '', target: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/assign?source=&target=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/assign?source=&target=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/assign?source=&target=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/assign?source=&target=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/assign',
  qs: {source: '', target: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/folder/assign');

req.query({
  source: '',
  target: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/assign',
  params: {source: '', target: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/assign?source=&target=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/assign?source=&target="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/assign?source=&target=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/assign?source=&target=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/folder/assign?source=&target=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/assign');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'source' => '',
  'target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/folder/assign');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'source' => '',
  'target' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/assign?source=&target=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/assign?source=&target=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/folder/assign?source=&target=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/assign"

querystring = {"source":"","target":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/assign"

queryString <- list(
  source = "",
  target = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/assign?source=&target=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/folder/assign') do |req|
  req.params['source'] = ''
  req.params['target'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/assign";

    let querystring = [
        ("source", ""),
        ("target", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/api/folder/assign?source=&target='

http POST '{{baseUrl}}/api/folder/assign?source=&target='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/api/folder/assign?source=&target='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/assign?source=&target=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates and updates the folder menu items

{{baseUrl}}/api/FolderMenu

BODY json

{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/FolderMenu");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/FolderMenu" {:content-type :json
                                                           :form-params {:BrowserTimeZoneName ""
                                                                         :BrowserUtcTime ""
                                                                         :Items [{:AutoExportSettings {:ExportFormat ""
                                                                                                       :ExportInterval ""
                                                                                                       :MeterPointId ""
                                                                                                       :UploadType ""}
                                                                                  :Children []
                                                                                  :Description ""
                                                                                  :FolderType ""
                                                                                  :Icon ""
                                                                                  :Id ""
                                                                                  :MeterSerialNumber ""
                                                                                  :Name ""
                                                                                  :UserId ""}]}})

require "http/client"

url = "{{baseUrl}}/api/FolderMenu"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/FolderMenu"),
    Content = new StringContent("{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/FolderMenu");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/FolderMenu"

	payload := strings.NewReader("{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/FolderMenu HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 408

{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/FolderMenu")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/FolderMenu"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/FolderMenu")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/FolderMenu")
  .header("content-type", "application/json")
  .body("{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  BrowserTimeZoneName: '',
  BrowserUtcTime: '',
  Items: [
    {
      AutoExportSettings: {
        ExportFormat: '',
        ExportInterval: '',
        MeterPointId: '',
        UploadType: ''
      },
      Children: [],
      Description: '',
      FolderType: '',
      Icon: '',
      Id: '',
      MeterSerialNumber: '',
      Name: '',
      UserId: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/FolderMenu');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/FolderMenu',
  headers: {'content-type': 'application/json'},
  data: {
    BrowserTimeZoneName: '',
    BrowserUtcTime: '',
    Items: [
      {
        AutoExportSettings: {ExportFormat: '', ExportInterval: '', MeterPointId: '', UploadType: ''},
        Children: [],
        Description: '',
        FolderType: '',
        Icon: '',
        Id: '',
        MeterSerialNumber: '',
        Name: '',
        UserId: ''
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/FolderMenu';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BrowserTimeZoneName":"","BrowserUtcTime":"","Items":[{"AutoExportSettings":{"ExportFormat":"","ExportInterval":"","MeterPointId":"","UploadType":""},"Children":[],"Description":"","FolderType":"","Icon":"","Id":"","MeterSerialNumber":"","Name":"","UserId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/FolderMenu',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "BrowserTimeZoneName": "",\n  "BrowserUtcTime": "",\n  "Items": [\n    {\n      "AutoExportSettings": {\n        "ExportFormat": "",\n        "ExportInterval": "",\n        "MeterPointId": "",\n        "UploadType": ""\n      },\n      "Children": [],\n      "Description": "",\n      "FolderType": "",\n      "Icon": "",\n      "Id": "",\n      "MeterSerialNumber": "",\n      "Name": "",\n      "UserId": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/FolderMenu")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/FolderMenu',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  BrowserTimeZoneName: '',
  BrowserUtcTime: '',
  Items: [
    {
      AutoExportSettings: {ExportFormat: '', ExportInterval: '', MeterPointId: '', UploadType: ''},
      Children: [],
      Description: '',
      FolderType: '',
      Icon: '',
      Id: '',
      MeterSerialNumber: '',
      Name: '',
      UserId: ''
    }
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/FolderMenu',
  headers: {'content-type': 'application/json'},
  body: {
    BrowserTimeZoneName: '',
    BrowserUtcTime: '',
    Items: [
      {
        AutoExportSettings: {ExportFormat: '', ExportInterval: '', MeterPointId: '', UploadType: ''},
        Children: [],
        Description: '',
        FolderType: '',
        Icon: '',
        Id: '',
        MeterSerialNumber: '',
        Name: '',
        UserId: ''
      }
    ]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/FolderMenu');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  BrowserTimeZoneName: '',
  BrowserUtcTime: '',
  Items: [
    {
      AutoExportSettings: {
        ExportFormat: '',
        ExportInterval: '',
        MeterPointId: '',
        UploadType: ''
      },
      Children: [],
      Description: '',
      FolderType: '',
      Icon: '',
      Id: '',
      MeterSerialNumber: '',
      Name: '',
      UserId: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/FolderMenu',
  headers: {'content-type': 'application/json'},
  data: {
    BrowserTimeZoneName: '',
    BrowserUtcTime: '',
    Items: [
      {
        AutoExportSettings: {ExportFormat: '', ExportInterval: '', MeterPointId: '', UploadType: ''},
        Children: [],
        Description: '',
        FolderType: '',
        Icon: '',
        Id: '',
        MeterSerialNumber: '',
        Name: '',
        UserId: ''
      }
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/FolderMenu';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"BrowserTimeZoneName":"","BrowserUtcTime":"","Items":[{"AutoExportSettings":{"ExportFormat":"","ExportInterval":"","MeterPointId":"","UploadType":""},"Children":[],"Description":"","FolderType":"","Icon":"","Id":"","MeterSerialNumber":"","Name":"","UserId":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"BrowserTimeZoneName": @"",
                              @"BrowserUtcTime": @"",
                              @"Items": @[ @{ @"AutoExportSettings": @{ @"ExportFormat": @"", @"ExportInterval": @"", @"MeterPointId": @"", @"UploadType": @"" }, @"Children": @[  ], @"Description": @"", @"FolderType": @"", @"Icon": @"", @"Id": @"", @"MeterSerialNumber": @"", @"Name": @"", @"UserId": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/FolderMenu"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/FolderMenu" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/FolderMenu",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'BrowserTimeZoneName' => '',
    'BrowserUtcTime' => '',
    'Items' => [
        [
                'AutoExportSettings' => [
                                'ExportFormat' => '',
                                'ExportInterval' => '',
                                'MeterPointId' => '',
                                'UploadType' => ''
                ],
                'Children' => [
                                
                ],
                'Description' => '',
                'FolderType' => '',
                'Icon' => '',
                'Id' => '',
                'MeterSerialNumber' => '',
                'Name' => '',
                'UserId' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/FolderMenu', [
  'body' => '{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/FolderMenu');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'BrowserTimeZoneName' => '',
  'BrowserUtcTime' => '',
  'Items' => [
    [
        'AutoExportSettings' => [
                'ExportFormat' => '',
                'ExportInterval' => '',
                'MeterPointId' => '',
                'UploadType' => ''
        ],
        'Children' => [
                
        ],
        'Description' => '',
        'FolderType' => '',
        'Icon' => '',
        'Id' => '',
        'MeterSerialNumber' => '',
        'Name' => '',
        'UserId' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'BrowserTimeZoneName' => '',
  'BrowserUtcTime' => '',
  'Items' => [
    [
        'AutoExportSettings' => [
                'ExportFormat' => '',
                'ExportInterval' => '',
                'MeterPointId' => '',
                'UploadType' => ''
        ],
        'Children' => [
                
        ],
        'Description' => '',
        'FolderType' => '',
        'Icon' => '',
        'Id' => '',
        'MeterSerialNumber' => '',
        'Name' => '',
        'UserId' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/FolderMenu');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/FolderMenu' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/FolderMenu' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/FolderMenu", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/FolderMenu"

payload = {
    "BrowserTimeZoneName": "",
    "BrowserUtcTime": "",
    "Items": [
        {
            "AutoExportSettings": {
                "ExportFormat": "",
                "ExportInterval": "",
                "MeterPointId": "",
                "UploadType": ""
            },
            "Children": [],
            "Description": "",
            "FolderType": "",
            "Icon": "",
            "Id": "",
            "MeterSerialNumber": "",
            "Name": "",
            "UserId": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/FolderMenu"

payload <- "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/FolderMenu")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/FolderMenu') do |req|
  req.body = "{\n  \"BrowserTimeZoneName\": \"\",\n  \"BrowserUtcTime\": \"\",\n  \"Items\": [\n    {\n      \"AutoExportSettings\": {\n        \"ExportFormat\": \"\",\n        \"ExportInterval\": \"\",\n        \"MeterPointId\": \"\",\n        \"UploadType\": \"\"\n      },\n      \"Children\": [],\n      \"Description\": \"\",\n      \"FolderType\": \"\",\n      \"Icon\": \"\",\n      \"Id\": \"\",\n      \"MeterSerialNumber\": \"\",\n      \"Name\": \"\",\n      \"UserId\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/FolderMenu";

    let payload = json!({
        "BrowserTimeZoneName": "",
        "BrowserUtcTime": "",
        "Items": (
            json!({
                "AutoExportSettings": json!({
                    "ExportFormat": "",
                    "ExportInterval": "",
                    "MeterPointId": "",
                    "UploadType": ""
                }),
                "Children": (),
                "Description": "",
                "FolderType": "",
                "Icon": "",
                "Id": "",
                "MeterSerialNumber": "",
                "Name": "",
                "UserId": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/FolderMenu \
  --header 'content-type: application/json' \
  --data '{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}'

echo '{
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    {
      "AutoExportSettings": {
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      },
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/api/FolderMenu \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "BrowserTimeZoneName": "",\n  "BrowserUtcTime": "",\n  "Items": [\n    {\n      "AutoExportSettings": {\n        "ExportFormat": "",\n        "ExportInterval": "",\n        "MeterPointId": "",\n        "UploadType": ""\n      },\n      "Children": [],\n      "Description": "",\n      "FolderType": "",\n      "Icon": "",\n      "Id": "",\n      "MeterSerialNumber": "",\n      "Name": "",\n      "UserId": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/FolderMenu

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "BrowserTimeZoneName": "",
  "BrowserUtcTime": "",
  "Items": [
    [
      "AutoExportSettings": [
        "ExportFormat": "",
        "ExportInterval": "",
        "MeterPointId": "",
        "UploadType": ""
      ],
      "Children": [],
      "Description": "",
      "FolderType": "",
      "Icon": "",
      "Id": "",
      "MeterSerialNumber": "",
      "Name": "",
      "UserId": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/FolderMenu")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/FolderMenu");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/FolderMenu")

require "http/client"

url = "{{baseUrl}}/api/FolderMenu"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/FolderMenu"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/FolderMenu");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/FolderMenu"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/FolderMenu HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/FolderMenu")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/FolderMenu"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/FolderMenu")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/FolderMenu")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/FolderMenu');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/FolderMenu'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/FolderMenu';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/FolderMenu',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/FolderMenu")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/FolderMenu',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/FolderMenu'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/FolderMenu');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/FolderMenu'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/FolderMenu';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/FolderMenu"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/FolderMenu" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/FolderMenu",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/FolderMenu');

echo $response->getBody();

setUrl('{{baseUrl}}/api/FolderMenu');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/FolderMenu');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/FolderMenu' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/FolderMenu' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/FolderMenu")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/FolderMenu"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/FolderMenu"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/FolderMenu")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/FolderMenu') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/FolderMenu";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/FolderMenu

http GET {{baseUrl}}/api/FolderMenu

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/FolderMenu

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/FolderMenu")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Add or edit a folder or a meter. To add a new folder use and empty ID

{{baseUrl}}/api/folder/settings/:id

QUERY PARAMS

BODY json

{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/settings/:id");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/folder/settings/:id" {:content-type :json
                                                                    :form-params {:Description ""
                                                                                  :Enable false
                                                                                  :FolderType ""
                                                                                  :Name ""
                                                                                  :ParentFolderId ""
                                                                                  :SerialNumber 0
                                                                                  :UseableForVirtualBillingMeters false
                                                                                  :ValueCorrection ""
                                                                                  :ValueCorrectionParentFolder ""
                                                                                  :VisualizationName ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/settings/:id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/folder/settings/:id"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/settings/:id");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/settings/:id"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/folder/settings/:id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 253

{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/settings/:id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/settings/:id"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/settings/:id")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  Enable: false,
  FolderType: '',
  Name: '',
  ParentFolderId: '',
  SerialNumber: 0,
  UseableForVirtualBillingMeters: false,
  ValueCorrection: '',
  ValueCorrectionParentFolder: '',
  VisualizationName: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/folder/settings/:id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/settings/:id',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Enable: false,
    FolderType: '',
    Name: '',
    ParentFolderId: '',
    SerialNumber: 0,
    UseableForVirtualBillingMeters: false,
    ValueCorrection: '',
    ValueCorrectionParentFolder: '',
    VisualizationName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Enable":false,"FolderType":"","Name":"","ParentFolderId":"","SerialNumber":0,"UseableForVirtualBillingMeters":false,"ValueCorrection":"","ValueCorrectionParentFolder":"","VisualizationName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/settings/:id',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "Enable": false,\n  "FolderType": "",\n  "Name": "",\n  "ParentFolderId": "",\n  "SerialNumber": 0,\n  "UseableForVirtualBillingMeters": false,\n  "ValueCorrection": "",\n  "ValueCorrectionParentFolder": "",\n  "VisualizationName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/settings/:id',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  Description: '',
  Enable: false,
  FolderType: '',
  Name: '',
  ParentFolderId: '',
  SerialNumber: 0,
  UseableForVirtualBillingMeters: false,
  ValueCorrection: '',
  ValueCorrectionParentFolder: '',
  VisualizationName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/settings/:id',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    Enable: false,
    FolderType: '',
    Name: '',
    ParentFolderId: '',
    SerialNumber: 0,
    UseableForVirtualBillingMeters: false,
    ValueCorrection: '',
    ValueCorrectionParentFolder: '',
    VisualizationName: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/folder/settings/:id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Description: '',
  Enable: false,
  FolderType: '',
  Name: '',
  ParentFolderId: '',
  SerialNumber: 0,
  UseableForVirtualBillingMeters: false,
  ValueCorrection: '',
  ValueCorrectionParentFolder: '',
  VisualizationName: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/settings/:id',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Enable: false,
    FolderType: '',
    Name: '',
    ParentFolderId: '',
    SerialNumber: 0,
    UseableForVirtualBillingMeters: false,
    ValueCorrection: '',
    ValueCorrectionParentFolder: '',
    VisualizationName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Enable":false,"FolderType":"","Name":"","ParentFolderId":"","SerialNumber":0,"UseableForVirtualBillingMeters":false,"ValueCorrection":"","ValueCorrectionParentFolder":"","VisualizationName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Description": @"",
                              @"Enable": @NO,
                              @"FolderType": @"",
                              @"Name": @"",
                              @"ParentFolderId": @"",
                              @"SerialNumber": @0,
                              @"UseableForVirtualBillingMeters": @NO,
                              @"ValueCorrection": @"",
                              @"ValueCorrectionParentFolder": @"",
                              @"VisualizationName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/settings/:id"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/settings/:id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/settings/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Description' => '',
    'Enable' => null,
    'FolderType' => '',
    'Name' => '',
    'ParentFolderId' => '',
    'SerialNumber' => 0,
    'UseableForVirtualBillingMeters' => null,
    'ValueCorrection' => '',
    'ValueCorrectionParentFolder' => '',
    'VisualizationName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/folder/settings/:id', [
  'body' => '{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'Enable' => null,
  'FolderType' => '',
  'Name' => '',
  'ParentFolderId' => '',
  'SerialNumber' => 0,
  'UseableForVirtualBillingMeters' => null,
  'ValueCorrection' => '',
  'ValueCorrectionParentFolder' => '',
  'VisualizationName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Description' => '',
  'Enable' => null,
  'FolderType' => '',
  'Name' => '',
  'ParentFolderId' => '',
  'SerialNumber' => 0,
  'UseableForVirtualBillingMeters' => null,
  'ValueCorrection' => '',
  'ValueCorrectionParentFolder' => '',
  'VisualizationName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/settings/:id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/settings/:id' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/folder/settings/:id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/settings/:id"

payload = {
    "Description": "",
    "Enable": False,
    "FolderType": "",
    "Name": "",
    "ParentFolderId": "",
    "SerialNumber": 0,
    "UseableForVirtualBillingMeters": False,
    "ValueCorrection": "",
    "ValueCorrectionParentFolder": "",
    "VisualizationName": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/settings/:id"

payload <- "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/settings/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/folder/settings/:id') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"Enable\": false,\n  \"FolderType\": \"\",\n  \"Name\": \"\",\n  \"ParentFolderId\": \"\",\n  \"SerialNumber\": 0,\n  \"UseableForVirtualBillingMeters\": false,\n  \"ValueCorrection\": \"\",\n  \"ValueCorrectionParentFolder\": \"\",\n  \"VisualizationName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/settings/:id";

    let payload = json!({
        "Description": "",
        "Enable": false,
        "FolderType": "",
        "Name": "",
        "ParentFolderId": "",
        "SerialNumber": 0,
        "UseableForVirtualBillingMeters": false,
        "ValueCorrection": "",
        "ValueCorrectionParentFolder": "",
        "VisualizationName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/folder/settings/:id \
  --header 'content-type: application/json' \
  --data '{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}'

echo '{
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
}' |  \
  http POST {{baseUrl}}/api/folder/settings/:id \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "Enable": false,\n  "FolderType": "",\n  "Name": "",\n  "ParentFolderId": "",\n  "SerialNumber": 0,\n  "UseableForVirtualBillingMeters": false,\n  "ValueCorrection": "",\n  "ValueCorrectionParentFolder": "",\n  "VisualizationName": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/settings/:id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "Enable": false,
  "FolderType": "",
  "Name": "",
  "ParentFolderId": "",
  "SerialNumber": 0,
  "UseableForVirtualBillingMeters": false,
  "ValueCorrection": "",
  "ValueCorrectionParentFolder": "",
  "VisualizationName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/settings/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Deletes a folder

{{baseUrl}}/api/folder/settings/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/settings/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/folder/settings/:id")

require "http/client"

url = "{{baseUrl}}/api/folder/settings/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/folder/settings/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/settings/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/settings/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/folder/settings/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/folder/settings/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/settings/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/folder/settings/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/folder/settings/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/folder/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/settings/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/settings/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/api/folder/settings/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/folder/settings/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/api/folder/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/settings/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/settings/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/settings/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/folder/settings/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/settings/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/settings/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/folder/settings/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/settings/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/settings/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/settings/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/folder/settings/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/settings/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/folder/settings/:id

http DELETE {{baseUrl}}/api/folder/settings/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/folder/settings/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/settings/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the settings of a folder or meter

{{baseUrl}}/api/folder/settings/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/settings/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/folder/settings/:id")

require "http/client"

url = "{{baseUrl}}/api/folder/settings/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/folder/settings/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/settings/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/settings/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/folder/settings/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/folder/settings/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/settings/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/settings/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/folder/settings/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/folder/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/settings/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/settings/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/settings/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/folder/settings/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/folder/settings/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/folder/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/settings/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/settings/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/settings/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/settings/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/folder/settings/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/folder/settings/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/settings/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/settings/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/folder/settings/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/settings/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/settings/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/settings/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/folder/settings/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/settings/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/folder/settings/:id

http GET {{baseUrl}}/api/folder/settings/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/folder/settings/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/settings/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET A method returning HTTP 200 OK when queried. It is used by Kubernetes probes to determine whether the app is healthy.

{{baseUrl}}/api/Health

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Health");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Health")

require "http/client"

url = "{{baseUrl}}/api/Health"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Health"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Health");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Health"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Health HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Health")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Health"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Health")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Health")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Health');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Health',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Health")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Health',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Health'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Health');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Health'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Health';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Health"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Health" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Health",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Health');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Health');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Health');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Health' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Health' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Health")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Health"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Health"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Health")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Health') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Health";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Health

http GET {{baseUrl}}/api/Health

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Health

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Health")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST M-BUS API- Adds data of a M-BUS Meter to the smart-me Cloud. Just send us the M-BUS Telegram (RSP_UD) and we will do the Rest.

{{baseUrl}}/api/MBus

BODY json

{
  "Date": "",
  "Telegram": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/MBus");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/MBus" {:content-type :json
                                                     :form-params {:Date ""
                                                                   :Telegram ""}})

require "http/client"

url = "{{baseUrl}}/api/MBus"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/MBus"),
    Content = new StringContent("{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/MBus");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/MBus"

	payload := strings.NewReader("{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/MBus HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "Date": "",
  "Telegram": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/MBus")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/MBus"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/MBus")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/MBus")
  .header("content-type", "application/json")
  .body("{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Date: '',
  Telegram: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/MBus');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MBus',
  headers: {'content-type': 'application/json'},
  data: {Date: '', Telegram: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/MBus';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Date":"","Telegram":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/MBus',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Date": "",\n  "Telegram": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/MBus")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/MBus',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Date: '', Telegram: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MBus',
  headers: {'content-type': 'application/json'},
  body: {Date: '', Telegram: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/MBus');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Date: '',
  Telegram: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MBus',
  headers: {'content-type': 'application/json'},
  data: {Date: '', Telegram: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/MBus';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Date":"","Telegram":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Date": @"",
                              @"Telegram": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/MBus"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/MBus" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/MBus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Date' => '',
    'Telegram' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/MBus', [
  'body' => '{
  "Date": "",
  "Telegram": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/MBus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Date' => '',
  'Telegram' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Date' => '',
  'Telegram' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/MBus');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/MBus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Date": "",
  "Telegram": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/MBus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Date": "",
  "Telegram": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/MBus", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/MBus"

payload = {
    "Date": "",
    "Telegram": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/MBus"

payload <- "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/MBus")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/MBus') do |req|
  req.body = "{\n  \"Date\": \"\",\n  \"Telegram\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/MBus";

    let payload = json!({
        "Date": "",
        "Telegram": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/MBus \
  --header 'content-type: application/json' \
  --data '{
  "Date": "",
  "Telegram": ""
}'

echo '{
  "Date": "",
  "Telegram": ""
}' |  \
  http POST {{baseUrl}}/api/MBus \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Date": "",\n  "Telegram": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/MBus

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Date": "",
  "Telegram": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/MBus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Beta- Gets the General Information for a Meter or a Folder

{{baseUrl}}/api/MeterFolderInformation/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/MeterFolderInformation/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/MeterFolderInformation/:id")

require "http/client"

url = "{{baseUrl}}/api/MeterFolderInformation/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/MeterFolderInformation/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/MeterFolderInformation/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/MeterFolderInformation/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/MeterFolderInformation/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/MeterFolderInformation/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/MeterFolderInformation/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/MeterFolderInformation/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/MeterFolderInformation/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/MeterFolderInformation/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterFolderInformation/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/MeterFolderInformation/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/MeterFolderInformation/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/MeterFolderInformation/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/MeterFolderInformation/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterFolderInformation/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/MeterFolderInformation/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterFolderInformation/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/MeterFolderInformation/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/MeterFolderInformation/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/MeterFolderInformation/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/MeterFolderInformation/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/MeterFolderInformation/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/MeterFolderInformation/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/MeterFolderInformation/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/MeterFolderInformation/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/MeterFolderInformation/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/MeterFolderInformation/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/MeterFolderInformation/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/MeterFolderInformation/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/MeterFolderInformation/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/MeterFolderInformation/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/MeterFolderInformation/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/MeterFolderInformation/:id

http GET {{baseUrl}}/api/MeterFolderInformation/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/MeterFolderInformation/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/MeterFolderInformation/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Sets the Name of a Meter or a Folder

{{baseUrl}}/api/MeterFolderInformation

BODY json

{
  "Id": "",
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/MeterFolderInformation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/MeterFolderInformation" {:content-type :json
                                                                       :form-params {:Id ""
                                                                                     :Name ""}})

require "http/client"

url = "{{baseUrl}}/api/MeterFolderInformation"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/MeterFolderInformation"),
    Content = new StringContent("{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/MeterFolderInformation");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/MeterFolderInformation"

	payload := strings.NewReader("{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/MeterFolderInformation HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "Id": "",
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/MeterFolderInformation")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/MeterFolderInformation"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/MeterFolderInformation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/MeterFolderInformation")
  .header("content-type", "application/json")
  .body("{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Id: '',
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/MeterFolderInformation');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MeterFolderInformation',
  headers: {'content-type': 'application/json'},
  data: {Id: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/MeterFolderInformation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Id":"","Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/MeterFolderInformation',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Id": "",\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/MeterFolderInformation")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/MeterFolderInformation',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Id: '', Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MeterFolderInformation',
  headers: {'content-type': 'application/json'},
  body: {Id: '', Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/MeterFolderInformation');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Id: '',
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/MeterFolderInformation',
  headers: {'content-type': 'application/json'},
  data: {Id: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/MeterFolderInformation';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Id":"","Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Id": @"",
                              @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/MeterFolderInformation"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/MeterFolderInformation" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/MeterFolderInformation",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Id' => '',
    'Name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/MeterFolderInformation', [
  'body' => '{
  "Id": "",
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/MeterFolderInformation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Id' => '',
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Id' => '',
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/MeterFolderInformation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/MeterFolderInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/MeterFolderInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Id": "",
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/MeterFolderInformation", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/MeterFolderInformation"

payload = {
    "Id": "",
    "Name": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/MeterFolderInformation"

payload <- "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/MeterFolderInformation")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/MeterFolderInformation') do |req|
  req.body = "{\n  \"Id\": \"\",\n  \"Name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/MeterFolderInformation";

    let payload = json!({
        "Id": "",
        "Name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/MeterFolderInformation \
  --header 'content-type: application/json' \
  --data '{
  "Id": "",
  "Name": ""
}'

echo '{
  "Id": "",
  "Name": ""
}' |  \
  http POST {{baseUrl}}/api/MeterFolderInformation \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Id": "",\n  "Name": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/MeterFolderInformation

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Id": "",
  "Name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/MeterFolderInformation")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the Values for a Meter at a given Date. The first Value found before the given Date is returned.

{{baseUrl}}/api/MeterValues/:id

QUERY PARAMS

date

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/MeterValues/:id?date=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/MeterValues/:id" {:query-params {:date ""}})

require "http/client"

url = "{{baseUrl}}/api/MeterValues/:id?date="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/MeterValues/:id?date="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/MeterValues/:id?date=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/MeterValues/:id?date="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/MeterValues/:id?date= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/MeterValues/:id?date=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/MeterValues/:id?date="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/MeterValues/:id?date=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/MeterValues/:id?date=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/MeterValues/:id?date=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterValues/:id',
  params: {date: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/MeterValues/:id?date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/MeterValues/:id?date=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/MeterValues/:id?date=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/MeterValues/:id?date=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterValues/:id',
  qs: {date: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/MeterValues/:id');

req.query({
  date: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/MeterValues/:id',
  params: {date: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/MeterValues/:id?date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/MeterValues/:id?date="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/MeterValues/:id?date=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/MeterValues/:id?date=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/MeterValues/:id?date=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/MeterValues/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'date' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/MeterValues/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'date' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/MeterValues/:id?date=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/MeterValues/:id?date=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/MeterValues/:id?date=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/MeterValues/:id"

querystring = {"date":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/MeterValues/:id"

queryString <- list(date = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/MeterValues/:id?date=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/MeterValues/:id') do |req|
  req.params['date'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/MeterValues/:id";

    let querystring = [
        ("date", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/MeterValues/:id?date='

http GET '{{baseUrl}}/api/MeterValues/:id?date='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/MeterValues/:id?date='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/MeterValues/:id?date=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET OAuth_Authorize

{{baseUrl}}/api/oauth/authorize

QUERY PARAMS

client_id

redirect_uri

state

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oauth/authorize" {:query-params {:client_id ""
                                                                              :redirect_uri ""
                                                                              :state ""}})

require "http/client"

url = "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oauth/authorize',
  params: {client_id: '', redirect_uri: '', state: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oauth/authorize',
  qs: {client_id: '', redirect_uri: '', state: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oauth/authorize');

req.query({
  client_id: '',
  redirect_uri: '',
  state: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oauth/authorize',
  params: {client_id: '', redirect_uri: '', state: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/oauth/authorize');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'client_id' => '',
  'redirect_uri' => '',
  'state' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oauth/authorize');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'client_id' => '',
  'redirect_uri' => '',
  'state' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oauth/authorize"

querystring = {"client_id":"","redirect_uri":"","state":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oauth/authorize"

queryString <- list(
  client_id = "",
  redirect_uri = "",
  state = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oauth/authorize') do |req|
  req.params['client_id'] = ''
  req.params['redirect_uri'] = ''
  req.params['state'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oauth/authorize";

    let querystring = [
        ("client_id", ""),
        ("redirect_uri", ""),
        ("state", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

http GET '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST post -api-oauth-authorize

{{baseUrl}}/api/oauth/authorize

QUERY PARAMS

client_id

redirect_uri

state

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oauth/authorize" {:query-params {:client_id ""
                                                                               :redirect_uri ""
                                                                               :state ""}})

require "http/client"

url = "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oauth/authorize',
  params: {client_id: '', redirect_uri: '', state: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oauth/authorize',
  qs: {client_id: '', redirect_uri: '', state: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oauth/authorize');

req.query({
  client_id: '',
  redirect_uri: '',
  state: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oauth/authorize',
  params: {client_id: '', redirect_uri: '', state: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/oauth/authorize');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'client_id' => '',
  'redirect_uri' => '',
  'state' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oauth/authorize');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'client_id' => '',
  'redirect_uri' => '',
  'state' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/oauth/authorize?client_id=&redirect_uri=&state=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oauth/authorize"

querystring = {"client_id":"","redirect_uri":"","state":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oauth/authorize"

queryString <- list(
  client_id = "",
  redirect_uri = "",
  state = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oauth/authorize') do |req|
  req.params['client_id'] = ''
  req.params['redirect_uri'] = ''
  req.params['state'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oauth/authorize";

    let querystring = [
        ("client_id", ""),
        ("redirect_uri", ""),
        ("state", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

http POST '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oauth/authorize?client_id=&redirect_uri=&state=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all pico charging stations for this user

{{baseUrl}}/api/pico

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico")

require "http/client"

url = "{{baseUrl}}/api/pico"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/pico'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/pico'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/pico'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico

http GET {{baseUrl}}/api/pico

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the active charging data of a pico station

{{baseUrl}}/api/pico/charging/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/charging/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico/charging/:id")

require "http/client"

url = "{{baseUrl}}/api/pico/charging/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico/charging/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/charging/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/charging/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico/charging/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico/charging/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/charging/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/charging/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico/charging/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico/charging/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/charging/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/charging/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/charging/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/charging/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/charging/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/charging/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico/charging/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/charging/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/charging/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/charging/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/charging/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/charging/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico/charging/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/charging/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/charging/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/charging/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/charging/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico/charging/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/charging/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/charging/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/charging/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico/charging/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/charging/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico/charging/:id

http GET {{baseUrl}}/api/pico/charging/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico/charging/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/charging/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the last charging history for a pico station

{{baseUrl}}/api/pico/history/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/history/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico/history/:id")

require "http/client"

url = "{{baseUrl}}/api/pico/history/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico/history/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/history/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/history/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico/history/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico/history/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/history/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/history/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico/history/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico/history/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/history/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/history/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/history/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/history/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/history/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/history/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico/history/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/history/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/history/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/history/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/history/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/history/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico/history/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/history/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/history/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/history/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/history/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico/history/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/history/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/history/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/history/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico/history/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/history/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico/history/:id

http GET {{baseUrl}}/api/pico/history/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico/history/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/history/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Try to fix lock the cable of a pico. The pico must be online and a cable (without car) needs to be connected. Otherwise this will fail.

{{baseUrl}}/api/pico/tryenablecablelock/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/tryenablecablelock/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/pico/tryenablecablelock/:id")

require "http/client"

url = "{{baseUrl}}/api/pico/tryenablecablelock/:id"

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/pico/tryenablecablelock/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/tryenablecablelock/:id");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/tryenablecablelock/:id"

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/pico/tryenablecablelock/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/pico/tryenablecablelock/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/tryenablecablelock/:id"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/tryenablecablelock/:id")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/pico/tryenablecablelock/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/pico/tryenablecablelock/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/tryenablecablelock/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/tryenablecablelock/:id';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/tryenablecablelock/:id',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/tryenablecablelock/:id")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/tryenablecablelock/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/tryenablecablelock/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/pico/tryenablecablelock/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/tryenablecablelock/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/tryenablecablelock/:id';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/tryenablecablelock/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/tryenablecablelock/:id" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/tryenablecablelock/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/pico/tryenablecablelock/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/tryenablecablelock/:id');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/tryenablecablelock/:id');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/tryenablecablelock/:id' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/tryenablecablelock/:id' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/pico/tryenablecablelock/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/tryenablecablelock/:id"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/tryenablecablelock/:id"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/tryenablecablelock/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/pico/tryenablecablelock/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/tryenablecablelock/:id";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/pico/tryenablecablelock/:id

http POST {{baseUrl}}/api/pico/tryenablecablelock/:id

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/pico/tryenablecablelock/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/tryenablecablelock/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GET- api-pico-loadmanagementgroup Returns a pico load management group by it's id

{{baseUrl}}/api/pico/loadmanagementgroup/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/loadmanagementgroup/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico/loadmanagementgroup/:id")

require "http/client"

url = "{{baseUrl}}/api/pico/loadmanagementgroup/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico/loadmanagementgroup/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/loadmanagementgroup/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/loadmanagementgroup/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico/loadmanagementgroup/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico/loadmanagementgroup/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/loadmanagementgroup/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico/loadmanagementgroup/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico/loadmanagementgroup/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/loadmanagementgroup/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/loadmanagementgroup/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico/loadmanagementgroup/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/loadmanagementgroup/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/loadmanagementgroup/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/loadmanagementgroup/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/loadmanagementgroup/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico/loadmanagementgroup/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/loadmanagementgroup/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/loadmanagementgroup/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/loadmanagementgroup/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/loadmanagementgroup/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico/loadmanagementgroup/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/loadmanagementgroup/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/loadmanagementgroup/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/loadmanagementgroup/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico/loadmanagementgroup/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/loadmanagementgroup/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico/loadmanagementgroup/:id

http GET {{baseUrl}}/api/pico/loadmanagementgroup/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico/loadmanagementgroup/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/loadmanagementgroup/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GET- api-pico-loadmanagementgroup Returns all available load management groups

{{baseUrl}}/api/pico/loadmanagementgroup

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/loadmanagementgroup");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico/loadmanagementgroup")

require "http/client"

url = "{{baseUrl}}/api/pico/loadmanagementgroup"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico/loadmanagementgroup"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/loadmanagementgroup");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/loadmanagementgroup"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico/loadmanagementgroup HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico/loadmanagementgroup")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/loadmanagementgroup"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico/loadmanagementgroup")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico/loadmanagementgroup');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/loadmanagementgroup'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/loadmanagementgroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/loadmanagementgroup',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/loadmanagementgroup',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/loadmanagementgroup'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico/loadmanagementgroup');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/loadmanagementgroup'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/loadmanagementgroup';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/loadmanagementgroup"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/loadmanagementgroup" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/loadmanagementgroup",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico/loadmanagementgroup');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/loadmanagementgroup');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/loadmanagementgroup');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/loadmanagementgroup' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/loadmanagementgroup' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico/loadmanagementgroup")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/loadmanagementgroup"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/loadmanagementgroup"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/loadmanagementgroup")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico/loadmanagementgroup') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/loadmanagementgroup";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico/loadmanagementgroup

http GET {{baseUrl}}/api/pico/loadmanagementgroup

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico/loadmanagementgroup

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/loadmanagementgroup")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Sets the dynamic current of a load management group or a single station.

{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial

QUERY PARAMS

current

serial

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial" {:query-params {:current ""}})

require "http/client"

url = "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/pico/loadmanagementgroup/current/:serial?current= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial',
  params: {current: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/loadmanagementgroup/current/:serial?current=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial',
  qs: {current: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial');

req.query({
  current: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial',
  params: {current: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'current' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'current' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/pico/loadmanagementgroup/current/:serial?current=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial"

querystring = {"current":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial"

queryString <- list(current = "")

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/pico/loadmanagementgroup/current/:serial') do |req|
  req.params['current'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial";

    let querystring = [
        ("current", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current='

http POST '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/loadmanagementgroup/current/:serial?current=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET GET- api-pico-settings Returns the settings of a pico charging station.

{{baseUrl}}/api/pico/settings/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/pico/settings/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/pico/settings/:id")

require "http/client"

url = "{{baseUrl}}/api/pico/settings/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/pico/settings/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/pico/settings/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/pico/settings/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/pico/settings/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/pico/settings/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/pico/settings/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/pico/settings/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/pico/settings/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/pico/settings/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/pico/settings/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/pico/settings/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/pico/settings/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/pico/settings/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/settings/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/pico/settings/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/pico/settings/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/pico/settings/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/pico/settings/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/pico/settings/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/pico/settings/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/pico/settings/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/pico/settings/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/pico/settings/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/pico/settings/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/pico/settings/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/pico/settings/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/pico/settings/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/pico/settings/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/pico/settings/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/pico/settings/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/pico/settings/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/pico/settings/:id

http GET {{baseUrl}}/api/pico/settings/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/pico/settings/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/pico/settings/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates a new registration for the realtime API. The Realtime API sends you the data of the registred devices as soon as we have them on the cloud. More Information about the realtime API- https---www.smart-me.com-Description-api-realtimeapi.aspx

{{baseUrl}}/api/RegisterForRealtimeApi

BODY json

{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/RegisterForRealtimeApi");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/RegisterForRealtimeApi" {:content-type :json
                                                                       :form-params {:ApiUrl ""
                                                                                     :BasicAuthPassword ""
                                                                                     :BasicAuthUsername ""
                                                                                     :Id ""
                                                                                     :MeterId ""
                                                                                     :RegistrationType ""
                                                                                     :SerialNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/RegisterForRealtimeApi"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/RegisterForRealtimeApi"),
    Content = new StringContent("{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/RegisterForRealtimeApi");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/RegisterForRealtimeApi"

	payload := strings.NewReader("{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/RegisterForRealtimeApi HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 149

{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/RegisterForRealtimeApi")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/RegisterForRealtimeApi"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/RegisterForRealtimeApi")
  .header("content-type", "application/json")
  .body("{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApiUrl: '',
  BasicAuthPassword: '',
  BasicAuthUsername: '',
  Id: '',
  MeterId: '',
  RegistrationType: '',
  SerialNumber: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/RegisterForRealtimeApi');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi',
  headers: {'content-type': 'application/json'},
  data: {
    ApiUrl: '',
    BasicAuthPassword: '',
    BasicAuthUsername: '',
    Id: '',
    MeterId: '',
    RegistrationType: '',
    SerialNumber: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/RegisterForRealtimeApi';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ApiUrl":"","BasicAuthPassword":"","BasicAuthUsername":"","Id":"","MeterId":"","RegistrationType":"","SerialNumber":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/RegisterForRealtimeApi',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApiUrl": "",\n  "BasicAuthPassword": "",\n  "BasicAuthUsername": "",\n  "Id": "",\n  "MeterId": "",\n  "RegistrationType": "",\n  "SerialNumber": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/RegisterForRealtimeApi',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  ApiUrl: '',
  BasicAuthPassword: '',
  BasicAuthUsername: '',
  Id: '',
  MeterId: '',
  RegistrationType: '',
  SerialNumber: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi',
  headers: {'content-type': 'application/json'},
  body: {
    ApiUrl: '',
    BasicAuthPassword: '',
    BasicAuthUsername: '',
    Id: '',
    MeterId: '',
    RegistrationType: '',
    SerialNumber: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/RegisterForRealtimeApi');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ApiUrl: '',
  BasicAuthPassword: '',
  BasicAuthUsername: '',
  Id: '',
  MeterId: '',
  RegistrationType: '',
  SerialNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi',
  headers: {'content-type': 'application/json'},
  data: {
    ApiUrl: '',
    BasicAuthPassword: '',
    BasicAuthUsername: '',
    Id: '',
    MeterId: '',
    RegistrationType: '',
    SerialNumber: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/RegisterForRealtimeApi';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ApiUrl":"","BasicAuthPassword":"","BasicAuthUsername":"","Id":"","MeterId":"","RegistrationType":"","SerialNumber":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ApiUrl": @"",
                              @"BasicAuthPassword": @"",
                              @"BasicAuthUsername": @"",
                              @"Id": @"",
                              @"MeterId": @"",
                              @"RegistrationType": @"",
                              @"SerialNumber": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/RegisterForRealtimeApi"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/RegisterForRealtimeApi" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/RegisterForRealtimeApi",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ApiUrl' => '',
    'BasicAuthPassword' => '',
    'BasicAuthUsername' => '',
    'Id' => '',
    'MeterId' => '',
    'RegistrationType' => '',
    'SerialNumber' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/RegisterForRealtimeApi', [
  'body' => '{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/RegisterForRealtimeApi');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApiUrl' => '',
  'BasicAuthPassword' => '',
  'BasicAuthUsername' => '',
  'Id' => '',
  'MeterId' => '',
  'RegistrationType' => '',
  'SerialNumber' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApiUrl' => '',
  'BasicAuthPassword' => '',
  'BasicAuthUsername' => '',
  'Id' => '',
  'MeterId' => '',
  'RegistrationType' => '',
  'SerialNumber' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/RegisterForRealtimeApi');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/RegisterForRealtimeApi' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/RegisterForRealtimeApi' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/RegisterForRealtimeApi", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/RegisterForRealtimeApi"

payload = {
    "ApiUrl": "",
    "BasicAuthPassword": "",
    "BasicAuthUsername": "",
    "Id": "",
    "MeterId": "",
    "RegistrationType": "",
    "SerialNumber": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/RegisterForRealtimeApi"

payload <- "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/RegisterForRealtimeApi")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/RegisterForRealtimeApi') do |req|
  req.body = "{\n  \"ApiUrl\": \"\",\n  \"BasicAuthPassword\": \"\",\n  \"BasicAuthUsername\": \"\",\n  \"Id\": \"\",\n  \"MeterId\": \"\",\n  \"RegistrationType\": \"\",\n  \"SerialNumber\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/RegisterForRealtimeApi";

    let payload = json!({
        "ApiUrl": "",
        "BasicAuthPassword": "",
        "BasicAuthUsername": "",
        "Id": "",
        "MeterId": "",
        "RegistrationType": "",
        "SerialNumber": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/RegisterForRealtimeApi \
  --header 'content-type: application/json' \
  --data '{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}'

echo '{
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
}' |  \
  http POST {{baseUrl}}/api/RegisterForRealtimeApi \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApiUrl": "",\n  "BasicAuthPassword": "",\n  "BasicAuthUsername": "",\n  "Id": "",\n  "MeterId": "",\n  "RegistrationType": "",\n  "SerialNumber": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/RegisterForRealtimeApi

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ApiUrl": "",
  "BasicAuthPassword": "",
  "BasicAuthUsername": "",
  "Id": "",
  "MeterId": "",
  "RegistrationType": "",
  "SerialNumber": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/RegisterForRealtimeApi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Deletes a realtime API registration.

{{baseUrl}}/api/RegisterForRealtimeApi/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/RegisterForRealtimeApi/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/RegisterForRealtimeApi/:id")

require "http/client"

url = "{{baseUrl}}/api/RegisterForRealtimeApi/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/RegisterForRealtimeApi/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/RegisterForRealtimeApi/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/RegisterForRealtimeApi/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/RegisterForRealtimeApi/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/RegisterForRealtimeApi/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/RegisterForRealtimeApi/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/RegisterForRealtimeApi/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/RegisterForRealtimeApi/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/RegisterForRealtimeApi/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/RegisterForRealtimeApi/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/RegisterForRealtimeApi/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/RegisterForRealtimeApi/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/RegisterForRealtimeApi/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/RegisterForRealtimeApi/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/RegisterForRealtimeApi/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/RegisterForRealtimeApi/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/RegisterForRealtimeApi/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/RegisterForRealtimeApi/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/RegisterForRealtimeApi/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/RegisterForRealtimeApi/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/RegisterForRealtimeApi/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/RegisterForRealtimeApi/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/RegisterForRealtimeApi/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/RegisterForRealtimeApi/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/RegisterForRealtimeApi/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/RegisterForRealtimeApi/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/RegisterForRealtimeApi/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/RegisterForRealtimeApi/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/RegisterForRealtimeApi/:id

http DELETE {{baseUrl}}/api/RegisterForRealtimeApi/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/RegisterForRealtimeApi/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/RegisterForRealtimeApi/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all registrations for the Realtime API.

{{baseUrl}}/api/RegisterForRealtimeApi

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/RegisterForRealtimeApi");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/RegisterForRealtimeApi")

require "http/client"

url = "{{baseUrl}}/api/RegisterForRealtimeApi"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/RegisterForRealtimeApi"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/RegisterForRealtimeApi");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/RegisterForRealtimeApi"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/RegisterForRealtimeApi HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/RegisterForRealtimeApi")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/RegisterForRealtimeApi"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/RegisterForRealtimeApi")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/RegisterForRealtimeApi');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/RegisterForRealtimeApi'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/RegisterForRealtimeApi';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/RegisterForRealtimeApi',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/RegisterForRealtimeApi")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/RegisterForRealtimeApi',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/RegisterForRealtimeApi'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/RegisterForRealtimeApi');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/RegisterForRealtimeApi'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/RegisterForRealtimeApi';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/RegisterForRealtimeApi"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/RegisterForRealtimeApi" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/RegisterForRealtimeApi",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/RegisterForRealtimeApi');

echo $response->getBody();

setUrl('{{baseUrl}}/api/RegisterForRealtimeApi');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/RegisterForRealtimeApi');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/RegisterForRealtimeApi' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/RegisterForRealtimeApi' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/RegisterForRealtimeApi")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/RegisterForRealtimeApi"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/RegisterForRealtimeApi"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/RegisterForRealtimeApi")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/RegisterForRealtimeApi') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/RegisterForRealtimeApi";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/RegisterForRealtimeApi

http GET {{baseUrl}}/api/RegisterForRealtimeApi

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/RegisterForRealtimeApi

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/RegisterForRealtimeApi")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the configuration of a smart-me device.

{{baseUrl}}/api/SmartMeDeviceConfiguration/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")

require "http/client"

url = "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/SmartMeDeviceConfiguration/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/SmartMeDeviceConfiguration/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/SmartMeDeviceConfiguration/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/SmartMeDeviceConfiguration/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/SmartMeDeviceConfiguration/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/SmartMeDeviceConfiguration/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/SmartMeDeviceConfiguration/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/SmartMeDeviceConfiguration/:id

http GET {{baseUrl}}/api/SmartMeDeviceConfiguration/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/SmartMeDeviceConfiguration/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/SmartMeDeviceConfiguration/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Sets the configuration of a smart-me device. The device needs to be online.

{{baseUrl}}/api/SmartMeDeviceConfiguration

BODY json

{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/SmartMeDeviceConfiguration");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/SmartMeDeviceConfiguration" {:content-type :json
                                                                           :form-params {:DeviceEncryptionKey ""
                                                                                         :DevicePinCode ""
                                                                                         :DnsUpdateState ""
                                                                                         :EnableModbusTcp false
                                                                                         :Id ""
                                                                                         :InputConfiguration [{:Name ""
                                                                                                               :Number 0
                                                                                                               :OffText ""
                                                                                                               :OnText ""
                                                                                                               :Type ""}]
                                                                                         :OutputConfiguration [{:DigitalOutputNoConnectionAction ""
                                                                                                                :Name ""
                                                                                                                :Number 0
                                                                                                                :S0PulseValue ""
                                                                                                                :Type ""}]
                                                                                         :ShowReactiveEnergy false
                                                                                         :SwitchConfiguration [{:CanSwitchOff false
                                                                                                                :Number 0}]
                                                                                         :UploadInterval ""}})

require "http/client"

url = "{{baseUrl}}/api/SmartMeDeviceConfiguration"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/SmartMeDeviceConfiguration"),
    Content = new StringContent("{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/SmartMeDeviceConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/SmartMeDeviceConfiguration"

	payload := strings.NewReader("{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/SmartMeDeviceConfiguration HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 571

{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/SmartMeDeviceConfiguration")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/SmartMeDeviceConfiguration"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/SmartMeDeviceConfiguration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/SmartMeDeviceConfiguration")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeviceEncryptionKey: '',
  DevicePinCode: '',
  DnsUpdateState: '',
  EnableModbusTcp: false,
  Id: '',
  InputConfiguration: [
    {
      Name: '',
      Number: 0,
      OffText: '',
      OnText: '',
      Type: ''
    }
  ],
  OutputConfiguration: [
    {
      DigitalOutputNoConnectionAction: '',
      Name: '',
      Number: 0,
      S0PulseValue: '',
      Type: ''
    }
  ],
  ShowReactiveEnergy: false,
  SwitchConfiguration: [
    {
      CanSwitchOff: false,
      Number: 0
    }
  ],
  UploadInterval: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/SmartMeDeviceConfiguration');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceEncryptionKey: '',
    DevicePinCode: '',
    DnsUpdateState: '',
    EnableModbusTcp: false,
    Id: '',
    InputConfiguration: [{Name: '', Number: 0, OffText: '', OnText: '', Type: ''}],
    OutputConfiguration: [
      {
        DigitalOutputNoConnectionAction: '',
        Name: '',
        Number: 0,
        S0PulseValue: '',
        Type: ''
      }
    ],
    ShowReactiveEnergy: false,
    SwitchConfiguration: [{CanSwitchOff: false, Number: 0}],
    UploadInterval: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/SmartMeDeviceConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceEncryptionKey":"","DevicePinCode":"","DnsUpdateState":"","EnableModbusTcp":false,"Id":"","InputConfiguration":[{"Name":"","Number":0,"OffText":"","OnText":"","Type":""}],"OutputConfiguration":[{"DigitalOutputNoConnectionAction":"","Name":"","Number":0,"S0PulseValue":"","Type":""}],"ShowReactiveEnergy":false,"SwitchConfiguration":[{"CanSwitchOff":false,"Number":0}],"UploadInterval":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceEncryptionKey": "",\n  "DevicePinCode": "",\n  "DnsUpdateState": "",\n  "EnableModbusTcp": false,\n  "Id": "",\n  "InputConfiguration": [\n    {\n      "Name": "",\n      "Number": 0,\n      "OffText": "",\n      "OnText": "",\n      "Type": ""\n    }\n  ],\n  "OutputConfiguration": [\n    {\n      "DigitalOutputNoConnectionAction": "",\n      "Name": "",\n      "Number": 0,\n      "S0PulseValue": "",\n      "Type": ""\n    }\n  ],\n  "ShowReactiveEnergy": false,\n  "SwitchConfiguration": [\n    {\n      "CanSwitchOff": false,\n      "Number": 0\n    }\n  ],\n  "UploadInterval": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/SmartMeDeviceConfiguration")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/SmartMeDeviceConfiguration',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  DeviceEncryptionKey: '',
  DevicePinCode: '',
  DnsUpdateState: '',
  EnableModbusTcp: false,
  Id: '',
  InputConfiguration: [{Name: '', Number: 0, OffText: '', OnText: '', Type: ''}],
  OutputConfiguration: [
    {
      DigitalOutputNoConnectionAction: '',
      Name: '',
      Number: 0,
      S0PulseValue: '',
      Type: ''
    }
  ],
  ShowReactiveEnergy: false,
  SwitchConfiguration: [{CanSwitchOff: false, Number: 0}],
  UploadInterval: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration',
  headers: {'content-type': 'application/json'},
  body: {
    DeviceEncryptionKey: '',
    DevicePinCode: '',
    DnsUpdateState: '',
    EnableModbusTcp: false,
    Id: '',
    InputConfiguration: [{Name: '', Number: 0, OffText: '', OnText: '', Type: ''}],
    OutputConfiguration: [
      {
        DigitalOutputNoConnectionAction: '',
        Name: '',
        Number: 0,
        S0PulseValue: '',
        Type: ''
      }
    ],
    ShowReactiveEnergy: false,
    SwitchConfiguration: [{CanSwitchOff: false, Number: 0}],
    UploadInterval: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/SmartMeDeviceConfiguration');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DeviceEncryptionKey: '',
  DevicePinCode: '',
  DnsUpdateState: '',
  EnableModbusTcp: false,
  Id: '',
  InputConfiguration: [
    {
      Name: '',
      Number: 0,
      OffText: '',
      OnText: '',
      Type: ''
    }
  ],
  OutputConfiguration: [
    {
      DigitalOutputNoConnectionAction: '',
      Name: '',
      Number: 0,
      S0PulseValue: '',
      Type: ''
    }
  ],
  ShowReactiveEnergy: false,
  SwitchConfiguration: [
    {
      CanSwitchOff: false,
      Number: 0
    }
  ],
  UploadInterval: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SmartMeDeviceConfiguration',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceEncryptionKey: '',
    DevicePinCode: '',
    DnsUpdateState: '',
    EnableModbusTcp: false,
    Id: '',
    InputConfiguration: [{Name: '', Number: 0, OffText: '', OnText: '', Type: ''}],
    OutputConfiguration: [
      {
        DigitalOutputNoConnectionAction: '',
        Name: '',
        Number: 0,
        S0PulseValue: '',
        Type: ''
      }
    ],
    ShowReactiveEnergy: false,
    SwitchConfiguration: [{CanSwitchOff: false, Number: 0}],
    UploadInterval: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/SmartMeDeviceConfiguration';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceEncryptionKey":"","DevicePinCode":"","DnsUpdateState":"","EnableModbusTcp":false,"Id":"","InputConfiguration":[{"Name":"","Number":0,"OffText":"","OnText":"","Type":""}],"OutputConfiguration":[{"DigitalOutputNoConnectionAction":"","Name":"","Number":0,"S0PulseValue":"","Type":""}],"ShowReactiveEnergy":false,"SwitchConfiguration":[{"CanSwitchOff":false,"Number":0}],"UploadInterval":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DeviceEncryptionKey": @"",
                              @"DevicePinCode": @"",
                              @"DnsUpdateState": @"",
                              @"EnableModbusTcp": @NO,
                              @"Id": @"",
                              @"InputConfiguration": @[ @{ @"Name": @"", @"Number": @0, @"OffText": @"", @"OnText": @"", @"Type": @"" } ],
                              @"OutputConfiguration": @[ @{ @"DigitalOutputNoConnectionAction": @"", @"Name": @"", @"Number": @0, @"S0PulseValue": @"", @"Type": @"" } ],
                              @"ShowReactiveEnergy": @NO,
                              @"SwitchConfiguration": @[ @{ @"CanSwitchOff": @NO, @"Number": @0 } ],
                              @"UploadInterval": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/SmartMeDeviceConfiguration"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/SmartMeDeviceConfiguration" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/SmartMeDeviceConfiguration",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceEncryptionKey' => '',
    'DevicePinCode' => '',
    'DnsUpdateState' => '',
    'EnableModbusTcp' => null,
    'Id' => '',
    'InputConfiguration' => [
        [
                'Name' => '',
                'Number' => 0,
                'OffText' => '',
                'OnText' => '',
                'Type' => ''
        ]
    ],
    'OutputConfiguration' => [
        [
                'DigitalOutputNoConnectionAction' => '',
                'Name' => '',
                'Number' => 0,
                'S0PulseValue' => '',
                'Type' => ''
        ]
    ],
    'ShowReactiveEnergy' => null,
    'SwitchConfiguration' => [
        [
                'CanSwitchOff' => null,
                'Number' => 0
        ]
    ],
    'UploadInterval' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/SmartMeDeviceConfiguration', [
  'body' => '{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/SmartMeDeviceConfiguration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceEncryptionKey' => '',
  'DevicePinCode' => '',
  'DnsUpdateState' => '',
  'EnableModbusTcp' => null,
  'Id' => '',
  'InputConfiguration' => [
    [
        'Name' => '',
        'Number' => 0,
        'OffText' => '',
        'OnText' => '',
        'Type' => ''
    ]
  ],
  'OutputConfiguration' => [
    [
        'DigitalOutputNoConnectionAction' => '',
        'Name' => '',
        'Number' => 0,
        'S0PulseValue' => '',
        'Type' => ''
    ]
  ],
  'ShowReactiveEnergy' => null,
  'SwitchConfiguration' => [
    [
        'CanSwitchOff' => null,
        'Number' => 0
    ]
  ],
  'UploadInterval' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DeviceEncryptionKey' => '',
  'DevicePinCode' => '',
  'DnsUpdateState' => '',
  'EnableModbusTcp' => null,
  'Id' => '',
  'InputConfiguration' => [
    [
        'Name' => '',
        'Number' => 0,
        'OffText' => '',
        'OnText' => '',
        'Type' => ''
    ]
  ],
  'OutputConfiguration' => [
    [
        'DigitalOutputNoConnectionAction' => '',
        'Name' => '',
        'Number' => 0,
        'S0PulseValue' => '',
        'Type' => ''
    ]
  ],
  'ShowReactiveEnergy' => null,
  'SwitchConfiguration' => [
    [
        'CanSwitchOff' => null,
        'Number' => 0
    ]
  ],
  'UploadInterval' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/SmartMeDeviceConfiguration');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/SmartMeDeviceConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/SmartMeDeviceConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/SmartMeDeviceConfiguration", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/SmartMeDeviceConfiguration"

payload = {
    "DeviceEncryptionKey": "",
    "DevicePinCode": "",
    "DnsUpdateState": "",
    "EnableModbusTcp": False,
    "Id": "",
    "InputConfiguration": [
        {
            "Name": "",
            "Number": 0,
            "OffText": "",
            "OnText": "",
            "Type": ""
        }
    ],
    "OutputConfiguration": [
        {
            "DigitalOutputNoConnectionAction": "",
            "Name": "",
            "Number": 0,
            "S0PulseValue": "",
            "Type": ""
        }
    ],
    "ShowReactiveEnergy": False,
    "SwitchConfiguration": [
        {
            "CanSwitchOff": False,
            "Number": 0
        }
    ],
    "UploadInterval": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/SmartMeDeviceConfiguration"

payload <- "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/SmartMeDeviceConfiguration")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/SmartMeDeviceConfiguration') do |req|
  req.body = "{\n  \"DeviceEncryptionKey\": \"\",\n  \"DevicePinCode\": \"\",\n  \"DnsUpdateState\": \"\",\n  \"EnableModbusTcp\": false,\n  \"Id\": \"\",\n  \"InputConfiguration\": [\n    {\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"OffText\": \"\",\n      \"OnText\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"OutputConfiguration\": [\n    {\n      \"DigitalOutputNoConnectionAction\": \"\",\n      \"Name\": \"\",\n      \"Number\": 0,\n      \"S0PulseValue\": \"\",\n      \"Type\": \"\"\n    }\n  ],\n  \"ShowReactiveEnergy\": false,\n  \"SwitchConfiguration\": [\n    {\n      \"CanSwitchOff\": false,\n      \"Number\": 0\n    }\n  ],\n  \"UploadInterval\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/SmartMeDeviceConfiguration";

    let payload = json!({
        "DeviceEncryptionKey": "",
        "DevicePinCode": "",
        "DnsUpdateState": "",
        "EnableModbusTcp": false,
        "Id": "",
        "InputConfiguration": (
            json!({
                "Name": "",
                "Number": 0,
                "OffText": "",
                "OnText": "",
                "Type": ""
            })
        ),
        "OutputConfiguration": (
            json!({
                "DigitalOutputNoConnectionAction": "",
                "Name": "",
                "Number": 0,
                "S0PulseValue": "",
                "Type": ""
            })
        ),
        "ShowReactiveEnergy": false,
        "SwitchConfiguration": (
            json!({
                "CanSwitchOff": false,
                "Number": 0
            })
        ),
        "UploadInterval": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/SmartMeDeviceConfiguration \
  --header 'content-type: application/json' \
  --data '{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}'

echo '{
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    {
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    }
  ],
  "OutputConfiguration": [
    {
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    }
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    {
      "CanSwitchOff": false,
      "Number": 0
    }
  ],
  "UploadInterval": ""
}' |  \
  http POST {{baseUrl}}/api/SmartMeDeviceConfiguration \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceEncryptionKey": "",\n  "DevicePinCode": "",\n  "DnsUpdateState": "",\n  "EnableModbusTcp": false,\n  "Id": "",\n  "InputConfiguration": [\n    {\n      "Name": "",\n      "Number": 0,\n      "OffText": "",\n      "OnText": "",\n      "Type": ""\n    }\n  ],\n  "OutputConfiguration": [\n    {\n      "DigitalOutputNoConnectionAction": "",\n      "Name": "",\n      "Number": 0,\n      "S0PulseValue": "",\n      "Type": ""\n    }\n  ],\n  "ShowReactiveEnergy": false,\n  "SwitchConfiguration": [\n    {\n      "CanSwitchOff": false,\n      "Number": 0\n    }\n  ],\n  "UploadInterval": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/SmartMeDeviceConfiguration

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DeviceEncryptionKey": "",
  "DevicePinCode": "",
  "DnsUpdateState": "",
  "EnableModbusTcp": false,
  "Id": "",
  "InputConfiguration": [
    [
      "Name": "",
      "Number": 0,
      "OffText": "",
      "OnText": "",
      "Type": ""
    ]
  ],
  "OutputConfiguration": [
    [
      "DigitalOutputNoConnectionAction": "",
      "Name": "",
      "Number": 0,
      "S0PulseValue": "",
      "Type": ""
    ]
  ],
  "ShowReactiveEnergy": false,
  "SwitchConfiguration": [
    [
      "CanSwitchOff": false,
      "Number": 0
    ]
  ],
  "UploadInterval": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/SmartMeDeviceConfiguration")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Creates or updates a subuser. To create a new user set no ID (empty)

{{baseUrl}}/api/SubUser

BODY json

{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/SubUser");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/SubUser" {:content-type :json
                                                        :form-params {:AccessEndDate ""
                                                                      :AccessTimeStartDate ""
                                                                      :Email ""
                                                                      :Id ""
                                                                      :NewPassword ""
                                                                      :PermissionLevel ""
                                                                      :Username ""}})

require "http/client"

url = "{{baseUrl}}/api/SubUser"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/SubUser"),
    Content = new StringContent("{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/SubUser");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/SubUser"

	payload := strings.NewReader("{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/SubUser HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 145

{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/SubUser")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/SubUser"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/SubUser")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/SubUser")
  .header("content-type", "application/json")
  .body("{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccessEndDate: '',
  AccessTimeStartDate: '',
  Email: '',
  Id: '',
  NewPassword: '',
  PermissionLevel: '',
  Username: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/SubUser');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SubUser',
  headers: {'content-type': 'application/json'},
  data: {
    AccessEndDate: '',
    AccessTimeStartDate: '',
    Email: '',
    Id: '',
    NewPassword: '',
    PermissionLevel: '',
    Username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/SubUser';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccessEndDate":"","AccessTimeStartDate":"","Email":"","Id":"","NewPassword":"","PermissionLevel":"","Username":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/SubUser',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccessEndDate": "",\n  "AccessTimeStartDate": "",\n  "Email": "",\n  "Id": "",\n  "NewPassword": "",\n  "PermissionLevel": "",\n  "Username": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/SubUser")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/SubUser',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  AccessEndDate: '',
  AccessTimeStartDate: '',
  Email: '',
  Id: '',
  NewPassword: '',
  PermissionLevel: '',
  Username: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SubUser',
  headers: {'content-type': 'application/json'},
  body: {
    AccessEndDate: '',
    AccessTimeStartDate: '',
    Email: '',
    Id: '',
    NewPassword: '',
    PermissionLevel: '',
    Username: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/SubUser');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AccessEndDate: '',
  AccessTimeStartDate: '',
  Email: '',
  Id: '',
  NewPassword: '',
  PermissionLevel: '',
  Username: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/SubUser',
  headers: {'content-type': 'application/json'},
  data: {
    AccessEndDate: '',
    AccessTimeStartDate: '',
    Email: '',
    Id: '',
    NewPassword: '',
    PermissionLevel: '',
    Username: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/SubUser';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AccessEndDate":"","AccessTimeStartDate":"","Email":"","Id":"","NewPassword":"","PermissionLevel":"","Username":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AccessEndDate": @"",
                              @"AccessTimeStartDate": @"",
                              @"Email": @"",
                              @"Id": @"",
                              @"NewPassword": @"",
                              @"PermissionLevel": @"",
                              @"Username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/SubUser"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/SubUser" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/SubUser",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'AccessEndDate' => '',
    'AccessTimeStartDate' => '',
    'Email' => '',
    'Id' => '',
    'NewPassword' => '',
    'PermissionLevel' => '',
    'Username' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/SubUser', [
  'body' => '{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/SubUser');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccessEndDate' => '',
  'AccessTimeStartDate' => '',
  'Email' => '',
  'Id' => '',
  'NewPassword' => '',
  'PermissionLevel' => '',
  'Username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AccessEndDate' => '',
  'AccessTimeStartDate' => '',
  'Email' => '',
  'Id' => '',
  'NewPassword' => '',
  'PermissionLevel' => '',
  'Username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/SubUser');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/SubUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/SubUser' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/SubUser", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/SubUser"

payload = {
    "AccessEndDate": "",
    "AccessTimeStartDate": "",
    "Email": "",
    "Id": "",
    "NewPassword": "",
    "PermissionLevel": "",
    "Username": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/SubUser"

payload <- "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/SubUser")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/SubUser') do |req|
  req.body = "{\n  \"AccessEndDate\": \"\",\n  \"AccessTimeStartDate\": \"\",\n  \"Email\": \"\",\n  \"Id\": \"\",\n  \"NewPassword\": \"\",\n  \"PermissionLevel\": \"\",\n  \"Username\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/SubUser";

    let payload = json!({
        "AccessEndDate": "",
        "AccessTimeStartDate": "",
        "Email": "",
        "Id": "",
        "NewPassword": "",
        "PermissionLevel": "",
        "Username": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/SubUser \
  --header 'content-type: application/json' \
  --data '{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}'

echo '{
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
}' |  \
  http POST {{baseUrl}}/api/SubUser \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccessEndDate": "",\n  "AccessTimeStartDate": "",\n  "Email": "",\n  "Id": "",\n  "NewPassword": "",\n  "PermissionLevel": "",\n  "Username": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/SubUser

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AccessEndDate": "",
  "AccessTimeStartDate": "",
  "Email": "",
  "Id": "",
  "NewPassword": "",
  "PermissionLevel": "",
  "Username": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/SubUser")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete a subuser

{{baseUrl}}/api/SubUser/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/SubUser/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/SubUser/:id")

require "http/client"

url = "{{baseUrl}}/api/SubUser/:id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/SubUser/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/SubUser/:id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/SubUser/:id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/SubUser/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/SubUser/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/SubUser/:id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/SubUser/:id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/SubUser/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/SubUser/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/SubUser/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/SubUser/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/SubUser/:id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/SubUser/:id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/SubUser/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/api/SubUser/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/SubUser/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/api/SubUser/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/SubUser/:id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/SubUser/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/SubUser/:id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/SubUser/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/SubUser/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/SubUser/:id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/SubUser/:id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/SubUser/:id' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/SubUser/:id' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/SubUser/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/SubUser/:id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/SubUser/:id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/SubUser/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/SubUser/:id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/SubUser/:id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/SubUser/:id

http DELETE {{baseUrl}}/api/SubUser/:id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/SubUser/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/SubUser/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get a sub user. The user must be assigend to the user that makes this call.

{{baseUrl}}/api/SubUser/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/SubUser/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/SubUser/:id")

require "http/client"

url = "{{baseUrl}}/api/SubUser/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/SubUser/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/SubUser/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/SubUser/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/SubUser/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/SubUser/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/SubUser/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/SubUser/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/SubUser/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/SubUser/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/SubUser/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/SubUser/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/SubUser/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/SubUser/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/SubUser/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/SubUser/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/SubUser/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/SubUser/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/SubUser/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/SubUser/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/SubUser/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/SubUser/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/SubUser/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/SubUser/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/SubUser/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/SubUser/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/SubUser/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/SubUser/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/SubUser/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/SubUser/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/SubUser/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/SubUser/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/SubUser/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/SubUser/:id

http GET {{baseUrl}}/api/SubUser/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/SubUser/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/SubUser/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the informations for the user.

{{baseUrl}}/api/User

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/User");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/User")

require "http/client"

url = "{{baseUrl}}/api/User"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/User"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/User");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/User"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/User HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/User")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/User"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/User")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/User")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/User');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/User'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/User';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/User',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/User")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/User',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/User'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/User');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/User'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/User';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/User"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/User" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/User",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/User');

echo $response->getBody();

setUrl('{{baseUrl}}/api/User');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/User');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/User' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/User' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/User")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/User"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/User"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/User")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/User') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/User";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/User

http GET {{baseUrl}}/api/User

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/User

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/User")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Triggers user account deletion.

{{baseUrl}}/api/User

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/User");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/User")

require "http/client"

url = "{{baseUrl}}/api/User"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/User"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/User");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/User"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/User HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/User")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/User"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/User")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/User")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/User');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/api/User'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/User';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/User',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/User")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/User',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'DELETE', url: '{{baseUrl}}/api/User'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/User');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'DELETE', url: '{{baseUrl}}/api/User'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/User';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/User"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/User" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/User",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/User');

echo $response->getBody();

setUrl('{{baseUrl}}/api/User');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/User');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/User' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/User' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/User")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/User"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/User"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/User")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/User') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/User";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/User

http DELETE {{baseUrl}}/api/User

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/api/User

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/User")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Assign a user to a folder

{{baseUrl}}/api/folder/user/assign

QUERY PARAMS

source

target

oldFolder

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/folder/user/assign" {:query-params {:source ""
                                                                                  :target ""
                                                                                  :oldFolder ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder="

response = HTTP::Client.post url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder="

	req, _ := http.NewRequest("POST", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/folder/user/assign?source=&target=&oldFolder= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder="))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/user/assign',
  params: {source: '', target: '', oldFolder: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/user/assign?source=&target=&oldFolder=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/user/assign',
  qs: {source: '', target: '', oldFolder: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/folder/user/assign');

req.query({
  source: '',
  target: '',
  oldFolder: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/user/assign',
  params: {source: '', target: '', oldFolder: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=';
const options = {method: 'POST'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/user/assign');
$request->setMethod(HTTP_METH_POST);

$request->setQueryData([
  'source' => '',
  'target' => '',
  'oldFolder' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/folder/user/assign');
$request->setRequestMethod('POST');
$request->setQuery(new http\QueryString([
  'source' => '',
  'target' => '',
  'oldFolder' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=' -Method POST

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/api/folder/user/assign?source=&target=&oldFolder=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/user/assign"

querystring = {"source":"","target":"","oldFolder":""}

response = requests.post(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/user/assign"

queryString <- list(
  source = "",
  target = "",
  oldFolder = ""
)

response <- VERB("POST", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/folder/user/assign') do |req|
  req.params['source'] = ''
  req.params['target'] = ''
  req.params['oldFolder'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/user/assign";

    let querystring = [
        ("source", ""),
        ("target", ""),
        ("oldFolder", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.post(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder='

http POST '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder='

wget --quiet \
  --method POST \
  --output-document \
  - '{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/user/assign?source=&target=&oldFolder=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Deletes a user to folder assignement

{{baseUrl}}/api/folder/user/assign

QUERY PARAMS

source

target

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/user/assign?source=&target=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/folder/user/assign" {:query-params {:source ""
                                                                                    :target ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/user/assign?source=&target="

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/folder/user/assign?source=&target="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/folder/user/assign?source=&target=");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/user/assign?source=&target="

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/folder/user/assign?source=&target= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/folder/user/assign?source=&target=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/user/assign?source=&target="))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/user/assign?source=&target=")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/folder/user/assign?source=&target=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/folder/user/assign?source=&target=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/folder/user/assign',
  params: {source: '', target: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/folder/user/assign?source=&target=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/user/assign?source=&target=',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/user/assign?source=&target=")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/user/assign?source=&target=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/folder/user/assign',
  qs: {source: '', target: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/folder/user/assign');

req.query({
  source: '',
  target: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/folder/user/assign',
  params: {source: '', target: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/folder/user/assign?source=&target=';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/user/assign?source=&target="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/folder/user/assign?source=&target=" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/folder/user/assign?source=&target=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/folder/user/assign?source=&target=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/user/assign');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'source' => '',
  'target' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/folder/user/assign');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'source' => '',
  'target' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/user/assign?source=&target=' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/user/assign?source=&target=' -Method DELETE

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/api/folder/user/assign?source=&target=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/folder/user/assign"

querystring = {"source":"","target":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/user/assign"

queryString <- list(
  source = "",
  target = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/user/assign?source=&target=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/folder/user/assign') do |req|
  req.params['source'] = ''
  req.params['target'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/folder/user/assign";

    let querystring = [
        ("source", ""),
        ("target", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url '{{baseUrl}}/api/folder/user/assign?source=&target='

http DELETE '{{baseUrl}}/api/folder/user/assign?source=&target='

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/api/folder/user/assign?source=&target='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/user/assign?source=&target=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all (last) values of a device

{{baseUrl}}/api/Values/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/Values/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/Values/:id")

require "http/client"

url = "{{baseUrl}}/api/Values/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/Values/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/Values/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/Values/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/Values/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/Values/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/Values/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/Values/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/Values/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/Values/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/Values/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/Values/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/Values/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/Values/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/Values/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/Values/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/Values/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/Values/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/Values/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/Values/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/Values/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/Values/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/Values/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/Values/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/Values/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/Values/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/Values/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/Values/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/Values/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/Values/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/Values/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/Values/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/Values/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/Values/:id

http GET {{baseUrl}}/api/Values/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/Values/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/Values/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all (last) values of a device The first Value found before the given Date is returned.

{{baseUrl}}/api/ValuesInPast/:id

QUERY PARAMS

date

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/ValuesInPast/:id?date=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/ValuesInPast/:id" {:query-params {:date ""}})

require "http/client"

url = "{{baseUrl}}/api/ValuesInPast/:id?date="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/ValuesInPast/:id?date="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/ValuesInPast/:id?date=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/ValuesInPast/:id?date="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/ValuesInPast/:id?date= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/ValuesInPast/:id?date=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/ValuesInPast/:id?date="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/ValuesInPast/:id?date=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/ValuesInPast/:id?date=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/ValuesInPast/:id?date=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPast/:id',
  params: {date: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/ValuesInPast/:id?date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/ValuesInPast/:id?date=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/ValuesInPast/:id?date=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/ValuesInPast/:id?date=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPast/:id',
  qs: {date: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/ValuesInPast/:id');

req.query({
  date: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPast/:id',
  params: {date: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/ValuesInPast/:id?date=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/ValuesInPast/:id?date="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/ValuesInPast/:id?date=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/ValuesInPast/:id?date=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/ValuesInPast/:id?date=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/ValuesInPast/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'date' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/ValuesInPast/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'date' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/ValuesInPast/:id?date=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/ValuesInPast/:id?date=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/ValuesInPast/:id?date=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/ValuesInPast/:id"

querystring = {"date":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/ValuesInPast/:id"

queryString <- list(date = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/ValuesInPast/:id?date=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/ValuesInPast/:id') do |req|
  req.params['date'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/ValuesInPast/:id";

    let querystring = [
        ("date", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/ValuesInPast/:id?date='

http GET '{{baseUrl}}/api/ValuesInPast/:id?date='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/ValuesInPast/:id?date='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/ValuesInPast/:id?date=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets multiple values of a device. This call needs a smart-me professional licence.

{{baseUrl}}/api/ValuesInPastMultiple/:id

QUERY PARAMS

startDate

endDate

interval

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/ValuesInPastMultiple/:id" {:query-params {:startDate ""
                                                                                       :endDate ""
                                                                                       :interval ""}})

require "http/client"

url = "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPastMultiple/:id',
  params: {startDate: '', endDate: '', interval: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPastMultiple/:id',
  qs: {startDate: '', endDate: '', interval: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/ValuesInPastMultiple/:id');

req.query({
  startDate: '',
  endDate: '',
  interval: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/ValuesInPastMultiple/:id',
  params: {startDate: '', endDate: '', interval: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/ValuesInPastMultiple/:id');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'startDate' => '',
  'endDate' => '',
  'interval' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/ValuesInPastMultiple/:id');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'startDate' => '',
  'endDate' => '',
  'interval' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/ValuesInPastMultiple/:id"

querystring = {"startDate":"","endDate":"","interval":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/ValuesInPastMultiple/:id"

queryString <- list(
  startDate = "",
  endDate = "",
  interval = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/ValuesInPastMultiple/:id') do |req|
  req.params['startDate'] = ''
  req.params['endDate'] = ''
  req.params['interval'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/ValuesInPastMultiple/:id";

    let querystring = [
        ("startDate", ""),
        ("endDate", ""),
        ("interval", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval='

http GET '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/ValuesInPastMultiple/:id?startDate=&endDate=&interval=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Beta- Gets all active virtual meters

{{baseUrl}}/api/VirtualBillingMeterActive

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualBillingMeterActive");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualBillingMeterActive")

require "http/client"

url = "{{baseUrl}}/api/VirtualBillingMeterActive"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualBillingMeterActive"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualBillingMeterActive");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualBillingMeterActive"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualBillingMeterActive HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualBillingMeterActive")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualBillingMeterActive"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterActive")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualBillingMeterActive")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualBillingMeterActive');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualBillingMeterActive';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualBillingMeterActive',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterActive")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualBillingMeterActive',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualBillingMeterActive');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualBillingMeterActive';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualBillingMeterActive"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualBillingMeterActive" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualBillingMeterActive",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualBillingMeterActive');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualBillingMeterActive');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualBillingMeterActive');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualBillingMeterActive' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualBillingMeterActive' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualBillingMeterActive")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualBillingMeterActive"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualBillingMeterActive"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualBillingMeterActive")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualBillingMeterActive') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualBillingMeterActive";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualBillingMeterActive

http GET {{baseUrl}}/api/VirtualBillingMeterActive

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualBillingMeterActive

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualBillingMeterActive")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Beta- Virtual Meter API- Activates a Meter and add the Consumption to a Virtual Meter assosiated with the User.

{{baseUrl}}/api/VirtualBillingMeterActive

BODY json

{
  "SerialNumber": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualBillingMeterActive");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"SerialNumber\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/VirtualBillingMeterActive" {:content-type :json
                                                                          :form-params {:SerialNumber ""}})

require "http/client"

url = "{{baseUrl}}/api/VirtualBillingMeterActive"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SerialNumber\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualBillingMeterActive"),
    Content = new StringContent("{\n  \"SerialNumber\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualBillingMeterActive");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SerialNumber\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualBillingMeterActive"

	payload := strings.NewReader("{\n  \"SerialNumber\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/VirtualBillingMeterActive HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "SerialNumber": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/VirtualBillingMeterActive")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SerialNumber\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualBillingMeterActive"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SerialNumber\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"SerialNumber\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterActive")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/VirtualBillingMeterActive")
  .header("content-type", "application/json")
  .body("{\n  \"SerialNumber\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SerialNumber: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/VirtualBillingMeterActive');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive',
  headers: {'content-type': 'application/json'},
  data: {SerialNumber: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualBillingMeterActive';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SerialNumber":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualBillingMeterActive',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SerialNumber": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SerialNumber\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterActive")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualBillingMeterActive',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({SerialNumber: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive',
  headers: {'content-type': 'application/json'},
  body: {SerialNumber: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/VirtualBillingMeterActive');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  SerialNumber: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterActive',
  headers: {'content-type': 'application/json'},
  data: {SerialNumber: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualBillingMeterActive';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SerialNumber":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"SerialNumber": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualBillingMeterActive"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualBillingMeterActive" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SerialNumber\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualBillingMeterActive",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'SerialNumber' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/VirtualBillingMeterActive', [
  'body' => '{
  "SerialNumber": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualBillingMeterActive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SerialNumber' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'SerialNumber' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/VirtualBillingMeterActive');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualBillingMeterActive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SerialNumber": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualBillingMeterActive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SerialNumber": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"SerialNumber\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/VirtualBillingMeterActive", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualBillingMeterActive"

payload = { "SerialNumber": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualBillingMeterActive"

payload <- "{\n  \"SerialNumber\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualBillingMeterActive")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"SerialNumber\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/VirtualBillingMeterActive') do |req|
  req.body = "{\n  \"SerialNumber\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualBillingMeterActive";

    let payload = json!({"SerialNumber": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/VirtualBillingMeterActive \
  --header 'content-type: application/json' \
  --data '{
  "SerialNumber": ""
}'

echo '{
  "SerialNumber": ""
}' |  \
  http POST {{baseUrl}}/api/VirtualBillingMeterActive \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SerialNumber": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/VirtualBillingMeterActive

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["SerialNumber": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualBillingMeterActive")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Beta- Virtual Meter API- Deactivates a Virtual Meter.

{{baseUrl}}/api/VirtualBillingMeterDeactivate

BODY json

{
  "ID": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualBillingMeterDeactivate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ID\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/VirtualBillingMeterDeactivate" {:content-type :json
                                                                              :form-params {:ID ""}})

require "http/client"

url = "{{baseUrl}}/api/VirtualBillingMeterDeactivate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ID\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualBillingMeterDeactivate"),
    Content = new StringContent("{\n  \"ID\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualBillingMeterDeactivate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ID\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualBillingMeterDeactivate"

	payload := strings.NewReader("{\n  \"ID\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/VirtualBillingMeterDeactivate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 14

{
  "ID": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/VirtualBillingMeterDeactivate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ID\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualBillingMeterDeactivate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ID\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ID\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterDeactivate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/VirtualBillingMeterDeactivate")
  .header("content-type", "application/json")
  .body("{\n  \"ID\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ID: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/VirtualBillingMeterDeactivate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterDeactivate',
  headers: {'content-type': 'application/json'},
  data: {ID: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualBillingMeterDeactivate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ID":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualBillingMeterDeactivate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ID": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ID\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeterDeactivate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualBillingMeterDeactivate',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({ID: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterDeactivate',
  headers: {'content-type': 'application/json'},
  body: {ID: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/VirtualBillingMeterDeactivate');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ID: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/VirtualBillingMeterDeactivate',
  headers: {'content-type': 'application/json'},
  data: {ID: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualBillingMeterDeactivate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ID":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ID": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualBillingMeterDeactivate"]
                                                       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) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualBillingMeterDeactivate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ID\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualBillingMeterDeactivate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ID' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/VirtualBillingMeterDeactivate', [
  'body' => '{
  "ID": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualBillingMeterDeactivate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ID' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ID' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/VirtualBillingMeterDeactivate');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualBillingMeterDeactivate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ID": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualBillingMeterDeactivate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ID": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ID\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/VirtualBillingMeterDeactivate", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualBillingMeterDeactivate"

payload = { "ID": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualBillingMeterDeactivate"

payload <- "{\n  \"ID\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualBillingMeterDeactivate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ID\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/VirtualBillingMeterDeactivate') do |req|
  req.body = "{\n  \"ID\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualBillingMeterDeactivate";

    let payload = json!({"ID": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/VirtualBillingMeterDeactivate \
  --header 'content-type: application/json' \
  --data '{
  "ID": ""
}'

echo '{
  "ID": ""
}' |  \
  http POST {{baseUrl}}/api/VirtualBillingMeterDeactivate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ID": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/VirtualBillingMeterDeactivate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ID": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualBillingMeterDeactivate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Beta- Gets all Meters available to activate as a Virtual Meter.

{{baseUrl}}/api/VirtualBillingMeters

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualBillingMeters");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualBillingMeters")

require "http/client"

url = "{{baseUrl}}/api/VirtualBillingMeters"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualBillingMeters"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualBillingMeters");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualBillingMeters"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualBillingMeters HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualBillingMeters")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualBillingMeters"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeters")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualBillingMeters")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualBillingMeters');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualBillingMeters'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualBillingMeters';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualBillingMeters',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualBillingMeters")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualBillingMeters',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualBillingMeters'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualBillingMeters');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualBillingMeters'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualBillingMeters';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualBillingMeters"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualBillingMeters" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualBillingMeters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualBillingMeters');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualBillingMeters');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualBillingMeters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualBillingMeters' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualBillingMeters' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualBillingMeters")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualBillingMeters"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualBillingMeters"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualBillingMeters")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualBillingMeters') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualBillingMeters";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualBillingMeters

http GET {{baseUrl}}/api/VirtualBillingMeters

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualBillingMeters

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualBillingMeters")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Calculates a virtual meter from a formula. A meter is coded as ID(-METERID-)

{{baseUrl}}/api/VirtualMeterCalculateFormula

QUERY PARAMS

formula

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualMeterCalculateFormula" {:query-params {:formula ""}})

require "http/client"

url = "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualMeterCalculateFormula?formula= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualMeterCalculateFormula',
  params: {formula: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualMeterCalculateFormula?formula=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualMeterCalculateFormula',
  qs: {formula: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualMeterCalculateFormula');

req.query({
  formula: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualMeterCalculateFormula',
  params: {formula: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualMeterCalculateFormula?formula="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualMeterCalculateFormula');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'formula' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualMeterCalculateFormula');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'formula' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualMeterCalculateFormula?formula=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualMeterCalculateFormula"

querystring = {"formula":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualMeterCalculateFormula"

queryString <- list(formula = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualMeterCalculateFormula') do |req|
  req.params['formula'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualMeterCalculateFormula";

    let querystring = [
        ("formula", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula='

http GET '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/VirtualMeterCalculateFormula?formula='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualMeterCalculateFormula?formula=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Virtual Tariffs of a user

{{baseUrl}}/api/VirtualTariff

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualTariff");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualTariff")

require "http/client"

url = "{{baseUrl}}/api/VirtualTariff"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualTariff"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualTariff");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualTariff"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualTariff HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualTariff")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualTariff"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariff")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualTariff")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualTariff');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualTariff';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualTariff',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariff")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualTariff',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualTariff');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualTariff';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualTariff"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualTariff" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualTariff",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualTariff');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualTariff');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualTariff');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualTariff' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualTariff' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualTariff")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualTariff"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualTariff"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualTariff")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualTariff') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualTariff";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualTariff

http GET {{baseUrl}}/api/VirtualTariff

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualTariff

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualTariff")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all virtual tariffs of a folder

{{baseUrl}}/api/VirtualTariff/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualTariff/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualTariff/:id")

require "http/client"

url = "{{baseUrl}}/api/VirtualTariff/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualTariff/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualTariff/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualTariff/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualTariff/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualTariff/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualTariff/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariff/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualTariff/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualTariff/:id');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualTariff/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualTariff/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariff/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualTariff/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff/:id'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualTariff/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/api/VirtualTariff/:id'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualTariff/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualTariff/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualTariff/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualTariff/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualTariff/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualTariff/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualTariff/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualTariff/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualTariff/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualTariff/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualTariff/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualTariff/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualTariff/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualTariff/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualTariff/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualTariff/:id

http GET {{baseUrl}}/api/VirtualTariff/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualTariff/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualTariff/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the consumption of a folder with a virtuall tariffs.

{{baseUrl}}/api/VirtualTariffConsumption

QUERY PARAMS

folderId

startDate

endDate

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualTariffConsumption" {:query-params {:folderId ""
                                                                                       :startDate ""
                                                                                       :endDate ""}})

require "http/client"

url = "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate="

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate="

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualTariffConsumption?folderId=&startDate=&endDate= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate="))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffConsumption',
  params: {folderId: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualTariffConsumption?folderId=&startDate=&endDate=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffConsumption',
  qs: {folderId: '', startDate: '', endDate: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualTariffConsumption');

req.query({
  folderId: '',
  startDate: '',
  endDate: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffConsumption',
  params: {folderId: '', startDate: '', endDate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualTariffConsumption');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'folderId' => '',
  'startDate' => '',
  'endDate' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualTariffConsumption');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'folderId' => '',
  'startDate' => '',
  'endDate' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualTariffConsumption"

querystring = {"folderId":"","startDate":"","endDate":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualTariffConsumption"

queryString <- list(
  folderId = "",
  startDate = "",
  endDate = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualTariffConsumption') do |req|
  req.params['folderId'] = ''
  req.params['startDate'] = ''
  req.params['endDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualTariffConsumption";

    let querystring = [
        ("folderId", ""),
        ("startDate", ""),
        ("endDate", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate='

http GET '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualTariffConsumption?folderId=&startDate=&endDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets all Virtual Tariffs for a property (folder)

{{baseUrl}}/api/VirtualTariffsForProperty/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualTariffsForProperty/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualTariffsForProperty/:id")

require "http/client"

url = "{{baseUrl}}/api/VirtualTariffsForProperty/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualTariffsForProperty/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualTariffsForProperty/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualTariffsForProperty/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualTariffsForProperty/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualTariffsForProperty/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualTariffsForProperty/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffsForProperty/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualTariffsForProperty/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualTariffsForProperty/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsForProperty/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualTariffsForProperty/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualTariffsForProperty/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffsForProperty/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualTariffsForProperty/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsForProperty/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualTariffsForProperty/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsForProperty/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualTariffsForProperty/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualTariffsForProperty/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualTariffsForProperty/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualTariffsForProperty/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualTariffsForProperty/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualTariffsForProperty/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualTariffsForProperty/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualTariffsForProperty/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualTariffsForProperty/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualTariffsForProperty/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualTariffsForProperty/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualTariffsForProperty/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualTariffsForProperty/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualTariffsForProperty/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualTariffsForProperty/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualTariffsForProperty/:id

http GET {{baseUrl}}/api/VirtualTariffsForProperty/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualTariffsForProperty/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualTariffsForProperty/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Gets the calculation status for a virtual tariff property

{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id

QUERY PARAMS

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")

require "http/client"

url = "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/VirtualTariffsStatusForProperty/:id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/VirtualTariffsStatusForProperty/:id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id');

echo $response->getBody();

setUrl('{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/VirtualTariffsStatusForProperty/:id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/VirtualTariffsStatusForProperty/:id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/VirtualTariffsStatusForProperty/:id

http GET {{baseUrl}}/api/VirtualTariffsStatusForProperty/:id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/VirtualTariffsStatusForProperty/:id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/VirtualTariffsStatusForProperty/:id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()