FileRise API

GET Get UI configuration

{{baseUrl}}/api/admin/getConfig.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/admin/getConfig.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/admin/getConfig.php")

require "http/client"

url = "{{baseUrl}}/api/admin/getConfig.php"

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/admin/getConfig.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/admin/getConfig.php"

	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/admin/getConfig.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/admin/getConfig.php"))
    .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/admin/getConfig.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/admin/getConfig.php")
  .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/admin/getConfig.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/admin/getConfig.php'};

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

const url = '{{baseUrl}}/api/admin/getConfig.php';
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/admin/getConfig.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/admin/getConfig.php',
  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/admin/getConfig.php'};

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/admin/getConfig.php');

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/admin/getConfig.php'};

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

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

const url = '{{baseUrl}}/api/admin/getConfig.php';
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/admin/getConfig.php"]
                                                       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/admin/getConfig.php" in

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

 "{{baseUrl}}/api/admin/getConfig.php",
  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/admin/getConfig.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/admin/getConfig.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/admin/getConfig.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/admin/getConfig.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/admin/getConfig.php")

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

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

import requests

url = "{{baseUrl}}/api/admin/getConfig.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/admin/getConfig.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/admin/getConfig.php")

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/admin/getConfig.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/admin/getConfig.php

http GET {{baseUrl}}/api/admin/getConfig.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/admin/getConfig.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/admin/getConfig.php")! 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 per-folder grants for a user (admin-only)

{{baseUrl}}/api/admin/acl/getGrants.php

HEADERS

PHPSESSID

QUERY PARAMS

user

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/admin/acl/getGrants.php?user=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/admin/acl/getGrants.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                       :query-params {:user ""}})

require "http/client"

url = "{{baseUrl}}/api/admin/acl/getGrants.php?user="
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/admin/acl/getGrants.php?user=");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/admin/acl/getGrants.php?user="

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

	req.Header.Add("phpsessid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/admin/acl/getGrants.php?user= HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/admin/acl/getGrants.php?user=")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/admin/acl/getGrants.php?user="))
    .header("phpsessid", "{{apiKey}}")
    .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/admin/acl/getGrants.php?user=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/admin/acl/getGrants.php?user=")
  .header("phpsessid", "{{apiKey}}")
  .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/admin/acl/getGrants.php?user=');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/admin/acl/getGrants.php',
  params: {user: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/admin/acl/getGrants.php?user=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/admin/acl/getGrants.php?user=',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/admin/acl/getGrants.php?user=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/admin/acl/getGrants.php?user=',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/admin/acl/getGrants.php',
  qs: {user: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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/admin/acl/getGrants.php');

req.query({
  user: ''
});

req.headers({
  phpsessid: '{{apiKey}}'
});

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/admin/acl/getGrants.php',
  params: {user: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/admin/acl/getGrants.php?user=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/admin/acl/getGrants.php?user="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/admin/acl/getGrants.php?user=" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/admin/acl/getGrants.php?user=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/admin/acl/getGrants.php?user=', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/admin/acl/getGrants.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'user' => ''
]);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/admin/acl/getGrants.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'user' => ''
]));

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/admin/acl/getGrants.php?user=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/admin/acl/getGrants.php?user=' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/admin/acl/getGrants.php?user=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/admin/acl/getGrants.php"

querystring = {"user":""}

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/admin/acl/getGrants.php"

queryString <- list(user = "")

response <- VERB("GET", url, query = queryString, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/admin/acl/getGrants.php?user=")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/admin/acl/getGrants.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.params['user'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/admin/acl/getGrants.php";

    let querystring = [
        ("user", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/admin/acl/getGrants.php?user=' \
  --header 'phpsessid: {{apiKey}}'

http GET '{{baseUrl}}/api/admin/acl/getGrants.php?user=' \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/admin/acl/getGrants.php?user='

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/admin/acl/getGrants.php?user=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "grants": {
    "root": {
      "view": true,
      "viewOwn": false,
      "upload": true,
      "manage": false,
      "share": true
    },
    "projects/acme": {
      "view": true,
      "viewOwn": false,
      "upload": true,
      "manage": true,
      "share": true
    },
    "teams/ops": {
      "view": false,
      "viewOwn": true,
      "upload": true,
      "manage": false,
      "share": false
    }
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/admin/readMetadata.php?file=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/admin/readMetadata.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                      :query-params {:file ""}})

require "http/client"

url = "{{baseUrl}}/api/admin/readMetadata.php?file="
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/admin/readMetadata.php?file=");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/admin/readMetadata.php?file="

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

	req.Header.Add("phpsessid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/admin/readMetadata.php?file= HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/admin/readMetadata.php?file=")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/admin/readMetadata.php?file="))
    .header("phpsessid", "{{apiKey}}")
    .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/admin/readMetadata.php?file=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/admin/readMetadata.php?file=")
  .header("phpsessid", "{{apiKey}}")
  .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/admin/readMetadata.php?file=');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/admin/readMetadata.php',
  params: {file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/admin/readMetadata.php?file=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/admin/readMetadata.php?file=',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/admin/readMetadata.php?file=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/admin/readMetadata.php?file=',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/admin/readMetadata.php',
  qs: {file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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/admin/readMetadata.php');

req.query({
  file: ''
});

req.headers({
  phpsessid: '{{apiKey}}'
});

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/admin/readMetadata.php',
  params: {file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/admin/readMetadata.php?file=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/admin/readMetadata.php?file="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/admin/readMetadata.php?file=" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/admin/readMetadata.php?file=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/admin/readMetadata.php?file=', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/admin/readMetadata.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'file' => ''
]);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/admin/readMetadata.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'file' => ''
]));

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/admin/readMetadata.php?file=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/admin/readMetadata.php?file=' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/admin/readMetadata.php?file=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/admin/readMetadata.php"

querystring = {"file":""}

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/admin/readMetadata.php"

queryString <- list(file = "")

response <- VERB("GET", url, query = queryString, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/admin/readMetadata.php?file=")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/admin/readMetadata.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.params['file'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("file", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/admin/readMetadata.php?file=' \
  --header 'phpsessid: {{apiKey}}'

http GET '{{baseUrl}}/api/admin/readMetadata.php?file=' \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/admin/readMetadata.php?file='

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/admin/readMetadata.php?file=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Save per-folder grants for one or many users (admin-only)

{{baseUrl}}/api/admin/acl/saveGrants.php

HEADERS

X-CSRF-Token

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/admin/acl/saveGrants.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/admin/acl/saveGrants.php" {:headers {:x-csrf-token ""
                                                                                   :phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/admin/acl/saveGrants.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
}

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/admin/acl/saveGrants.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/admin/acl/saveGrants.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/admin/acl/saveGrants.php"

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")

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

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

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

}

POST /baseUrl/api/admin/acl/saveGrants.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/admin/acl/saveGrants.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/admin/acl/saveGrants.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .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/admin/acl/saveGrants.php")
  .post(null)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/admin/acl/saveGrants.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .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/admin/acl/saveGrants.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/admin/acl/saveGrants.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/admin/acl/saveGrants.php';
const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};

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/admin/acl/saveGrants.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/admin/acl/saveGrants.php")
  .post(null)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/admin/acl/saveGrants.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}'
  }
};

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/admin/acl/saveGrants.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

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/admin/acl/saveGrants.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}'
});

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/admin/acl/saveGrants.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/admin/acl/saveGrants.php';
const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/admin/acl/saveGrants.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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/admin/acl/saveGrants.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
] in

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

 "{{baseUrl}}/api/admin/acl/saveGrants.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/admin/acl/saveGrants.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/admin/acl/saveGrants.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/admin/acl/saveGrants.php');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/admin/acl/saveGrants.php' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/admin/acl/saveGrants.php' -Method POST -Headers $headers

import http.client

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

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}"
}

conn.request("POST", "/baseUrl/api/admin/acl/saveGrants.php", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/admin/acl/saveGrants.php"

headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/admin/acl/saveGrants.php"

response <- VERB("POST", url, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/admin/acl/saveGrants.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.post('/baseUrl/api/admin/acl/saveGrants.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/admin/acl/saveGrants.php";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/admin/acl/saveGrants.php \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: '

http POST {{baseUrl}}/api/admin/acl/saveGrants.php \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/admin/acl/saveGrants.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/admin/acl/saveGrants.php")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Authenticate user

{{baseUrl}}/api/auth/auth.php

BODY json

{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auth/auth.php");

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  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/auth/auth.php" {:content-type :json
                                                              :form-params {:username ""
                                                                            :password ""
                                                                            :remember_me false
                                                                            :totp_code ""}})

require "http/client"

url = "{{baseUrl}}/api/auth/auth.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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/auth/auth.php"),
    Content = new StringContent("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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/auth/auth.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/auth/auth.php"

	payload := strings.NewReader("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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/auth/auth.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 81

{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/auth/auth.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auth/auth.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/auth/auth.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/auth/auth.php")
  .header("content-type", "application/json")
  .body("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  username: '',
  password: '',
  remember_me: false,
  totp_code: ''
});

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/auth/auth.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/auth/auth.php',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: '', remember_me: false, totp_code: ''}
};

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

const url = '{{baseUrl}}/api/auth/auth.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":"","remember_me":false,"totp_code":""}'
};

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/auth/auth.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "username": "",\n  "password": "",\n  "remember_me": false,\n  "totp_code": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/auth/auth.php")
  .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/auth/auth.php',
  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({username: '', password: '', remember_me: false, totp_code: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/auth/auth.php',
  headers: {'content-type': 'application/json'},
  body: {username: '', password: '', remember_me: false, totp_code: ''},
  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/auth/auth.php');

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

req.type('json');
req.send({
  username: '',
  password: '',
  remember_me: false,
  totp_code: ''
});

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/auth/auth.php',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: '', remember_me: false, totp_code: ''}
};

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

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

const url = '{{baseUrl}}/api/auth/auth.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":"","remember_me":false,"totp_code":""}'
};

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 = @{ @"username": @"",
                              @"password": @"",
                              @"remember_me": @NO,
                              @"totp_code": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/auth/auth.php"]
                                                       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/auth/auth.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}" in

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

 "{{baseUrl}}/api/auth/auth.php",
  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([
    'username' => '',
    'password' => '',
    'remember_me' => null,
    'totp_code' => ''
  ]),
  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/auth/auth.php', [
  'body' => '{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'username' => '',
  'password' => '',
  'remember_me' => null,
  'totp_code' => ''
]));

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

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

append(json_encode([
  'username' => '',
  'password' => '',
  'remember_me' => null,
  'totp_code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/auth/auth.php');
$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/auth/auth.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auth/auth.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}'

import http.client

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

payload = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/api/auth/auth.php"

payload = {
    "username": "",
    "password": "",
    "remember_me": False,
    "totp_code": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auth/auth.php"

payload <- "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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/auth/auth.php")

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  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\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/auth/auth.php') do |req|
  req.body = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"remember_me\": false,\n  \"totp_code\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "username": "",
        "password": "",
        "remember_me": false,
        "totp_code": ""
    });

    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/auth/auth.php \
  --header 'content-type: application/json' \
  --data '{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}'

echo '{
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
}' |  \
  http POST {{baseUrl}}/api/auth/auth.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "username": "",\n  "password": "",\n  "remember_me": false,\n  "totp_code": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/auth/auth.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "username": "",
  "password": "",
  "remember_me": false,
  "totp_code": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auth/auth.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "status": "ok",
  "success": "Login successful",
  "username": "johndoe",
  "isAdmin": true
}

GET Authenticate using HTTP Basic Authentication

{{baseUrl}}/api/auth/login_basic.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auth/login_basic.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/auth/login_basic.php")

require "http/client"

url = "{{baseUrl}}/api/auth/login_basic.php"

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/auth/login_basic.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auth/login_basic.php"

	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/auth/login_basic.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auth/login_basic.php"))
    .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/auth/login_basic.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/auth/login_basic.php")
  .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/auth/login_basic.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/auth/login_basic.php'};

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

const url = '{{baseUrl}}/api/auth/login_basic.php';
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/auth/login_basic.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/auth/login_basic.php',
  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/auth/login_basic.php'};

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/auth/login_basic.php');

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/auth/login_basic.php'};

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

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

const url = '{{baseUrl}}/api/auth/login_basic.php';
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/auth/login_basic.php"]
                                                       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/auth/login_basic.php" in

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

 "{{baseUrl}}/api/auth/login_basic.php",
  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/auth/login_basic.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auth/login_basic.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auth/login_basic.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auth/login_basic.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/auth/login_basic.php")

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

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

import requests

url = "{{baseUrl}}/api/auth/login_basic.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auth/login_basic.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auth/login_basic.php")

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/auth/login_basic.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/auth/login_basic.php

http GET {{baseUrl}}/api/auth/login_basic.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/auth/login_basic.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auth/login_basic.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "Login successful"
}

GET Check authentication status

{{baseUrl}}/api/auth/checkAuth.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auth/checkAuth.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/auth/checkAuth.php")

require "http/client"

url = "{{baseUrl}}/api/auth/checkAuth.php"

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/auth/checkAuth.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auth/checkAuth.php"

	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/auth/checkAuth.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auth/checkAuth.php"))
    .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/auth/checkAuth.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/auth/checkAuth.php")
  .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/auth/checkAuth.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/auth/checkAuth.php'};

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

const url = '{{baseUrl}}/api/auth/checkAuth.php';
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/auth/checkAuth.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/auth/checkAuth.php',
  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/auth/checkAuth.php'};

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/auth/checkAuth.php');

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/auth/checkAuth.php'};

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

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

const url = '{{baseUrl}}/api/auth/checkAuth.php';
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/auth/checkAuth.php"]
                                                       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/auth/checkAuth.php" in

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

 "{{baseUrl}}/api/auth/checkAuth.php",
  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/auth/checkAuth.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auth/checkAuth.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auth/checkAuth.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auth/checkAuth.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/auth/checkAuth.php")

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

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

import requests

url = "{{baseUrl}}/api/auth/checkAuth.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auth/checkAuth.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auth/checkAuth.php")

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/auth/checkAuth.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/auth/checkAuth.php

http GET {{baseUrl}}/api/auth/checkAuth.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/auth/checkAuth.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auth/checkAuth.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "authenticated": true,
  "isAdmin": true,
  "totp_enabled": false,
  "username": "johndoe",
  "folderOnly": false
}

POST Logout user

{{baseUrl}}/api/auth/logout.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auth/logout.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/auth/logout.php")

require "http/client"

url = "{{baseUrl}}/api/auth/logout.php"

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/auth/logout.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auth/logout.php"

	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/auth/logout.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auth/logout.php"))
    .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/auth/logout.php")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/auth/logout.php")
  .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/auth/logout.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/auth/logout.php'};

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

const url = '{{baseUrl}}/api/auth/logout.php';
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/auth/logout.php',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/auth/logout.php")
  .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/auth/logout.php',
  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/auth/logout.php'};

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/auth/logout.php');

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/auth/logout.php'};

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

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

const url = '{{baseUrl}}/api/auth/logout.php';
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/auth/logout.php"]
                                                       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/auth/logout.php" in

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

 "{{baseUrl}}/api/auth/logout.php",
  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/auth/logout.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auth/logout.php');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/api/auth/logout.php');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auth/logout.php' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auth/logout.php' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/api/auth/logout.php")

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

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

import requests

url = "{{baseUrl}}/api/auth/logout.php"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auth/logout.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auth/logout.php")

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/auth/logout.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/auth/logout.php

http POST {{baseUrl}}/api/auth/logout.php

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/auth/logout.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auth/logout.php")! 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()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/auth/token.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/auth/token.php")

require "http/client"

url = "{{baseUrl}}/api/auth/token.php"

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/auth/token.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/auth/token.php"

	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/auth/token.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/auth/token.php"))
    .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/auth/token.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/auth/token.php")
  .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/auth/token.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/auth/token.php'};

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

const url = '{{baseUrl}}/api/auth/token.php';
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/auth/token.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/auth/token.php',
  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/auth/token.php'};

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/auth/token.php');

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/auth/token.php'};

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

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

const url = '{{baseUrl}}/api/auth/token.php';
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/auth/token.php"]
                                                       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/auth/token.php" in

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

 "{{baseUrl}}/api/auth/token.php",
  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/auth/token.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/auth/token.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/auth/token.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/auth/token.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/auth/token.php")

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

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

import requests

url = "{{baseUrl}}/api/auth/token.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/auth/token.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/auth/token.php")

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/auth/token.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/auth/token.php

http GET {{baseUrl}}/api/auth/token.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/auth/token.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/auth/token.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "csrf_token": "0123456789abcdef...",
  "share_url": "https://yourdomain.com/share.php"
}

POST Copy files between folders

{{baseUrl}}/api/file/copyFiles.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "source": "",
  "destination": "",
  "files": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/copyFiles.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/copyFiles.php" {:headers {:x-csrf-token ""
                                                                             :phpsessid "{{apiKey}}"}
                                                                   :content-type :json
                                                                   :form-params {:source "root"
                                                                                 :destination "userA/projects"
                                                                                 :files ["report.pdf" "notes.txt"]}})

require "http/client"

url = "{{baseUrl}}/api/file/copyFiles.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\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/file/copyFiles.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\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/file/copyFiles.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/copyFiles.php"

	payload := strings.NewReader("{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/copyFiles.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/copyFiles.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/copyFiles.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\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  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/copyFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/copyFiles.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  source: 'root',
  destination: 'userA/projects',
  files: [
    'report.pdf',
    'notes.txt'
  ]
});

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/file/copyFiles.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/copyFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    source: 'root',
    destination: 'userA/projects',
    files: ['report.pdf', 'notes.txt']
  }
};

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

const url = '{{baseUrl}}/api/file/copyFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"source":"root","destination":"userA/projects","files":["report.pdf","notes.txt"]}'
};

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/file/copyFiles.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "source": "root",\n  "destination": "userA/projects",\n  "files": [\n    "report.pdf",\n    "notes.txt"\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  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/copyFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/copyFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({
  source: 'root',
  destination: 'userA/projects',
  files: ['report.pdf', 'notes.txt']
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/copyFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {
    source: 'root',
    destination: 'userA/projects',
    files: ['report.pdf', 'notes.txt']
  },
  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/file/copyFiles.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  source: 'root',
  destination: 'userA/projects',
  files: [
    'report.pdf',
    'notes.txt'
  ]
});

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/file/copyFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    source: 'root',
    destination: 'userA/projects',
    files: ['report.pdf', 'notes.txt']
  }
};

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

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

const url = '{{baseUrl}}/api/file/copyFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"source":"root","destination":"userA/projects","files":["report.pdf","notes.txt"]}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"source": @"root",
                              @"destination": @"userA/projects",
                              @"files": @[ @"report.pdf", @"notes.txt" ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/copyFiles.php"]
                                                       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/file/copyFiles.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}" in

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

 "{{baseUrl}}/api/file/copyFiles.php",
  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([
    'source' => 'root',
    'destination' => 'userA/projects',
    'files' => [
        'report.pdf',
        'notes.txt'
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/copyFiles.php', [
  'body' => '{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/copyFiles.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'source' => 'root',
  'destination' => 'userA/projects',
  'files' => [
    'report.pdf',
    'notes.txt'
  ]
]));

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

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

append(json_encode([
  'source' => 'root',
  'destination' => 'userA/projects',
  'files' => [
    'report.pdf',
    'notes.txt'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/file/copyFiles.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/copyFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/copyFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}'

import http.client

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

payload = "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/copyFiles.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/copyFiles.php"

payload = {
    "source": "root",
    "destination": "userA/projects",
    "files": ["report.pdf", "notes.txt"]
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/copyFiles.php"

payload <- "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/copyFiles.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\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/file/copyFiles.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"source\": \"root\",\n  \"destination\": \"userA/projects\",\n  \"files\": [\n    \"report.pdf\",\n    \"notes.txt\"\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/file/copyFiles.php";

    let payload = json!({
        "source": "root",
        "destination": "userA/projects",
        "files": ("report.pdf", "notes.txt")
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/copyFiles.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}'

echo '{
  "source": "root",
  "destination": "userA/projects",
  "files": [
    "report.pdf",
    "notes.txt"
  ]
}' |  \
  http POST {{baseUrl}}/api/file/copyFiles.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "source": "root",\n  "destination": "userA/projects",\n  "files": [\n    "report.pdf",\n    "notes.txt"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/file/copyFiles.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "source": "root",
  "destination": "userA/projects",
  "files": ["report.pdf", "notes.txt"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/copyFiles.php")! 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 Create an empty file

{{baseUrl}}/api/file/createFile.php

HEADERS

PHPSESSID

BODY json

{
  "folder": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/createFile.php");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/createFile.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                    :content-type :json
                                                                    :form-params {:folder "root"
                                                                                  :name "new.txt"}})

require "http/client"

url = "{{baseUrl}}/api/file/createFile.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\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/file/createFile.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\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/file/createFile.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/createFile.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}")

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

	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/createFile.php HTTP/1.1
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "folder": "root",
  "name": "new.txt"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/createFile.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/createFile.php"))
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\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  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/createFile.php")
  .post(body)
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/createFile.php")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  name: 'new.txt'
});

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/file/createFile.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/createFile.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {folder: 'root', name: 'new.txt'}
};

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

const url = '{{baseUrl}}/api/file/createFile.php';
const options = {
  method: 'POST',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"folder":"root","name":"new.txt"}'
};

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/file/createFile.php',
  method: 'POST',
  headers: {
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "name": "new.txt"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/createFile.php")
  .post(body)
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/createFile.php',
  headers: {
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', name: 'new.txt'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/createFile.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {folder: 'root', name: 'new.txt'},
  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/file/createFile.php');

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

req.type('json');
req.send({
  folder: 'root',
  name: 'new.txt'
});

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/file/createFile.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {folder: 'root', name: 'new.txt'}
};

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

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

const url = '{{baseUrl}}/api/file/createFile.php';
const options = {
  method: 'POST',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"folder":"root","name":"new.txt"}'
};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"name": @"new.txt" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/createFile.php"]
                                                       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/file/createFile.php" in
let headers = Header.add_list (Header.init ()) [
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}" in

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

 "{{baseUrl}}/api/file/createFile.php",
  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([
    'folder' => 'root',
    'name' => 'new.txt'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/createFile.php', [
  'body' => '{
  "folder": "root",
  "name": "new.txt"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/createFile.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'name' => 'new.txt'
]));

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

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

append(json_encode([
  'folder' => 'root',
  'name' => 'new.txt'
]));
$request->setRequestUrl('{{baseUrl}}/api/file/createFile.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/createFile.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "name": "new.txt"
}'

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/createFile.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "name": "new.txt"
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}"

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

conn.request("POST", "/baseUrl/api/file/createFile.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/createFile.php"

payload = {
    "folder": "root",
    "name": "new.txt"
}
headers = {
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/createFile.php"

payload <- "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/createFile.php")

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

request = Net::HTTP::Post.new(url)
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\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/file/createFile.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"name\": \"new.txt\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "folder": "root",
        "name": "new.txt"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/createFile.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --data '{
  "folder": "root",
  "name": "new.txt"
}'

echo '{
  "folder": "root",
  "name": "new.txt"
}' |  \
  http POST {{baseUrl}}/api/file/createFile.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "name": "new.txt"\n}' \
  --output-document \
  - {{baseUrl}}/api/file/createFile.php

import Foundation

let headers = [
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "name": "new.txt"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/createFile.php")! 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()

PUT Create or overwrite a file’s content

{{baseUrl}}/api/file/saveFile.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "fileName": "",
  "content": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/saveFile.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/file/saveFile.php" {:headers {:x-csrf-token ""
                                                                           :phpsessid "{{apiKey}}"}
                                                                 :content-type :json
                                                                 :form-params {:folder "root"
                                                                               :fileName "readme.txt"
                                                                               :content "Hello world"}})

require "http/client"

url = "{{baseUrl}}/api/file/saveFile.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\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/file/saveFile.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\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/file/saveFile.php");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/saveFile.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/saveFile.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/file/saveFile.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/saveFile.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\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  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/saveFile.php")
  .put(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/file/saveFile.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  fileName: 'readme.txt',
  content: 'Hello world'
});

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/file/saveFile.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/file/saveFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', fileName: 'readme.txt', content: 'Hello world'}
};

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

const url = '{{baseUrl}}/api/file/saveFile.php';
const options = {
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","fileName":"readme.txt","content":"Hello world"}'
};

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/file/saveFile.php',
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "fileName": "readme.txt",\n  "content": "Hello world"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/saveFile.php")
  .put(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/saveFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', fileName: 'readme.txt', content: 'Hello world'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/file/saveFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'root', fileName: 'readme.txt', content: 'Hello world'},
  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/file/saveFile.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  fileName: 'readme.txt',
  content: 'Hello world'
});

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/file/saveFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', fileName: 'readme.txt', content: 'Hello world'}
};

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

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

const url = '{{baseUrl}}/api/file/saveFile.php';
const options = {
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","fileName":"readme.txt","content":"Hello world"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"fileName": @"readme.txt",
                              @"content": @"Hello world" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/saveFile.php"]
                                                       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/file/saveFile.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}" in

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

 "{{baseUrl}}/api/file/saveFile.php",
  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([
    'folder' => 'root',
    'fileName' => 'readme.txt',
    'content' => 'Hello world'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/file/saveFile.php', [
  'body' => '{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/saveFile.php');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'fileName' => 'readme.txt',
  'content' => 'Hello world'
]));

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

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

append(json_encode([
  'folder' => 'root',
  'fileName' => 'readme.txt',
  'content' => 'Hello world'
]));
$request->setRequestUrl('{{baseUrl}}/api/file/saveFile.php');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/saveFile.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/saveFile.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/api/file/saveFile.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/saveFile.php"

payload = {
    "folder": "root",
    "fileName": "readme.txt",
    "content": "Hello world"
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/saveFile.php"

payload <- "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/saveFile.php")

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

request = Net::HTTP::Put.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\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/file/saveFile.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"fileName\": \"readme.txt\",\n  \"content\": \"Hello world\"\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/file/saveFile.php";

    let payload = json!({
        "folder": "root",
        "fileName": "readme.txt",
        "content": "Hello world"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/saveFile.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}'

echo '{
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
}' |  \
  http PUT {{baseUrl}}/api/file/saveFile.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method PUT \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "fileName": "readme.txt",\n  "content": "Hello world"\n}' \
  --output-document \
  - {{baseUrl}}/api/file/saveFile.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "fileName": "readme.txt",
  "content": "Hello world"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/saveFile.php")! 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()

POST Delete files to Trash

{{baseUrl}}/api/file/deleteFiles.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "files": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/deleteFiles.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/deleteFiles.php" {:headers {:x-csrf-token ""
                                                                               :phpsessid "{{apiKey}}"}
                                                                     :content-type :json
                                                                     :form-params {:folder "root"
                                                                                   :files ["old.docx" "draft.md"]}})

require "http/client"

url = "{{baseUrl}}/api/file/deleteFiles.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\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/file/deleteFiles.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\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/file/deleteFiles.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/deleteFiles.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/deleteFiles.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/deleteFiles.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/deleteFiles.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\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  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/deleteFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/deleteFiles.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  files: [
    'old.docx',
    'draft.md'
  ]
});

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/file/deleteFiles.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/deleteFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['old.docx', 'draft.md']}
};

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

const url = '{{baseUrl}}/api/file/deleteFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["old.docx","draft.md"]}'
};

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/file/deleteFiles.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "files": [\n    "old.docx",\n    "draft.md"\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  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/deleteFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/deleteFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', files: ['old.docx', 'draft.md']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/deleteFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'root', files: ['old.docx', 'draft.md']},
  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/file/deleteFiles.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  files: [
    'old.docx',
    'draft.md'
  ]
});

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/file/deleteFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['old.docx', 'draft.md']}
};

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

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

const url = '{{baseUrl}}/api/file/deleteFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["old.docx","draft.md"]}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"files": @[ @"old.docx", @"draft.md" ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/deleteFiles.php"]
                                                       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/file/deleteFiles.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}" in

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

 "{{baseUrl}}/api/file/deleteFiles.php",
  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([
    'folder' => 'root',
    'files' => [
        'old.docx',
        'draft.md'
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/deleteFiles.php', [
  'body' => '{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/deleteFiles.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'files' => [
    'old.docx',
    'draft.md'
  ]
]));

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

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

append(json_encode([
  'folder' => 'root',
  'files' => [
    'old.docx',
    'draft.md'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/file/deleteFiles.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/deleteFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/deleteFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/deleteFiles.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/deleteFiles.php"

payload = {
    "folder": "root",
    "files": ["old.docx", "draft.md"]
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/deleteFiles.php"

payload <- "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/deleteFiles.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\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/file/deleteFiles.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"old.docx\",\n    \"draft.md\"\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/file/deleteFiles.php";

    let payload = json!({
        "folder": "root",
        "files": ("old.docx", "draft.md")
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/deleteFiles.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}'

echo '{
  "folder": "root",
  "files": [
    "old.docx",
    "draft.md"
  ]
}' |  \
  http POST {{baseUrl}}/api/file/deleteFiles.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "files": [\n    "old.docx",\n    "draft.md"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/file/deleteFiles.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "files": ["old.docx", "draft.md"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/deleteFiles.php")! 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 Download a file

{{baseUrl}}/api/file/download.php

HEADERS

PHPSESSID

QUERY PARAMS

folder

file

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/download.php?folder=&file=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/file/download.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                 :query-params {:folder ""
                                                                                :file ""}})

require "http/client"

url = "{{baseUrl}}/api/file/download.php?folder=&file="
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/file/download.php?folder=&file=");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/download.php?folder=&file="

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

	req.Header.Add("phpsessid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/file/download.php?folder=&file= HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/file/download.php?folder=&file=")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/download.php?folder=&file="))
    .header("phpsessid", "{{apiKey}}")
    .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/file/download.php?folder=&file=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/download.php?folder=&file=")
  .header("phpsessid", "{{apiKey}}")
  .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/file/download.php?folder=&file=');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/file/download.php',
  params: {folder: '', file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/file/download.php?folder=&file=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/file/download.php?folder=&file=',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/file/download.php?folder=&file=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/download.php?folder=&file=',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/file/download.php',
  qs: {folder: '', file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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/file/download.php');

req.query({
  folder: '',
  file: ''
});

req.headers({
  phpsessid: '{{apiKey}}'
});

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/file/download.php',
  params: {folder: '', file: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/file/download.php?folder=&file=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/download.php?folder=&file="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/file/download.php?folder=&file=" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/file/download.php?folder=&file=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/file/download.php?folder=&file=', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/download.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'folder' => '',
  'file' => ''
]);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/file/download.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'folder' => '',
  'file' => ''
]));

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/download.php?folder=&file=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/download.php?folder=&file=' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/file/download.php?folder=&file=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/file/download.php"

querystring = {"folder":"","file":""}

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/download.php"

queryString <- list(
  folder = "",
  file = ""
)

response <- VERB("GET", url, query = queryString, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/download.php?folder=&file=")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/file/download.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.params['folder'] = ''
  req.params['file'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("folder", ""),
        ("file", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/file/download.php?folder=&file=' \
  --header 'phpsessid: {{apiKey}}'

http GET '{{baseUrl}}/api/file/download.php?folder=&file=' \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/file/download.php?folder=&file='

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/download.php?folder=&file=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Download multiple files as a ZIP

{{baseUrl}}/api/file/downloadZip.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "files": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/downloadZip.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/downloadZip.php" {:headers {:x-csrf-token ""
                                                                               :phpsessid "{{apiKey}}"}
                                                                     :content-type :json
                                                                     :form-params {:folder "root"
                                                                                   :files ["a.jpg" "b.png"]}})

require "http/client"

url = "{{baseUrl}}/api/file/downloadZip.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\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/file/downloadZip.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\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/file/downloadZip.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/downloadZip.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/downloadZip.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 65

{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/downloadZip.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/downloadZip.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\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  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/downloadZip.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/downloadZip.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  files: [
    'a.jpg',
    'b.png'
  ]
});

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/file/downloadZip.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/downloadZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['a.jpg', 'b.png']}
};

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

const url = '{{baseUrl}}/api/file/downloadZip.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["a.jpg","b.png"]}'
};

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/file/downloadZip.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "files": [\n    "a.jpg",\n    "b.png"\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  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/downloadZip.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/downloadZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', files: ['a.jpg', 'b.png']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/downloadZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'root', files: ['a.jpg', 'b.png']},
  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/file/downloadZip.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  files: [
    'a.jpg',
    'b.png'
  ]
});

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/file/downloadZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['a.jpg', 'b.png']}
};

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

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

const url = '{{baseUrl}}/api/file/downloadZip.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["a.jpg","b.png"]}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"files": @[ @"a.jpg", @"b.png" ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/downloadZip.php"]
                                                       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/file/downloadZip.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}" in

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

 "{{baseUrl}}/api/file/downloadZip.php",
  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([
    'folder' => 'root',
    'files' => [
        'a.jpg',
        'b.png'
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/downloadZip.php', [
  'body' => '{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/downloadZip.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'files' => [
    'a.jpg',
    'b.png'
  ]
]));

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

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

append(json_encode([
  'folder' => 'root',
  'files' => [
    'a.jpg',
    'b.png'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/file/downloadZip.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/downloadZip.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/downloadZip.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/downloadZip.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/downloadZip.php"

payload = {
    "folder": "root",
    "files": ["a.jpg", "b.png"]
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/downloadZip.php"

payload <- "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/downloadZip.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\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/file/downloadZip.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"a.jpg\",\n    \"b.png\"\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/file/downloadZip.php";

    let payload = json!({
        "folder": "root",
        "files": ("a.jpg", "b.png")
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/downloadZip.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}'

echo '{
  "folder": "root",
  "files": [
    "a.jpg",
    "b.png"
  ]
}' |  \
  http POST {{baseUrl}}/api/file/downloadZip.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "files": [\n    "a.jpg",\n    "b.png"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/file/downloadZip.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "files": ["a.jpg", "b.png"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/downloadZip.php")! 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 Extract ZIP file(s) into a folder

{{baseUrl}}/api/file/extractZip.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "files": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/extractZip.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/extractZip.php" {:headers {:x-csrf-token ""
                                                                              :phpsessid "{{apiKey}}"}
                                                                    :content-type :json
                                                                    :form-params {:folder "root"
                                                                                  :files ["archive.zip"]}})

require "http/client"

url = "{{baseUrl}}/api/file/extractZip.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\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/file/extractZip.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\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/file/extractZip.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/extractZip.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/extractZip.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/extractZip.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/extractZip.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\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  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/extractZip.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/extractZip.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  files: [
    'archive.zip'
  ]
});

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/file/extractZip.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/extractZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['archive.zip']}
};

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

const url = '{{baseUrl}}/api/file/extractZip.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["archive.zip"]}'
};

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/file/extractZip.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "files": [\n    "archive.zip"\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  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/extractZip.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/extractZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', files: ['archive.zip']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/extractZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'root', files: ['archive.zip']},
  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/file/extractZip.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  files: [
    'archive.zip'
  ]
});

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/file/extractZip.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', files: ['archive.zip']}
};

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

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

const url = '{{baseUrl}}/api/file/extractZip.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","files":["archive.zip"]}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"files": @[ @"archive.zip" ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/extractZip.php"]
                                                       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/file/extractZip.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}" in

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

 "{{baseUrl}}/api/file/extractZip.php",
  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([
    'folder' => 'root',
    'files' => [
        'archive.zip'
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/extractZip.php', [
  'body' => '{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/extractZip.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'files' => [
    'archive.zip'
  ]
]));

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

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

append(json_encode([
  'folder' => 'root',
  'files' => [
    'archive.zip'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/file/extractZip.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/extractZip.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/extractZip.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/extractZip.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/extractZip.php"

payload = {
    "folder": "root",
    "files": ["archive.zip"]
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/extractZip.php"

payload <- "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/extractZip.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\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/file/extractZip.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"files\": [\n    \"archive.zip\"\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/file/extractZip.php";

    let payload = json!({
        "folder": "root",
        "files": ("archive.zip")
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/extractZip.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}'

echo '{
  "folder": "root",
  "files": [
    "archive.zip"
  ]
}' |  \
  http POST {{baseUrl}}/api/file/extractZip.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "files": [\n    "archive.zip"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/file/extractZip.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "files": ["archive.zip"]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/extractZip.php")! 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 List files in a folder

{{baseUrl}}/api/file/getFileList.php

HEADERS

PHPSESSID

QUERY PARAMS

folder

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/getFileList.php?folder=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/file/getFileList.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                    :query-params {:folder ""}})

require "http/client"

url = "{{baseUrl}}/api/file/getFileList.php?folder="
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

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

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

var client = new RestClient("{{baseUrl}}/api/file/getFileList.php?folder=");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/getFileList.php?folder="

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

	req.Header.Add("phpsessid", "{{apiKey}}")

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

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

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

}

GET /baseUrl/api/file/getFileList.php?folder= HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/file/getFileList.php?folder=")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/getFileList.php?folder="))
    .header("phpsessid", "{{apiKey}}")
    .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/file/getFileList.php?folder=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/getFileList.php?folder=")
  .header("phpsessid", "{{apiKey}}")
  .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/file/getFileList.php?folder=');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/file/getFileList.php',
  params: {folder: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/file/getFileList.php?folder=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/file/getFileList.php?folder=',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/file/getFileList.php?folder=")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/getFileList.php?folder=',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/file/getFileList.php',
  qs: {folder: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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/file/getFileList.php');

req.query({
  folder: ''
});

req.headers({
  phpsessid: '{{apiKey}}'
});

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/file/getFileList.php',
  params: {folder: ''},
  headers: {phpsessid: '{{apiKey}}'}
};

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

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

const url = '{{baseUrl}}/api/file/getFileList.php?folder=';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/getFileList.php?folder="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/file/getFileList.php?folder=" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/file/getFileList.php?folder=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/api/file/getFileList.php?folder=', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/getFileList.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'folder' => ''
]);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/file/getFileList.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'folder' => ''
]));

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/getFileList.php?folder=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/getFileList.php?folder=' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/file/getFileList.php?folder=", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/file/getFileList.php"

querystring = {"folder":""}

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/getFileList.php"

queryString <- list(folder = "")

response <- VERB("GET", url, query = queryString, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/getFileList.php?folder=")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/file/getFileList.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.params['folder'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("folder", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/file/getFileList.php?folder=' \
  --header 'phpsessid: {{apiKey}}'

http GET '{{baseUrl}}/api/file/getFileList.php?folder=' \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - '{{baseUrl}}/api/file/getFileList.php?folder='

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/getFileList.php?folder=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Rename a file

{{baseUrl}}/api/file/renameFile.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "oldName": "",
  "newName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/renameFile.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/file/renameFile.php" {:headers {:x-csrf-token ""
                                                                             :phpsessid "{{apiKey}}"}
                                                                   :content-type :json
                                                                   :form-params {:folder "root"
                                                                                 :oldName "old.pdf"
                                                                                 :newName "new.pdf"}})

require "http/client"

url = "{{baseUrl}}/api/file/renameFile.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\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/file/renameFile.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\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/file/renameFile.php");
var request = new RestRequest("", Method.Put);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/renameFile.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/renameFile.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/file/renameFile.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/renameFile.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\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  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/renameFile.php")
  .put(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/file/renameFile.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  oldName: 'old.pdf',
  newName: 'new.pdf'
});

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/file/renameFile.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/file/renameFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', oldName: 'old.pdf', newName: 'new.pdf'}
};

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

const url = '{{baseUrl}}/api/file/renameFile.php';
const options = {
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","oldName":"old.pdf","newName":"new.pdf"}'
};

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/file/renameFile.php',
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "oldName": "old.pdf",\n  "newName": "new.pdf"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/renameFile.php")
  .put(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/renameFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'root', oldName: 'old.pdf', newName: 'new.pdf'}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/file/renameFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'root', oldName: 'old.pdf', newName: 'new.pdf'},
  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/file/renameFile.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  oldName: 'old.pdf',
  newName: 'new.pdf'
});

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/file/renameFile.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'root', oldName: 'old.pdf', newName: 'new.pdf'}
};

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

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

const url = '{{baseUrl}}/api/file/renameFile.php';
const options = {
  method: 'PUT',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","oldName":"old.pdf","newName":"new.pdf"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"oldName": @"old.pdf",
                              @"newName": @"new.pdf" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/renameFile.php"]
                                                       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/file/renameFile.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}" in

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

 "{{baseUrl}}/api/file/renameFile.php",
  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([
    'folder' => 'root',
    'oldName' => 'old.pdf',
    'newName' => 'new.pdf'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/api/file/renameFile.php', [
  'body' => '{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/renameFile.php');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'oldName' => 'old.pdf',
  'newName' => 'new.pdf'
]));

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

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

append(json_encode([
  'folder' => 'root',
  'oldName' => 'old.pdf',
  'newName' => 'new.pdf'
]));
$request->setRequestUrl('{{baseUrl}}/api/file/renameFile.php');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/renameFile.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/renameFile.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("PUT", "/baseUrl/api/file/renameFile.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/renameFile.php"

payload = {
    "folder": "root",
    "oldName": "old.pdf",
    "newName": "new.pdf"
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/renameFile.php"

payload <- "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/renameFile.php")

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

request = Net::HTTP::Put.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\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/file/renameFile.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"oldName\": \"old.pdf\",\n  \"newName\": \"new.pdf\"\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/file/renameFile.php";

    let payload = json!({
        "folder": "root",
        "oldName": "old.pdf",
        "newName": "new.pdf"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/renameFile.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}'

echo '{
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
}' |  \
  http PUT {{baseUrl}}/api/file/renameFile.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method PUT \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "oldName": "old.pdf",\n  "newName": "new.pdf"\n}' \
  --output-document \
  - {{baseUrl}}/api/file/renameFile.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "oldName": "old.pdf",
  "newName": "new.pdf"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/renameFile.php")! 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()

POST Create a new folder

{{baseUrl}}/api/folder/createFolder.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folderName": "",
  "parent": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/createFolder.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/createFolder.php" {:headers {:x-csrf-token ""
                                                                                  :phpsessid "{{apiKey}}"}
                                                                        :content-type :json
                                                                        :form-params {:folderName "reports"
                                                                                      :parent "root"}})

require "http/client"

url = "{{baseUrl}}/api/folder/createFolder.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\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/createFolder.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\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/createFolder.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/createFolder.php"

	payload := strings.NewReader("{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/createFolder.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "folderName": "reports",
  "parent": "root"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/createFolder.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/createFolder.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\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  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/createFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/createFolder.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}")
  .asString();

const data = JSON.stringify({
  folderName: 'reports',
  parent: 'root'
});

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/createFolder.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/createFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folderName: 'reports', parent: 'root'}
};

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

const url = '{{baseUrl}}/api/folder/createFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folderName":"reports","parent":"root"}'
};

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/createFolder.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folderName": "reports",\n  "parent": "root"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/createFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/createFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folderName: 'reports', parent: 'root'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/createFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folderName: 'reports', parent: 'root'},
  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/createFolder.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folderName: 'reports',
  parent: 'root'
});

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/createFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folderName: 'reports', parent: 'root'}
};

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/createFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folderName":"reports","parent":"root"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folderName": @"reports",
                              @"parent": @"root" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/createFolder.php"]
                                                       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/createFolder.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}" in

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

 "{{baseUrl}}/api/folder/createFolder.php",
  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([
    'folderName' => 'reports',
    'parent' => 'root'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$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/createFolder.php', [
  'body' => '{
  "folderName": "reports",
  "parent": "root"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/createFolder.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folderName' => 'reports',
  'parent' => 'root'
]));

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

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

append(json_encode([
  'folderName' => 'reports',
  'parent' => 'root'
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/createFolder.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/createFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folderName": "reports",
  "parent": "root"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/createFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folderName": "reports",
  "parent": "root"
}'

import http.client

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

payload = "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/folder/createFolder.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/createFolder.php"

payload = {
    "folderName": "reports",
    "parent": "root"
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/createFolder.php"

payload <- "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/createFolder.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\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/createFolder.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folderName\": \"reports\",\n  \"parent\": \"root\"\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/createFolder.php";

    let payload = json!({
        "folderName": "reports",
        "parent": "root"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/createFolder.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folderName": "reports",
  "parent": "root"
}'

echo '{
  "folderName": "reports",
  "parent": "root"
}' |  \
  http POST {{baseUrl}}/api/folder/createFolder.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folderName": "reports",\n  "parent": "root"\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/createFolder.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folderName": "reports",
  "parent": "root"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/createFolder.php")! 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 Delete a folder

{{baseUrl}}/api/folder/deleteFolder.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/deleteFolder.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"userA/reports\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/deleteFolder.php" {:headers {:x-csrf-token ""
                                                                                  :phpsessid "{{apiKey}}"}
                                                                        :content-type :json
                                                                        :form-params {:folder "userA/reports"}})

require "http/client"

url = "{{baseUrl}}/api/folder/deleteFolder.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"userA/reports\"\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/deleteFolder.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"userA/reports\"\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/deleteFolder.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"userA/reports\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/deleteFolder.php"

	payload := strings.NewReader("{\n  \"folder\": \"userA/reports\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/deleteFolder.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 31

{
  "folder": "userA/reports"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/deleteFolder.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"userA/reports\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/deleteFolder.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"userA/reports\"\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  \"folder\": \"userA/reports\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/deleteFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/deleteFolder.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"userA/reports\"\n}")
  .asString();

const data = JSON.stringify({
  folder: 'userA/reports'
});

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/deleteFolder.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/deleteFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'userA/reports'}
};

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

const url = '{{baseUrl}}/api/folder/deleteFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"userA/reports"}'
};

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/deleteFolder.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "userA/reports"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"userA/reports\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/deleteFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/deleteFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({folder: 'userA/reports'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/deleteFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {folder: 'userA/reports'},
  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/deleteFolder.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'userA/reports'
});

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/deleteFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {folder: 'userA/reports'}
};

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/deleteFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"userA/reports"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"userA/reports" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/deleteFolder.php"]
                                                       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/deleteFolder.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"userA/reports\"\n}" in

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

 "{{baseUrl}}/api/folder/deleteFolder.php",
  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([
    'folder' => 'userA/reports'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$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/deleteFolder.php', [
  'body' => '{
  "folder": "userA/reports"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/deleteFolder.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'userA/reports'
]));

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

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

append(json_encode([
  'folder' => 'userA/reports'
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/deleteFolder.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/deleteFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "userA/reports"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/deleteFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "userA/reports"
}'

import http.client

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

payload = "{\n  \"folder\": \"userA/reports\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/folder/deleteFolder.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/deleteFolder.php"

payload = { "folder": "userA/reports" }
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/deleteFolder.php"

payload <- "{\n  \"folder\": \"userA/reports\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/deleteFolder.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"userA/reports\"\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/deleteFolder.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"userA/reports\"\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/deleteFolder.php";

    let payload = json!({"folder": "userA/reports"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/deleteFolder.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "userA/reports"
}'

echo '{
  "folder": "userA/reports"
}' |  \
  http POST {{baseUrl}}/api/folder/deleteFolder.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "userA/reports"\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/deleteFolder.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["folder": "userA/reports"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/deleteFolder.php")! 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 Get effective capabilities for the current user in a folder

{{baseUrl}}/api/folder/capabilities.php

HEADERS

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/capabilities.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/folder/capabilities.php" {:headers {:phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/folder/capabilities.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
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/capabilities.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
};
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/capabilities.php");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/capabilities.php"

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

	req.Header.Add("phpsessid", "{{apiKey}}")

	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/capabilities.php HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/folder/capabilities.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/capabilities.php"))
    .header("phpsessid", "{{apiKey}}")
    .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/capabilities.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/capabilities.php")
  .header("phpsessid", "{{apiKey}}")
  .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/capabilities.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/folder/capabilities.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/folder/capabilities.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/capabilities.php',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/capabilities.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/capabilities.php',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/capabilities.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/capabilities.php');

req.headers({
  phpsessid: '{{apiKey}}'
});

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/capabilities.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/capabilities.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/capabilities.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/capabilities.php" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/folder/capabilities.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

$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/capabilities.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/capabilities.php');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/folder/capabilities.php');
$request->setRequestMethod('GET');
$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/capabilities.php' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/capabilities.php' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/folder/capabilities.php", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/capabilities.php"

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/capabilities.php"

response <- VERB("GET", url, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/capabilities.php")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/folder/capabilities.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/folder/capabilities.php \
  --header 'phpsessid: {{apiKey}}'

http GET {{baseUrl}}/api/folder/capabilities.php \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/folder/capabilities.php

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

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

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "user": "alice",
  "folder": "projects/acme",
  "isAdmin": false,
  "flags": {
    "folderOnly": false,
    "readOnly": false,
    "disableUpload": false
  },
  "owner": "alice",
  "canView": true,
  "canUpload": true,
  "canCreate": true,
  "canRename": true,
  "canDelete": true,
  "canMoveIn": true,
  "canShare": false
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": "Unauthorized"
}

GET List folders (optionally under a parent)

{{baseUrl}}/api/folder/getFolderList.php

HEADERS

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/getFolderList.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/folder/getFolderList.php" {:headers {:phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/folder/getFolderList.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
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/getFolderList.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
};
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/getFolderList.php");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/getFolderList.php"

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

	req.Header.Add("phpsessid", "{{apiKey}}")

	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/getFolderList.php HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/folder/getFolderList.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/getFolderList.php"))
    .header("phpsessid", "{{apiKey}}")
    .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/getFolderList.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/getFolderList.php")
  .header("phpsessid", "{{apiKey}}")
  .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/getFolderList.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/folder/getFolderList.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/folder/getFolderList.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/getFolderList.php',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/getFolderList.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/getFolderList.php',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/getFolderList.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/getFolderList.php');

req.headers({
  phpsessid: '{{apiKey}}'
});

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/getFolderList.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/getFolderList.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/getFolderList.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/getFolderList.php" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/folder/getFolderList.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

$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/getFolderList.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/getFolderList.php');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/folder/getFolderList.php');
$request->setRequestMethod('GET');
$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/getFolderList.php' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/getFolderList.php' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/folder/getFolderList.php", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/getFolderList.php"

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/getFolderList.php"

response <- VERB("GET", url, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/getFolderList.php")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/folder/getFolderList.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/folder/getFolderList.php \
  --header 'phpsessid: {{apiKey}}'

http GET {{baseUrl}}/api/folder/getFolderList.php \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/folder/getFolderList.php

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

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

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "folder": "team/reports",
    "fileCount": 12,
    "metadataFile": "/path/to/meta.json"
  }
]

POST Rename or move a folder

{{baseUrl}}/api/folder/renameFolder.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "oldFolder": "",
  "newFolder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/renameFolder.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/renameFolder.php" {:headers {:x-csrf-token ""
                                                                                  :phpsessid "{{apiKey}}"}
                                                                        :content-type :json
                                                                        :form-params {:oldFolder "team/q1"
                                                                                      :newFolder "team/quarter-1"}})

require "http/client"

url = "{{baseUrl}}/api/folder/renameFolder.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\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/renameFolder.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\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/renameFolder.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/renameFolder.php"

	payload := strings.NewReader("{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/renameFolder.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 61

{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/renameFolder.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/renameFolder.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\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  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/renameFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/renameFolder.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}")
  .asString();

const data = JSON.stringify({
  oldFolder: 'team/q1',
  newFolder: 'team/quarter-1'
});

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/renameFolder.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/renameFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {oldFolder: 'team/q1', newFolder: 'team/quarter-1'}
};

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

const url = '{{baseUrl}}/api/folder/renameFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"oldFolder":"team/q1","newFolder":"team/quarter-1"}'
};

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/renameFolder.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "oldFolder": "team/q1",\n  "newFolder": "team/quarter-1"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/renameFolder.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/renameFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({oldFolder: 'team/q1', newFolder: 'team/quarter-1'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/renameFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {oldFolder: 'team/q1', newFolder: 'team/quarter-1'},
  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/renameFolder.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  oldFolder: 'team/q1',
  newFolder: 'team/quarter-1'
});

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/renameFolder.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {oldFolder: 'team/q1', newFolder: 'team/quarter-1'}
};

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/renameFolder.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"oldFolder":"team/q1","newFolder":"team/quarter-1"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"oldFolder": @"team/q1",
                              @"newFolder": @"team/quarter-1" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/renameFolder.php"]
                                                       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/renameFolder.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}" in

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

 "{{baseUrl}}/api/folder/renameFolder.php",
  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([
    'oldFolder' => 'team/q1',
    'newFolder' => 'team/quarter-1'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$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/renameFolder.php', [
  'body' => '{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/renameFolder.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'oldFolder' => 'team/q1',
  'newFolder' => 'team/quarter-1'
]));

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

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

append(json_encode([
  'oldFolder' => 'team/q1',
  'newFolder' => 'team/quarter-1'
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/renameFolder.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/renameFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/renameFolder.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}'

import http.client

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

payload = "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/folder/renameFolder.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/renameFolder.php"

payload = {
    "oldFolder": "team/q1",
    "newFolder": "team/quarter-1"
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/renameFolder.php"

payload <- "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/renameFolder.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\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/renameFolder.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"oldFolder\": \"team/q1\",\n  \"newFolder\": \"team/quarter-1\"\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/renameFolder.php";

    let payload = json!({
        "oldFolder": "team/q1",
        "newFolder": "team/quarter-1"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/renameFolder.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}'

echo '{
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
}' |  \
  http POST {{baseUrl}}/api/folder/renameFolder.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "oldFolder": "team/q1",\n  "newFolder": "team/quarter-1"\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/renameFolder.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "oldFolder": "team/q1",
  "newFolder": "team/quarter-1"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/renameFolder.php")! 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 Create a share link for a folder

{{baseUrl}}/api/folder/createShareFolderLink.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/createShareFolderLink.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/createShareFolderLink.php" {:headers {:x-csrf-token ""
                                                                                           :phpsessid "{{apiKey}}"}
                                                                                 :content-type :json
                                                                                 :form-params {:folder ""
                                                                                               :expirationValue 0
                                                                                               :expirationUnit ""
                                                                                               :password ""
                                                                                               :allowUpload 0}})

require "http/client"

url = "{{baseUrl}}/api/folder/createShareFolderLink.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\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/createShareFolderLink.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 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/folder/createShareFolderLink.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/createShareFolderLink.php"

	payload := strings.NewReader("{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/createShareFolderLink.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 104

{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/createShareFolderLink.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/createShareFolderLink.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 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  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/createShareFolderLink.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/createShareFolderLink.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}")
  .asString();

const data = JSON.stringify({
  folder: '',
  expirationValue: 0,
  expirationUnit: '',
  password: '',
  allowUpload: 0
});

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/createShareFolderLink.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/createShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    folder: '',
    expirationValue: 0,
    expirationUnit: '',
    password: '',
    allowUpload: 0
  }
};

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

const url = '{{baseUrl}}/api/folder/createShareFolderLink.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"","expirationValue":0,"expirationUnit":"","password":"","allowUpload":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/folder/createShareFolderLink.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "",\n  "expirationValue": 0,\n  "expirationUnit": "",\n  "password": "",\n  "allowUpload": 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  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/createShareFolderLink.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/createShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({
  folder: '',
  expirationValue: 0,
  expirationUnit: '',
  password: '',
  allowUpload: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/createShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {
    folder: '',
    expirationValue: 0,
    expirationUnit: '',
    password: '',
    allowUpload: 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('POST', '{{baseUrl}}/api/folder/createShareFolderLink.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: '',
  expirationValue: 0,
  expirationUnit: '',
  password: '',
  allowUpload: 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: 'POST',
  url: '{{baseUrl}}/api/folder/createShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    folder: '',
    expirationValue: 0,
    expirationUnit: '',
    password: '',
    allowUpload: 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/folder/createShareFolderLink.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"","expirationValue":0,"expirationUnit":"","password":"","allowUpload":0}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"",
                              @"expirationValue": @0,
                              @"expirationUnit": @"",
                              @"password": @"",
                              @"allowUpload": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/createShareFolderLink.php"]
                                                       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/createShareFolderLink.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}" in

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

 "{{baseUrl}}/api/folder/createShareFolderLink.php",
  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([
    'folder' => '',
    'expirationValue' => 0,
    'expirationUnit' => '',
    'password' => '',
    'allowUpload' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$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/createShareFolderLink.php', [
  'body' => '{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/createShareFolderLink.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => '',
  'expirationValue' => 0,
  'expirationUnit' => '',
  'password' => '',
  'allowUpload' => 0
]));

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

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

append(json_encode([
  'folder' => '',
  'expirationValue' => 0,
  'expirationUnit' => '',
  'password' => '',
  'allowUpload' => 0
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/createShareFolderLink.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/createShareFolderLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/createShareFolderLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}'

import http.client

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

payload = "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/folder/createShareFolderLink.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/createShareFolderLink.php"

payload = {
    "folder": "",
    "expirationValue": 0,
    "expirationUnit": "",
    "password": "",
    "allowUpload": 0
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/createShareFolderLink.php"

payload <- "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/createShareFolderLink.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 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.post('/baseUrl/api/folder/createShareFolderLink.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\",\n  \"allowUpload\": 0\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/createShareFolderLink.php";

    let payload = json!({
        "folder": "",
        "expirationValue": 0,
        "expirationUnit": "",
        "password": "",
        "allowUpload": 0
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/createShareFolderLink.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}'

echo '{
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
}' |  \
  http POST {{baseUrl}}/api/folder/createShareFolderLink.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "",\n  "expirationValue": 0,\n  "expirationUnit": "",\n  "password": "",\n  "allowUpload": 0\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/createShareFolderLink.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": "",
  "allowUpload": 0
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/createShareFolderLink.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "token": "sf_abc123",
  "url": "/api/folder/shareFolder.php?token=sf_abc123",
  "expires": 1700000000
}

POST Delete a shared-folder link by token (admin only)

{{baseUrl}}/api/folder/deleteShareFolderLink.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "token": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/deleteShareFolderLink.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"token\": \"sf_abc123\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/deleteShareFolderLink.php" {:headers {:x-csrf-token ""
                                                                                           :phpsessid "{{apiKey}}"}
                                                                                 :content-type :json
                                                                                 :form-params {:token "sf_abc123"}})

require "http/client"

url = "{{baseUrl}}/api/folder/deleteShareFolderLink.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"token\": \"sf_abc123\"\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/deleteShareFolderLink.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"token\": \"sf_abc123\"\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/deleteShareFolderLink.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"token\": \"sf_abc123\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/deleteShareFolderLink.php"

	payload := strings.NewReader("{\n  \"token\": \"sf_abc123\"\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/deleteShareFolderLink.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "token": "sf_abc123"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/deleteShareFolderLink.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"token\": \"sf_abc123\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/deleteShareFolderLink.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"token\": \"sf_abc123\"\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  \"token\": \"sf_abc123\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/deleteShareFolderLink.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/deleteShareFolderLink.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"token\": \"sf_abc123\"\n}")
  .asString();

const data = JSON.stringify({
  token: 'sf_abc123'
});

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/deleteShareFolderLink.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/deleteShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {token: 'sf_abc123'}
};

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

const url = '{{baseUrl}}/api/folder/deleteShareFolderLink.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"token":"sf_abc123"}'
};

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/deleteShareFolderLink.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "token": "sf_abc123"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"token\": \"sf_abc123\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/deleteShareFolderLink.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/deleteShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({token: 'sf_abc123'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/deleteShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {token: 'sf_abc123'},
  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/deleteShareFolderLink.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  token: 'sf_abc123'
});

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/deleteShareFolderLink.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {token: 'sf_abc123'}
};

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/deleteShareFolderLink.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"token":"sf_abc123"}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"token": @"sf_abc123" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/deleteShareFolderLink.php"]
                                                       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/deleteShareFolderLink.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"token\": \"sf_abc123\"\n}" in

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

 "{{baseUrl}}/api/folder/deleteShareFolderLink.php",
  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([
    'token' => 'sf_abc123'
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$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/deleteShareFolderLink.php', [
  'body' => '{
  "token": "sf_abc123"
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/deleteShareFolderLink.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'token' => 'sf_abc123'
]));

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

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

append(json_encode([
  'token' => 'sf_abc123'
]));
$request->setRequestUrl('{{baseUrl}}/api/folder/deleteShareFolderLink.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/deleteShareFolderLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "token": "sf_abc123"
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/deleteShareFolderLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "token": "sf_abc123"
}'

import http.client

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

payload = "{\n  \"token\": \"sf_abc123\"\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/folder/deleteShareFolderLink.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/deleteShareFolderLink.php"

payload = { "token": "sf_abc123" }
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/deleteShareFolderLink.php"

payload <- "{\n  \"token\": \"sf_abc123\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/deleteShareFolderLink.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"token\": \"sf_abc123\"\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/deleteShareFolderLink.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"token\": \"sf_abc123\"\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/deleteShareFolderLink.php";

    let payload = json!({"token": "sf_abc123"});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/deleteShareFolderLink.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "token": "sf_abc123"
}'

echo '{
  "token": "sf_abc123"
}' |  \
  http POST {{baseUrl}}/api/folder/deleteShareFolderLink.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "token": "sf_abc123"\n}' \
  --output-document \
  - {{baseUrl}}/api/folder/deleteShareFolderLink.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["token": "sf_abc123"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/deleteShareFolderLink.php")! 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 Download a file from a shared folder (by token)

{{baseUrl}}/api/folder/downloadSharedFile.php

QUERY PARAMS

token

file

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/folder/downloadSharedFile.php" {:query-params {:token ""
                                                                                            :file ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file="

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/downloadSharedFile.php?token=&file="),
};
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/downloadSharedFile.php?token=&file=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file="

	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/downloadSharedFile.php?token=&file= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file="))
    .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/downloadSharedFile.php?token=&file=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=")
  .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/downloadSharedFile.php?token=&file=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/folder/downloadSharedFile.php',
  params: {token: '', file: ''}
};

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

const url = '{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=';
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/downloadSharedFile.php?token=&file=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=")
  .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/downloadSharedFile.php?token=&file=',
  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/downloadSharedFile.php',
  qs: {token: '', file: ''}
};

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/downloadSharedFile.php');

req.query({
  token: '',
  file: ''
});

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/downloadSharedFile.php',
  params: {token: '', file: ''}
};

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/downloadSharedFile.php?token=&file=';
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/downloadSharedFile.php?token=&file="]
                                                       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/downloadSharedFile.php?token=&file=" in

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

 "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=",
  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/downloadSharedFile.php?token=&file=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/downloadSharedFile.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => '',
  'file' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/folder/downloadSharedFile.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => '',
  'file' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/folder/downloadSharedFile.php?token=&file=")

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

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

import requests

url = "{{baseUrl}}/api/folder/downloadSharedFile.php"

querystring = {"token":"","file":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/downloadSharedFile.php"

queryString <- list(
  token = "",
  file = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=")

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/downloadSharedFile.php') do |req|
  req.params['token'] = ''
  req.params['file'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("token", ""),
        ("file", ""),
    ];

    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/folder/downloadSharedFile.php?token=&file='

http GET '{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/downloadSharedFile.php?token=&file=")! 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 List active shared-folder links (admin only)

{{baseUrl}}/api/folder/getShareFolderLinks.php

HEADERS

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/getShareFolderLinks.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/folder/getShareFolderLinks.php" {:headers {:phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/folder/getShareFolderLinks.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
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/getShareFolderLinks.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
};
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/getShareFolderLinks.php");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/getShareFolderLinks.php"

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

	req.Header.Add("phpsessid", "{{apiKey}}")

	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/getShareFolderLinks.php HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/folder/getShareFolderLinks.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/getShareFolderLinks.php"))
    .header("phpsessid", "{{apiKey}}")
    .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/getShareFolderLinks.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/getShareFolderLinks.php")
  .header("phpsessid", "{{apiKey}}")
  .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/getShareFolderLinks.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/folder/getShareFolderLinks.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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

const url = '{{baseUrl}}/api/folder/getShareFolderLinks.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/getShareFolderLinks.php',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/getShareFolderLinks.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/getShareFolderLinks.php',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/getShareFolderLinks.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/getShareFolderLinks.php');

req.headers({
  phpsessid: '{{apiKey}}'
});

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/getShareFolderLinks.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/getShareFolderLinks.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/getShareFolderLinks.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/getShareFolderLinks.php" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

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

 "{{baseUrl}}/api/folder/getShareFolderLinks.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

$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/getShareFolderLinks.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/getShareFolderLinks.php');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

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

setRequestUrl('{{baseUrl}}/api/folder/getShareFolderLinks.php');
$request->setRequestMethod('GET');
$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/getShareFolderLinks.php' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/getShareFolderLinks.php' -Method GET -Headers $headers

import http.client

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

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/folder/getShareFolderLinks.php", headers=headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/getShareFolderLinks.php"

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/getShareFolderLinks.php"

response <- VERB("GET", url, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/getShareFolderLinks.php")

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

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

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

require 'faraday'

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

response = conn.get('/baseUrl/api/folder/getShareFolderLinks.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/folder/getShareFolderLinks.php \
  --header 'phpsessid: {{apiKey}}'

http GET {{baseUrl}}/api/folder/getShareFolderLinks.php \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/folder/getShareFolderLinks.php

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

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

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 Open a shared folder by token (HTML UI)

{{baseUrl}}/api/folder/shareFolder.php

QUERY PARAMS

token

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/shareFolder.php?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/folder/shareFolder.php" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/api/folder/shareFolder.php?token="

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/shareFolder.php?token="),
};
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/shareFolder.php?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/shareFolder.php?token="

	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/shareFolder.php?token= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/shareFolder.php?token="))
    .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/shareFolder.php?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/folder/shareFolder.php?token=")
  .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/shareFolder.php?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/folder/shareFolder.php',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/api/folder/shareFolder.php?token=';
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/shareFolder.php?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/shareFolder.php?token=")
  .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/shareFolder.php?token=',
  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/shareFolder.php',
  qs: {token: ''}
};

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/shareFolder.php');

req.query({
  token: ''
});

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/shareFolder.php',
  params: {token: ''}
};

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/shareFolder.php?token=';
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/shareFolder.php?token="]
                                                       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/shareFolder.php?token=" in

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

 "{{baseUrl}}/api/folder/shareFolder.php?token=",
  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/shareFolder.php?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/shareFolder.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/folder/shareFolder.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/shareFolder.php?token=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/shareFolder.php?token=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/folder/shareFolder.php?token=")

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

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

import requests

url = "{{baseUrl}}/api/folder/shareFolder.php"

querystring = {"token":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/shareFolder.php"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/shareFolder.php?token=")

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/shareFolder.php') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("token", ""),
    ];

    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/folder/shareFolder.php?token='

http GET '{{baseUrl}}/api/folder/shareFolder.php?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/folder/shareFolder.php?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/shareFolder.php?token=")! 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 Upload a file into a shared folder (by token)

{{baseUrl}}/api/folder/uploadToSharedFolder.php

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/folder/uploadToSharedFolder.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/folder/uploadToSharedFolder.php" {:multipart [{:name "token"
                                                                                             :content ""} {:name "fileToUpload"
                                                                                             :content ""}]})

require "http/client"

url = "{{baseUrl}}/api/folder/uploadToSharedFolder.php"
headers = HTTP::Headers{
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\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/uploadToSharedFolder.php"),
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "token",
                }
            }
        },
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "fileToUpload",
                }
            }
        },
    },
};
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/uploadToSharedFolder.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/folder/uploadToSharedFolder.php"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

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

	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	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/uploadToSharedFolder.php HTTP/1.1
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 202

-----011000010111000001101001
Content-Disposition: form-data; name="token"


-----011000010111000001101001
Content-Disposition: form-data; name="fileToUpload"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/folder/uploadToSharedFolder.php")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/folder/uploadToSharedFolder.php"))
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/folder/uploadToSharedFolder.php")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/folder/uploadToSharedFolder.php")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('token', '');
data.append('fileToUpload', '');

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/uploadToSharedFolder.php');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('token', '');
form.append('fileToUpload', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/uploadToSharedFolder.php',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '[form]'
};

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

const url = '{{baseUrl}}/api/folder/uploadToSharedFolder.php';
const form = new FormData();
form.append('token', '');
form.append('fileToUpload', '');

const options = {method: 'POST'};

options.body = form;

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

const form = new FormData();
form.append('token', '');
form.append('fileToUpload', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/folder/uploadToSharedFolder.php',
  method: 'POST',
  headers: {},
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/api/folder/uploadToSharedFolder.php")
  .post(body)
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/folder/uploadToSharedFolder.php',
  headers: {
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="token"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="fileToUpload"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/folder/uploadToSharedFolder.php',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  formData: {token: '', fileToUpload: ''}
};

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/uploadToSharedFolder.php');

req.headers({
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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/uploadToSharedFolder.php',
  headers: {'content-type': 'multipart/form-data; boundary=---011000010111000001101001'},
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="token"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="fileToUpload"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

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

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('token', '');
formData.append('fileToUpload', '');

const url = '{{baseUrl}}/api/folder/uploadToSharedFolder.php';
const options = {method: 'POST'};
options.body = formData;

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": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"token", @"value": @"" },
                         @{ @"name": @"fileToUpload", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/folder/uploadToSharedFolder.php"]
                                                       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/uploadToSharedFolder.php" in
let headers = Header.add (Header.init ()) "content-type" "multipart/form-data; boundary=---011000010111000001101001" in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

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

 "{{baseUrl}}/api/folder/uploadToSharedFolder.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001"
  ],
]);

$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/uploadToSharedFolder.php', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/folder/uploadToSharedFolder.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="token"


-----011000010111000001101001
Content-Disposition: form-data; name="fileToUpload"


-----011000010111000001101001--
');

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

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

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/api/folder/uploadToSharedFolder.php');
$request->setRequestMethod('POST');
$request->setBody($body);

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/folder/uploadToSharedFolder.php' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="token"


-----011000010111000001101001
Content-Disposition: form-data; name="fileToUpload"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/folder/uploadToSharedFolder.php' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="token"


-----011000010111000001101001
Content-Disposition: form-data; name="fileToUpload"


-----011000010111000001101001--
'

import http.client

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

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = { 'content-type': "multipart/form-data; boundary=---011000010111000001101001" }

conn.request("POST", "/baseUrl/api/folder/uploadToSharedFolder.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/folder/uploadToSharedFolder.php"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {"content-type": "multipart/form-data; boundary=---011000010111000001101001"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/folder/uploadToSharedFolder.php"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/folder/uploadToSharedFolder.php")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

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

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/api/folder/uploadToSharedFolder.php') do |req|
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"token\"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"fileToUpload\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

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

    let form = reqwest::multipart::Form::new()
        .text("token", "")
        .text("fileToUpload", "");
    let mut headers = reqwest::header::HeaderMap::new();

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/folder/uploadToSharedFolder.php \
  --header 'content-type: multipart/form-data' \
  --form token= \
  --form fileToUpload=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="token"


-----011000010111000001101001
Content-Disposition: form-data; name="fileToUpload"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/api/folder/uploadToSharedFolder.php \
  content-type:'multipart/form-data; boundary=---011000010111000001101001'

wget --quiet \
  --method POST \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="token"\r\n\r\n\r\n-----011000010111000001101001\r\nContent-Disposition: form-data; name="fileToUpload"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/api/folder/uploadToSharedFolder.php

import Foundation

let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
let parameters = [
  [
    "name": "token",
    "value": ""
  ],
  [
    "name": "fileToUpload",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/folder/uploadToSharedFolder.php")! 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 Create a share link for a file

{{baseUrl}}/api/file/createShareLink.php

HEADERS

PHPSESSID

BODY json

{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/createShareLink.php");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/createShareLink.php" {:headers {:phpsessid "{{apiKey}}"}
                                                                         :content-type :json
                                                                         :form-params {:folder ""
                                                                                       :file ""
                                                                                       :expirationValue 0
                                                                                       :expirationUnit ""
                                                                                       :password ""}})

require "http/client"

url = "{{baseUrl}}/api/file/createShareLink.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\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/file/createShareLink.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\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/file/createShareLink.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/createShareLink.php"

	payload := strings.NewReader("{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}")

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

	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/createShareLink.php HTTP/1.1
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/createShareLink.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/createShareLink.php"))
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\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  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/createShareLink.php")
  .post(body)
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/createShareLink.php")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  folder: '',
  file: '',
  expirationValue: 0,
  expirationUnit: '',
  password: ''
});

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/file/createShareLink.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/createShareLink.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {folder: '', file: '', expirationValue: 0, expirationUnit: '', password: ''}
};

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

const url = '{{baseUrl}}/api/file/createShareLink.php';
const options = {
  method: 'POST',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"folder":"","file":"","expirationValue":0,"expirationUnit":"","password":""}'
};

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/file/createShareLink.php',
  method: 'POST',
  headers: {
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "",\n  "file": "",\n  "expirationValue": 0,\n  "expirationUnit": "",\n  "password": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/createShareLink.php")
  .post(body)
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/createShareLink.php',
  headers: {
    phpsessid: '{{apiKey}}',
    '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({folder: '', file: '', expirationValue: 0, expirationUnit: '', password: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/createShareLink.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: {folder: '', file: '', expirationValue: 0, expirationUnit: '', password: ''},
  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/file/createShareLink.php');

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

req.type('json');
req.send({
  folder: '',
  file: '',
  expirationValue: 0,
  expirationUnit: '',
  password: ''
});

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/file/createShareLink.php',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  data: {folder: '', file: '', expirationValue: 0, expirationUnit: '', password: ''}
};

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

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

const url = '{{baseUrl}}/api/file/createShareLink.php';
const options = {
  method: 'POST',
  headers: {phpsessid: '{{apiKey}}', 'content-type': 'application/json'},
  body: '{"folder":"","file":"","expirationValue":0,"expirationUnit":"","password":""}'
};

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

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"",
                              @"file": @"",
                              @"expirationValue": @0,
                              @"expirationUnit": @"",
                              @"password": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/createShareLink.php"]
                                                       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/file/createShareLink.php" in
let headers = Header.add_list (Header.init ()) [
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}" in

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

 "{{baseUrl}}/api/file/createShareLink.php",
  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([
    'folder' => '',
    'file' => '',
    'expirationValue' => 0,
    'expirationUnit' => '',
    'password' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/createShareLink.php', [
  'body' => '{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/createShareLink.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => '',
  'file' => '',
  'expirationValue' => 0,
  'expirationUnit' => '',
  'password' => ''
]));

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

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

append(json_encode([
  'folder' => '',
  'file' => '',
  'expirationValue' => 0,
  'expirationUnit' => '',
  'password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/file/createShareLink.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/createShareLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}'

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/createShareLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}'

import http.client

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

payload = "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}"

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

conn.request("POST", "/baseUrl/api/file/createShareLink.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/createShareLink.php"

payload = {
    "folder": "",
    "file": "",
    "expirationValue": 0,
    "expirationUnit": "",
    "password": ""
}
headers = {
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/createShareLink.php"

payload <- "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/createShareLink.php")

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

request = Net::HTTP::Post.new(url)
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\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/file/createShareLink.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"\",\n  \"file\": \"\",\n  \"expirationValue\": 0,\n  \"expirationUnit\": \"\",\n  \"password\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "folder": "",
        "file": "",
        "expirationValue": 0,
        "expirationUnit": "",
        "password": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/createShareLink.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --data '{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}'

echo '{
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
}' |  \
  http POST {{baseUrl}}/api/file/createShareLink.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method POST \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "",\n  "file": "",\n  "expirationValue": 0,\n  "expirationUnit": "",\n  "password": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/file/createShareLink.php

import Foundation

let headers = [
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "",
  "file": "",
  "expirationValue": 0,
  "expirationUnit": "",
  "password": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/createShareLink.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "token": "abc123",
  "url": "/api/file/share.php?token=abc123",
  "expires": 1700000000
}

POST Delete a share link by token

{{baseUrl}}/api/file/deleteShareLink.php

BODY json

{
  "token": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/deleteShareLink.php");

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  \"token\": \"abc123\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/deleteShareLink.php" {:content-type :json
                                                                         :form-params {:token "abc123"}})

require "http/client"

url = "{{baseUrl}}/api/file/deleteShareLink.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"token\": \"abc123\"\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/file/deleteShareLink.php"),
    Content = new StringContent("{\n  \"token\": \"abc123\"\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/file/deleteShareLink.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"token\": \"abc123\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/deleteShareLink.php"

	payload := strings.NewReader("{\n  \"token\": \"abc123\"\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/file/deleteShareLink.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "token": "abc123"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/deleteShareLink.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"token\": \"abc123\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/deleteShareLink.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"token\": \"abc123\"\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  \"token\": \"abc123\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/deleteShareLink.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/deleteShareLink.php")
  .header("content-type", "application/json")
  .body("{\n  \"token\": \"abc123\"\n}")
  .asString();

const data = JSON.stringify({
  token: 'abc123'
});

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/file/deleteShareLink.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/deleteShareLink.php',
  headers: {'content-type': 'application/json'},
  data: {token: 'abc123'}
};

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

const url = '{{baseUrl}}/api/file/deleteShareLink.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"token":"abc123"}'
};

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/file/deleteShareLink.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "token": "abc123"\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"token\": \"abc123\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/deleteShareLink.php")
  .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/file/deleteShareLink.php',
  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({token: 'abc123'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/deleteShareLink.php',
  headers: {'content-type': 'application/json'},
  body: {token: 'abc123'},
  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/file/deleteShareLink.php');

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

req.type('json');
req.send({
  token: 'abc123'
});

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/file/deleteShareLink.php',
  headers: {'content-type': 'application/json'},
  data: {token: 'abc123'}
};

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

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

const url = '{{baseUrl}}/api/file/deleteShareLink.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"token":"abc123"}'
};

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 = @{ @"token": @"abc123" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/deleteShareLink.php"]
                                                       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/file/deleteShareLink.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"token\": \"abc123\"\n}" in

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

 "{{baseUrl}}/api/file/deleteShareLink.php",
  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([
    'token' => 'abc123'
  ]),
  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/file/deleteShareLink.php', [
  'body' => '{
  "token": "abc123"
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/deleteShareLink.php');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'token' => 'abc123'
]));

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

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

append(json_encode([
  'token' => 'abc123'
]));
$request->setRequestUrl('{{baseUrl}}/api/file/deleteShareLink.php');
$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/file/deleteShareLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "token": "abc123"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/deleteShareLink.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "token": "abc123"
}'

import http.client

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

payload = "{\n  \"token\": \"abc123\"\n}"

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

conn.request("POST", "/baseUrl/api/file/deleteShareLink.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/deleteShareLink.php"

payload = { "token": "abc123" }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/deleteShareLink.php"

payload <- "{\n  \"token\": \"abc123\"\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/file/deleteShareLink.php")

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  \"token\": \"abc123\"\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/file/deleteShareLink.php') do |req|
  req.body = "{\n  \"token\": \"abc123\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({"token": "abc123"});

    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/file/deleteShareLink.php \
  --header 'content-type: application/json' \
  --data '{
  "token": "abc123"
}'

echo '{
  "token": "abc123"
}' |  \
  http POST {{baseUrl}}/api/file/deleteShareLink.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "token": "abc123"\n}' \
  --output-document \
  - {{baseUrl}}/api/file/deleteShareLink.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["token": "abc123"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/deleteShareLink.php")! 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/file/getShareLinks.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/file/getShareLinks.php")

require "http/client"

url = "{{baseUrl}}/api/file/getShareLinks.php"

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/file/getShareLinks.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/file/getShareLinks.php"

	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/file/getShareLinks.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/getShareLinks.php"))
    .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/file/getShareLinks.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/getShareLinks.php")
  .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/file/getShareLinks.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/file/getShareLinks.php'};

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

const url = '{{baseUrl}}/api/file/getShareLinks.php';
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/file/getShareLinks.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/getShareLinks.php',
  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/file/getShareLinks.php'};

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/file/getShareLinks.php');

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/file/getShareLinks.php'};

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

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

const url = '{{baseUrl}}/api/file/getShareLinks.php';
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/file/getShareLinks.php"]
                                                       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/file/getShareLinks.php" in

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

 "{{baseUrl}}/api/file/getShareLinks.php",
  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/file/getShareLinks.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/getShareLinks.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/getShareLinks.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/getShareLinks.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/file/getShareLinks.php")

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

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

import requests

url = "{{baseUrl}}/api/file/getShareLinks.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/getShareLinks.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/getShareLinks.php")

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/file/getShareLinks.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/file/getShareLinks.php

http GET {{baseUrl}}/api/file/getShareLinks.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/file/getShareLinks.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/getShareLinks.php")! 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 Open a shared file by token

{{baseUrl}}/api/file/share.php

QUERY PARAMS

token

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/share.php?token=");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/file/share.php" {:query-params {:token ""}})

require "http/client"

url = "{{baseUrl}}/api/file/share.php?token="

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/file/share.php?token="),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/file/share.php?token=");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/share.php?token="

	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/file/share.php?token= HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/share.php?token="))
    .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/file/share.php?token=")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/share.php?token=")
  .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/file/share.php?token=');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/file/share.php',
  params: {token: ''}
};

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

const url = '{{baseUrl}}/api/file/share.php?token=';
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/file/share.php?token=',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/file/share.php?token=")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/share.php?token=',
  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/file/share.php',
  qs: {token: ''}
};

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/file/share.php');

req.query({
  token: ''
});

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/file/share.php',
  params: {token: ''}
};

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

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

const url = '{{baseUrl}}/api/file/share.php?token=';
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/file/share.php?token="]
                                                       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/file/share.php?token=" in

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

 "{{baseUrl}}/api/file/share.php?token=",
  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/file/share.php?token=');

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/share.php');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'token' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/api/file/share.php');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'token' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/share.php?token=' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/share.php?token=' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/file/share.php?token=")

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

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

import requests

url = "{{baseUrl}}/api/file/share.php"

querystring = {"token":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/share.php"

queryString <- list(token = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/share.php?token=")

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/file/share.php') do |req|
  req.params['token'] = ''
end

puts response.status
puts response.body

use reqwest;

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

    let querystring = [
        ("token", ""),
    ];

    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/file/share.php?token='

http GET '{{baseUrl}}/api/file/share.php?token='

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/api/file/share.php?token='

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/share.php?token=")! 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 global file tags

{{baseUrl}}/api/file/getFileTags.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/getFileTags.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/api/file/getFileTags.php")

require "http/client"

url = "{{baseUrl}}/api/file/getFileTags.php"

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/file/getFileTags.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/file/getFileTags.php"

	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/file/getFileTags.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/getFileTags.php"))
    .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/file/getFileTags.php")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/getFileTags.php")
  .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/file/getFileTags.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/file/getFileTags.php'};

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

const url = '{{baseUrl}}/api/file/getFileTags.php';
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/file/getFileTags.php',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/getFileTags.php',
  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/file/getFileTags.php'};

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/file/getFileTags.php');

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/file/getFileTags.php'};

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

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

const url = '{{baseUrl}}/api/file/getFileTags.php';
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/file/getFileTags.php"]
                                                       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/file/getFileTags.php" in

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

 "{{baseUrl}}/api/file/getFileTags.php",
  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/file/getFileTags.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/getFileTags.php');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/getFileTags.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/getFileTags.php' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/api/file/getFileTags.php")

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

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

import requests

url = "{{baseUrl}}/api/file/getFileTags.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/getFileTags.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/getFileTags.php")

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/file/getFileTags.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/file/getFileTags.php

http GET {{baseUrl}}/api/file/getFileTags.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/file/getFileTags.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/getFileTags.php")! 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 Save tags for a file (or delete one)

{{baseUrl}}/api/file/saveFileTag.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "folder": "",
  "file": "",
  "tags": [],
  "deleteGlobal": false,
  "tagToDelete": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/saveFileTag.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/file/saveFileTag.php" {:headers {:x-csrf-token ""
                                                                               :phpsessid "{{apiKey}}"}
                                                                     :content-type :json
                                                                     :form-params {:folder "root"
                                                                                   :file "doc.md"
                                                                                   :tags ["work" "urgent"]
                                                                                   :deleteGlobal false
                                                                                   :tagToDelete nil}})

require "http/client"

url = "{{baseUrl}}/api/file/saveFileTag.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\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/file/saveFileTag.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\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/file/saveFileTag.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/file/saveFileTag.php"

	payload := strings.NewReader("{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}")

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

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/saveFileTag.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 132

{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/saveFileTag.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/saveFileTag.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\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  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/saveFileTag.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/saveFileTag.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}")
  .asString();

const data = JSON.stringify({
  folder: 'root',
  file: 'doc.md',
  tags: [
    'work',
    'urgent'
  ],
  deleteGlobal: false,
  tagToDelete: 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/file/saveFileTag.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/saveFileTag.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    folder: 'root',
    file: 'doc.md',
    tags: ['work', 'urgent'],
    deleteGlobal: false,
    tagToDelete: null
  }
};

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

const url = '{{baseUrl}}/api/file/saveFileTag.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","file":"doc.md","tags":["work","urgent"],"deleteGlobal":false,"tagToDelete":null}'
};

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/file/saveFileTag.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "root",\n  "file": "doc.md",\n  "tags": [\n    "work",\n    "urgent"\n  ],\n  "deleteGlobal": false,\n  "tagToDelete": null\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/saveFileTag.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/saveFileTag.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({
  folder: 'root',
  file: 'doc.md',
  tags: ['work', 'urgent'],
  deleteGlobal: false,
  tagToDelete: null
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/saveFileTag.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {
    folder: 'root',
    file: 'doc.md',
    tags: ['work', 'urgent'],
    deleteGlobal: false,
    tagToDelete: null
  },
  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/file/saveFileTag.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: 'root',
  file: 'doc.md',
  tags: [
    'work',
    'urgent'
  ],
  deleteGlobal: false,
  tagToDelete: null
});

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/file/saveFileTag.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {
    folder: 'root',
    file: 'doc.md',
    tags: ['work', 'urgent'],
    deleteGlobal: false,
    tagToDelete: null
  }
};

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

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

const url = '{{baseUrl}}/api/file/saveFileTag.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"folder":"root","file":"doc.md","tags":["work","urgent"],"deleteGlobal":false,"tagToDelete":null}'
};

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

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"folder": @"root",
                              @"file": @"doc.md",
                              @"tags": @[ @"work", @"urgent" ],
                              @"deleteGlobal": @NO,
                              @"tagToDelete":  };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/saveFileTag.php"]
                                                       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/file/saveFileTag.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}" in

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

 "{{baseUrl}}/api/file/saveFileTag.php",
  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([
    'folder' => 'root',
    'file' => 'doc.md',
    'tags' => [
        'work',
        'urgent'
    ],
    'deleteGlobal' => null,
    'tagToDelete' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/api/file/saveFileTag.php', [
  'body' => '{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/saveFileTag.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => 'root',
  'file' => 'doc.md',
  'tags' => [
    'work',
    'urgent'
  ],
  'deleteGlobal' => null,
  'tagToDelete' => null
]));

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

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

append(json_encode([
  'folder' => 'root',
  'file' => 'doc.md',
  'tags' => [
    'work',
    'urgent'
  ],
  'deleteGlobal' => null,
  'tagToDelete' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/file/saveFileTag.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/saveFileTag.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/saveFileTag.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}'

import http.client

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

payload = "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/saveFileTag.php", payload, headers)

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

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

import requests

url = "{{baseUrl}}/api/file/saveFileTag.php"

payload = {
    "folder": "root",
    "file": "doc.md",
    "tags": ["work", "urgent"],
    "deleteGlobal": False,
    "tagToDelete": None
}
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/saveFileTag.php"

payload <- "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/saveFileTag.php")

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

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\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/file/saveFileTag.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"folder\": \"root\",\n  \"file\": \"doc.md\",\n  \"tags\": [\n    \"work\",\n    \"urgent\"\n  ],\n  \"deleteGlobal\": false,\n  \"tagToDelete\": null\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "folder": "root",
        "file": "doc.md",
        "tags": ("work", "urgent"),
        "deleteGlobal": false,
        "tagToDelete": json!(null)
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/saveFileTag.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}'

echo '{
  "folder": "root",
  "file": "doc.md",
  "tags": [
    "work",
    "urgent"
  ],
  "deleteGlobal": false,
  "tagToDelete": null
}' |  \
  http POST {{baseUrl}}/api/file/saveFileTag.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "root",\n  "file": "doc.md",\n  "tags": [\n    "work",\n    "urgent"\n  ],\n  "deleteGlobal": false,\n  "tagToDelete": null\n}' \
  --output-document \
  - {{baseUrl}}/api/file/saveFileTag.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = [
  "folder": "root",
  "file": "doc.md",
  "tags": ["work", "urgent"],
  "deleteGlobal": false,
  "tagToDelete": 
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/saveFileTag.php")! 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()

PUT Disable TOTP for the authenticated user

{{baseUrl}}/api/totp_disable.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/totp_disable.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/api/totp_disable.php")

require "http/client"

url = "{{baseUrl}}/api/totp_disable.php"

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/totp_disable.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/totp_disable.php"

	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/totp_disable.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/totp_disable.php"))
    .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/totp_disable.php")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/api/totp_disable.php")
  .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/totp_disable.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'PUT', url: '{{baseUrl}}/api/totp_disable.php'};

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

const url = '{{baseUrl}}/api/totp_disable.php';
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/totp_disable.php',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/totp_disable.php")
  .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/totp_disable.php',
  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/totp_disable.php'};

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/totp_disable.php');

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/totp_disable.php'};

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

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

const url = '{{baseUrl}}/api/totp_disable.php';
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/totp_disable.php"]
                                                       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/totp_disable.php" in

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

 "{{baseUrl}}/api/totp_disable.php",
  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/totp_disable.php');

echo $response->getBody();

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

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

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

setRequestUrl('{{baseUrl}}/api/totp_disable.php');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/totp_disable.php' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/totp_disable.php' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/api/totp_disable.php")

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

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

import requests

url = "{{baseUrl}}/api/totp_disable.php"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/totp_disable.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/totp_disable.php")

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/totp_disable.php') 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/totp_disable.php";

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/totp_disable.php

http PUT {{baseUrl}}/api/totp_disable.php

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/api/totp_disable.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/totp_disable.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": true,
  "message": "TOTP disabled successfully."
}

POST Generate and save a new TOTP recovery code

{{baseUrl}}/api/totp_saveCode.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/totp_saveCode.php");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/totp_saveCode.php")

require "http/client"

url = "{{baseUrl}}/api/totp_saveCode.php"

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/totp_saveCode.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

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

package main

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

func main() {

	url := "{{baseUrl}}/api/totp_saveCode.php"

	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/totp_saveCode.php HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/totp_saveCode.php"))
    .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/totp_saveCode.php")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/totp_saveCode.php")
  .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/totp_saveCode.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'POST', url: '{{baseUrl}}/api/totp_saveCode.php'};

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

const url = '{{baseUrl}}/api/totp_saveCode.php';
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/totp_saveCode.php',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/totp_saveCode.php")
  .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/totp_saveCode.php',
  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/totp_saveCode.php'};

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/totp_saveCode.php');

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/totp_saveCode.php'};

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

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

const url = '{{baseUrl}}/api/totp_saveCode.php';
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/totp_saveCode.php"]
                                                       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/totp_saveCode.php" in

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

 "{{baseUrl}}/api/totp_saveCode.php",
  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/totp_saveCode.php');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/totp_saveCode.php' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/totp_saveCode.php' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/api/totp_saveCode.php")

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

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

import requests

url = "{{baseUrl}}/api/totp_saveCode.php"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/totp_saveCode.php"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/totp_saveCode.php")

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/totp_saveCode.php') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/totp_saveCode.php

http POST {{baseUrl}}/api/totp_saveCode.php

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/api/totp_saveCode.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/totp_saveCode.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "status": "ok",
  "recoveryCode": "ABC123DEF456"
}

POST Recover TOTP

{{baseUrl}}/api/totp_recover.php

BODY json

{
  "recovery_code": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/totp_recover.php");

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  \"recovery_code\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/api/totp_recover.php" {:content-type :json
                                                                 :form-params {:recovery_code ""}})

require "http/client"

url = "{{baseUrl}}/api/totp_recover.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"recovery_code\": \"\"\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/totp_recover.php"),
    Content = new StringContent("{\n  \"recovery_code\": \"\"\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/totp_recover.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"recovery_code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/api/totp_recover.php"

	payload := strings.NewReader("{\n  \"recovery_code\": \"\"\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/totp_recover.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 25

{
  "recovery_code": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/totp_recover.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"recovery_code\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/totp_recover.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"recovery_code\": \"\"\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  \"recovery_code\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/totp_recover.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/api/totp_recover.php")
  .header("content-type", "application/json")
  .body("{\n  \"recovery_code\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  recovery_code: ''
});

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/totp_recover.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/totp_recover.php',
  headers: {'content-type': 'application/json'},
  data: {recovery_code: ''}
};

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

const url = '{{baseUrl}}/api/totp_recover.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"recovery_code":""}'
};

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/totp_recover.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "recovery_code": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"recovery_code\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/totp_recover.php")
  .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/totp_recover.php',
  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({recovery_code: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/totp_recover.php',
  headers: {'content-type': 'application/json'},
  body: {recovery_code: ''},
  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/totp_recover.php');

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

req.type('json');
req.send({
  recovery_code: ''
});

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/totp_recover.php',
  headers: {'content-type': 'application/json'},
  data: {recovery_code: ''}
};

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

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

const url = '{{baseUrl}}/api/totp_recover.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"recovery_code":""}'
};

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 = @{ @"recovery_code": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/totp_recover.php"]
                                                       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/totp_recover.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"recovery_code\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/totp_recover.php",
  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([
    'recovery_code' => ''
  ]),
  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/totp_recover.php', [
  'body' => '{
  "recovery_code": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/totp_recover.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'recovery_code' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'recovery_code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/totp_recover.php');
$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/totp_recover.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "recovery_code": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/totp_recover.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "recovery_code": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"recovery_code\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/totp_recover.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/totp_recover.php"

payload = { "recovery_code": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/totp_recover.php"

payload <- "{\n  \"recovery_code\": \"\"\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/totp_recover.php")

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  \"recovery_code\": \"\"\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/totp_recover.php') do |req|
  req.body = "{\n  \"recovery_code\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/totp_recover.php";

    let payload = json!({"recovery_code": ""});

    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/totp_recover.php \
  --header 'content-type: application/json' \
  --data '{
  "recovery_code": ""
}'

echo '{
  "recovery_code": ""
}' |  \
  http POST {{baseUrl}}/api/totp_recover.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "recovery_code": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/totp_recover.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["recovery_code": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/totp_recover.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "status": "ok"
}

GET Set up TOTP and generate a QR code

{{baseUrl}}/api/totp_setup.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/totp_setup.php");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/totp_setup.php")

require "http/client"

url = "{{baseUrl}}/api/totp_setup.php"

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/totp_setup.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/totp_setup.php");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/totp_setup.php"

	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/totp_setup.php HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/totp_setup.php")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/totp_setup.php"))
    .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/totp_setup.php")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/totp_setup.php")
  .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/totp_setup.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/totp_setup.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/totp_setup.php';
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/totp_setup.php',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/totp_setup.php")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/totp_setup.php',
  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/totp_setup.php'};

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/totp_setup.php');

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/totp_setup.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/totp_setup.php';
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/totp_setup.php"]
                                                       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/totp_setup.php" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/totp_setup.php",
  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/totp_setup.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/totp_setup.php');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/totp_setup.php');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/totp_setup.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/totp_setup.php' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/totp_setup.php")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/totp_setup.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/totp_setup.php"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/totp_setup.php")

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/totp_setup.php') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/totp_setup.php";

    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/totp_setup.php

http GET {{baseUrl}}/api/totp_setup.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/totp_setup.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/totp_setup.php")! 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 Verify TOTP code

{{baseUrl}}/api/totp_verify.php

BODY json

{
  "totp_code": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/totp_verify.php");

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  \"totp_code\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/totp_verify.php" {:content-type :json
                                                                :form-params {:totp_code ""}})

require "http/client"

url = "{{baseUrl}}/api/totp_verify.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"totp_code\": \"\"\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/totp_verify.php"),
    Content = new StringContent("{\n  \"totp_code\": \"\"\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/totp_verify.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"totp_code\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/totp_verify.php"

	payload := strings.NewReader("{\n  \"totp_code\": \"\"\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/totp_verify.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "totp_code": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/totp_verify.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"totp_code\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/totp_verify.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"totp_code\": \"\"\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  \"totp_code\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/totp_verify.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/totp_verify.php")
  .header("content-type", "application/json")
  .body("{\n  \"totp_code\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  totp_code: ''
});

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/totp_verify.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/totp_verify.php',
  headers: {'content-type': 'application/json'},
  data: {totp_code: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/totp_verify.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"totp_code":""}'
};

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/totp_verify.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "totp_code": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"totp_code\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/totp_verify.php")
  .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/totp_verify.php',
  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({totp_code: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/totp_verify.php',
  headers: {'content-type': 'application/json'},
  body: {totp_code: ''},
  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/totp_verify.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  totp_code: ''
});

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/totp_verify.php',
  headers: {'content-type': 'application/json'},
  data: {totp_code: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/totp_verify.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"totp_code":""}'
};

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 = @{ @"totp_code": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/totp_verify.php"]
                                                       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/totp_verify.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"totp_code\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/totp_verify.php",
  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([
    'totp_code' => ''
  ]),
  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/totp_verify.php', [
  'body' => '{
  "totp_code": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/totp_verify.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'totp_code' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'totp_code' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/totp_verify.php');
$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/totp_verify.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "totp_code": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/totp_verify.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "totp_code": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"totp_code\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/totp_verify.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/totp_verify.php"

payload = { "totp_code": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/totp_verify.php"

payload <- "{\n  \"totp_code\": \"\"\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/totp_verify.php")

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  \"totp_code\": \"\"\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/totp_verify.php') do |req|
  req.body = "{\n  \"totp_code\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/totp_verify.php";

    let payload = json!({"totp_code": ""});

    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/totp_verify.php \
  --header 'content-type: application/json' \
  --data '{
  "totp_code": ""
}'

echo '{
  "totp_code": ""
}' |  \
  http POST {{baseUrl}}/api/totp_verify.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "totp_code": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/totp_verify.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["totp_code": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/totp_verify.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "status": "ok",
  "message": "Login successful"
}

GET List items in Trash (admin only)

{{baseUrl}}/api/file/getTrashItems.php

HEADERS

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/getTrashItems.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/file/getTrashItems.php" {:headers {:phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/file/getTrashItems.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/file/getTrashItems.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/file/getTrashItems.php");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/file/getTrashItems.php"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("phpsessid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/file/getTrashItems.php HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/file/getTrashItems.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/getTrashItems.php"))
    .header("phpsessid", "{{apiKey}}")
    .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/file/getTrashItems.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/file/getTrashItems.php")
  .header("phpsessid", "{{apiKey}}")
  .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/file/getTrashItems.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/file/getTrashItems.php',
  headers: {phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/file/getTrashItems.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/file/getTrashItems.php',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/file/getTrashItems.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/getTrashItems.php',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/file/getTrashItems.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/file/getTrashItems.php');

req.headers({
  phpsessid: '{{apiKey}}'
});

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/file/getTrashItems.php',
  headers: {phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/file/getTrashItems.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/getTrashItems.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/file/getTrashItems.php" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/file/getTrashItems.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/file/getTrashItems.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/getTrashItems.php');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/file/getTrashItems.php');
$request->setRequestMethod('GET');
$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/getTrashItems.php' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/getTrashItems.php' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/file/getTrashItems.php", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/file/getTrashItems.php"

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/getTrashItems.php"

response <- VERB("GET", url, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/getTrashItems.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/file/getTrashItems.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/file/getTrashItems.php";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/file/getTrashItems.php \
  --header 'phpsessid: {{apiKey}}'

http GET {{baseUrl}}/api/file/getTrashItems.php \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/file/getTrashItems.php

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/getTrashItems.php")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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 Permanently delete Trash items (admin only)

{{baseUrl}}/api/file/deleteTrashFiles.php

HEADERS

X-CSRF-Token

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/deleteTrashFiles.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/file/deleteTrashFiles.php" {:headers {:x-csrf-token ""
                                                                                    :phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/file/deleteTrashFiles.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/file/deleteTrashFiles.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/file/deleteTrashFiles.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/file/deleteTrashFiles.php"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/file/deleteTrashFiles.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/deleteTrashFiles.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/deleteTrashFiles.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .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/file/deleteTrashFiles.php")
  .post(null)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/deleteTrashFiles.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .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/file/deleteTrashFiles.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/deleteTrashFiles.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/file/deleteTrashFiles.php';
const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};

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/file/deleteTrashFiles.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/file/deleteTrashFiles.php")
  .post(null)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/file/deleteTrashFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}'
  }
};

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/file/deleteTrashFiles.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

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/file/deleteTrashFiles.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}'
});

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/file/deleteTrashFiles.php',
  headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/file/deleteTrashFiles.php';
const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/deleteTrashFiles.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

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/file/deleteTrashFiles.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/file/deleteTrashFiles.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/file/deleteTrashFiles.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/deleteTrashFiles.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/file/deleteTrashFiles.php');
$request->setRequestMethod('POST');
$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/deleteTrashFiles.php' -Method POST -Headers $headers

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/deleteTrashFiles.php' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}"
}

conn.request("POST", "/baseUrl/api/file/deleteTrashFiles.php", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/file/deleteTrashFiles.php"

headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}"
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/deleteTrashFiles.php"

response <- VERB("POST", url, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/deleteTrashFiles.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/file/deleteTrashFiles.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/file/deleteTrashFiles.php";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/file/deleteTrashFiles.php \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: '

http POST {{baseUrl}}/api/file/deleteTrashFiles.php \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/file/deleteTrashFiles.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}"
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/deleteTrashFiles.php")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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 Restore files from Trash (admin only)

{{baseUrl}}/api/file/restoreFiles.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY json

{
  "files": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/file/restoreFiles.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/file/restoreFiles.php" {:headers {:x-csrf-token ""
                                                                                :phpsessid "{{apiKey}}"}
                                                                      :content-type :json
                                                                      :form-params {:files ["trash/12345.json"]}})

require "http/client"

url = "{{baseUrl}}/api/file/restoreFiles.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "application/json"
}
reqBody = "{\n  \"files\": [\n    \"trash/12345.json\"\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/file/restoreFiles.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new StringContent("{\n  \"files\": [\n    \"trash/12345.json\"\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/file/restoreFiles.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/file/restoreFiles.php"

	payload := strings.NewReader("{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	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/file/restoreFiles.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: application/json
Host: example.com
Content-Length: 43

{
  "files": [
    "trash/12345.json"
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/file/restoreFiles.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/file/restoreFiles.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"files\": [\n    \"trash/12345.json\"\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  \"files\": [\n    \"trash/12345.json\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/file/restoreFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/file/restoreFiles.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "application/json")
  .body("{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  files: [
    'trash/12345.json'
  ]
});

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/file/restoreFiles.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/restoreFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {files: ['trash/12345.json']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/file/restoreFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"files":["trash/12345.json"]}'
};

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/file/restoreFiles.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "files": [\n    "trash/12345.json"\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  \"files\": [\n    \"trash/12345.json\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/file/restoreFiles.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .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/file/restoreFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    '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({files: ['trash/12345.json']}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/file/restoreFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: {files: ['trash/12345.json']},
  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/file/restoreFiles.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  files: [
    'trash/12345.json'
  ]
});

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/file/restoreFiles.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  data: {files: ['trash/12345.json']}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/file/restoreFiles.php';
const options = {
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'application/json'
  },
  body: '{"files":["trash/12345.json"]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"files": @[ @"trash/12345.json" ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/file/restoreFiles.php"]
                                                       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/file/restoreFiles.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/file/restoreFiles.php",
  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([
    'files' => [
        'trash/12345.json'
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/file/restoreFiles.php', [
  'body' => '{
  "files": [
    "trash/12345.json"
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/file/restoreFiles.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'files' => [
    'trash/12345.json'
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'files' => [
    'trash/12345.json'
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/file/restoreFiles.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/file/restoreFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "files": [
    "trash/12345.json"
  ]
}'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/file/restoreFiles.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "files": [
    "trash/12345.json"
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/file/restoreFiles.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/file/restoreFiles.php"

payload = { "files": ["trash/12345.json"] }
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/file/restoreFiles.php"

payload <- "{\n  \"files\": [\n    \"trash/12345.json\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/file/restoreFiles.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'application/json'
request.body = "{\n  \"files\": [\n    \"trash/12345.json\"\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/file/restoreFiles.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "{\n  \"files\": [\n    \"trash/12345.json\"\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/file/restoreFiles.php";

    let payload = json!({"files": ("trash/12345.json")});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());
    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/file/restoreFiles.php \
  --header 'content-type: application/json' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --data '{
  "files": [
    "trash/12345.json"
  ]
}'

echo '{
  "files": [
    "trash/12345.json"
  ]
}' |  \
  http POST {{baseUrl}}/api/file/restoreFiles.php \
  content-type:application/json \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: application/json' \
  --body-data '{\n  "files": [\n    "trash/12345.json"\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/file/restoreFiles.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "application/json"
]
let parameters = ["files": ["trash/12345.json"]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/file/restoreFiles.php")! 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 Remove temporary chunk directory

{{baseUrl}}/api/upload/removeChunks.php

BODY json

{
  "folder": "",
  "csrf_token": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/upload/removeChunks.php");

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  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/upload/removeChunks.php" {:content-type :json
                                                                        :form-params {:folder ""
                                                                                      :csrf_token ""}})

require "http/client"

url = "{{baseUrl}}/api/upload/removeChunks.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\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/upload/removeChunks.php"),
    Content = new StringContent("{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\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/upload/removeChunks.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/upload/removeChunks.php"

	payload := strings.NewReader("{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\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/upload/removeChunks.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 38

{
  "folder": "",
  "csrf_token": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/upload/removeChunks.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/upload/removeChunks.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\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  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/upload/removeChunks.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/upload/removeChunks.php")
  .header("content-type", "application/json")
  .body("{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  folder: '',
  csrf_token: ''
});

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/upload/removeChunks.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/upload/removeChunks.php',
  headers: {'content-type': 'application/json'},
  data: {folder: '', csrf_token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/upload/removeChunks.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"folder":"","csrf_token":""}'
};

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/upload/removeChunks.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "folder": "",\n  "csrf_token": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/upload/removeChunks.php")
  .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/upload/removeChunks.php',
  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({folder: '', csrf_token: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/upload/removeChunks.php',
  headers: {'content-type': 'application/json'},
  body: {folder: '', csrf_token: ''},
  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/upload/removeChunks.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  folder: '',
  csrf_token: ''
});

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/upload/removeChunks.php',
  headers: {'content-type': 'application/json'},
  data: {folder: '', csrf_token: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/upload/removeChunks.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"folder":"","csrf_token":""}'
};

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 = @{ @"folder": @"",
                              @"csrf_token": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/upload/removeChunks.php"]
                                                       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/upload/removeChunks.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/upload/removeChunks.php",
  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([
    'folder' => '',
    'csrf_token' => ''
  ]),
  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/upload/removeChunks.php', [
  'body' => '{
  "folder": "",
  "csrf_token": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/upload/removeChunks.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'folder' => '',
  'csrf_token' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'folder' => '',
  'csrf_token' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/upload/removeChunks.php');
$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/upload/removeChunks.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "csrf_token": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/upload/removeChunks.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "folder": "",
  "csrf_token": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/upload/removeChunks.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/upload/removeChunks.php"

payload = {
    "folder": "",
    "csrf_token": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/upload/removeChunks.php"

payload <- "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\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/upload/removeChunks.php")

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  \"folder\": \"\",\n  \"csrf_token\": \"\"\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/upload/removeChunks.php') do |req|
  req.body = "{\n  \"folder\": \"\",\n  \"csrf_token\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/upload/removeChunks.php";

    let payload = json!({
        "folder": "",
        "csrf_token": ""
    });

    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/upload/removeChunks.php \
  --header 'content-type: application/json' \
  --data '{
  "folder": "",
  "csrf_token": ""
}'

echo '{
  "folder": "",
  "csrf_token": ""
}' |  \
  http POST {{baseUrl}}/api/upload/removeChunks.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "folder": "",\n  "csrf_token": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/upload/removeChunks.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "folder": "",
  "csrf_token": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/upload/removeChunks.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": true,
  "message": "Temporary folder removed."
}

POST Add a new user

{{baseUrl}}/api/addUser.php

BODY json

{
  "username": "",
  "password": "",
  "isAdmin": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/addUser.php");

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  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/addUser.php" {:content-type :json
                                                            :form-params {:username ""
                                                                          :password ""
                                                                          :isAdmin false}})

require "http/client"

url = "{{baseUrl}}/api/addUser.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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/addUser.php"),
    Content = new StringContent("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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/addUser.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/addUser.php"

	payload := strings.NewReader("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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/addUser.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "username": "",
  "password": "",
  "isAdmin": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/addUser.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/addUser.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/addUser.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/addUser.php")
  .header("content-type", "application/json")
  .body("{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}")
  .asString();

const data = JSON.stringify({
  username: '',
  password: '',
  isAdmin: false
});

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/addUser.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/addUser.php',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: '', isAdmin: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/addUser.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":"","isAdmin":false}'
};

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/addUser.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "username": "",\n  "password": "",\n  "isAdmin": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/addUser.php")
  .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/addUser.php',
  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({username: '', password: '', isAdmin: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/addUser.php',
  headers: {'content-type': 'application/json'},
  body: {username: '', password: '', isAdmin: false},
  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/addUser.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  username: '',
  password: '',
  isAdmin: false
});

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/addUser.php',
  headers: {'content-type': 'application/json'},
  data: {username: '', password: '', isAdmin: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/addUser.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"username":"","password":"","isAdmin":false}'
};

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 = @{ @"username": @"",
                              @"password": @"",
                              @"isAdmin": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/addUser.php"]
                                                       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/addUser.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/addUser.php",
  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([
    'username' => '',
    'password' => '',
    'isAdmin' => null
  ]),
  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/addUser.php', [
  'body' => '{
  "username": "",
  "password": "",
  "isAdmin": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/addUser.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'username' => '',
  'password' => '',
  'isAdmin' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'username' => '',
  'password' => '',
  'isAdmin' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/addUser.php');
$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/addUser.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": "",
  "isAdmin": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/addUser.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "username": "",
  "password": "",
  "isAdmin": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/addUser.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/addUser.php"

payload = {
    "username": "",
    "password": "",
    "isAdmin": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/addUser.php"

payload <- "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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/addUser.php")

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  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\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/addUser.php') do |req|
  req.body = "{\n  \"username\": \"\",\n  \"password\": \"\",\n  \"isAdmin\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/addUser.php";

    let payload = json!({
        "username": "",
        "password": "",
        "isAdmin": false
    });

    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/addUser.php \
  --header 'content-type: application/json' \
  --data '{
  "username": "",
  "password": "",
  "isAdmin": false
}'

echo '{
  "username": "",
  "password": "",
  "isAdmin": false
}' |  \
  http POST {{baseUrl}}/api/addUser.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "username": "",\n  "password": "",\n  "isAdmin": false\n}' \
  --output-document \
  - {{baseUrl}}/api/addUser.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "username": "",
  "password": "",
  "isAdmin": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/addUser.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "User added successfully"
}

POST Change user password

{{baseUrl}}/api/changePassword.php

BODY json

{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/changePassword.php");

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  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/changePassword.php" {:content-type :json
                                                                   :form-params {:oldPassword ""
                                                                                 :newPassword ""
                                                                                 :confirmPassword ""}})

require "http/client"

url = "{{baseUrl}}/api/changePassword.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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/changePassword.php"),
    Content = new StringContent("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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/changePassword.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/changePassword.php"

	payload := strings.NewReader("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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/changePassword.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 69

{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/changePassword.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/changePassword.php"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/changePassword.php")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/changePassword.php")
  .header("content-type", "application/json")
  .body("{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  oldPassword: '',
  newPassword: '',
  confirmPassword: ''
});

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/changePassword.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/changePassword.php',
  headers: {'content-type': 'application/json'},
  data: {oldPassword: '', newPassword: '', confirmPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/changePassword.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"oldPassword":"","newPassword":"","confirmPassword":""}'
};

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/changePassword.php',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "oldPassword": "",\n  "newPassword": "",\n  "confirmPassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/changePassword.php")
  .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/changePassword.php',
  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({oldPassword: '', newPassword: '', confirmPassword: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/changePassword.php',
  headers: {'content-type': 'application/json'},
  body: {oldPassword: '', newPassword: '', confirmPassword: ''},
  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/changePassword.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  oldPassword: '',
  newPassword: '',
  confirmPassword: ''
});

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/changePassword.php',
  headers: {'content-type': 'application/json'},
  data: {oldPassword: '', newPassword: '', confirmPassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/changePassword.php';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"oldPassword":"","newPassword":"","confirmPassword":""}'
};

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 = @{ @"oldPassword": @"",
                              @"newPassword": @"",
                              @"confirmPassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/changePassword.php"]
                                                       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/changePassword.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/changePassword.php",
  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([
    'oldPassword' => '',
    'newPassword' => '',
    'confirmPassword' => ''
  ]),
  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/changePassword.php', [
  'body' => '{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/changePassword.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'oldPassword' => '',
  'newPassword' => '',
  'confirmPassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'oldPassword' => '',
  'newPassword' => '',
  'confirmPassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/changePassword.php');
$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/changePassword.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/changePassword.php' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/api/changePassword.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/changePassword.php"

payload = {
    "oldPassword": "",
    "newPassword": "",
    "confirmPassword": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/changePassword.php"

payload <- "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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/changePassword.php")

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  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\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/changePassword.php') do |req|
  req.body = "{\n  \"oldPassword\": \"\",\n  \"newPassword\": \"\",\n  \"confirmPassword\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/changePassword.php";

    let payload = json!({
        "oldPassword": "",
        "newPassword": "",
        "confirmPassword": ""
    });

    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/changePassword.php \
  --header 'content-type: application/json' \
  --data '{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}'

echo '{
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
}' |  \
  http POST {{baseUrl}}/api/changePassword.php \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "oldPassword": "",\n  "newPassword": "",\n  "confirmPassword": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/changePassword.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "oldPassword": "",
  "newPassword": "",
  "confirmPassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/changePassword.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "Password updated successfully."
}

GET Get the currently authenticated user's profile

{{baseUrl}}/api/profile/getCurrentUser.php

HEADERS

PHPSESSID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/profile/getCurrentUser.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/profile/getCurrentUser.php" {:headers {:phpsessid "{{apiKey}}"}})

require "http/client"

url = "{{baseUrl}}/api/profile/getCurrentUser.php"
headers = HTTP::Headers{
  "phpsessid" => "{{apiKey}}"
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/profile/getCurrentUser.php"),
    Headers =
    {
        { "phpsessid", "{{apiKey}}" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/profile/getCurrentUser.php");
var request = new RestRequest("", Method.Get);
request.AddHeader("phpsessid", "{{apiKey}}");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/profile/getCurrentUser.php"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("phpsessid", "{{apiKey}}")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/profile/getCurrentUser.php HTTP/1.1
Phpsessid: {{apiKey}}
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/profile/getCurrentUser.php")
  .setHeader("phpsessid", "{{apiKey}}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/profile/getCurrentUser.php"))
    .header("phpsessid", "{{apiKey}}")
    .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/profile/getCurrentUser.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/profile/getCurrentUser.php")
  .header("phpsessid", "{{apiKey}}")
  .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/profile/getCurrentUser.php');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/profile/getCurrentUser.php',
  headers: {phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/profile/getCurrentUser.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

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/profile/getCurrentUser.php',
  method: 'GET',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/profile/getCurrentUser.php")
  .get()
  .addHeader("phpsessid", "{{apiKey}}")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/profile/getCurrentUser.php',
  headers: {
    phpsessid: '{{apiKey}}'
  }
};

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/profile/getCurrentUser.php',
  headers: {phpsessid: '{{apiKey}}'}
};

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/profile/getCurrentUser.php');

req.headers({
  phpsessid: '{{apiKey}}'
});

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/profile/getCurrentUser.php',
  headers: {phpsessid: '{{apiKey}}'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/profile/getCurrentUser.php';
const options = {method: 'GET', headers: {phpsessid: '{{apiKey}}'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"phpsessid": @"{{apiKey}}" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/profile/getCurrentUser.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

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/profile/getCurrentUser.php" in
let headers = Header.add (Header.init ()) "phpsessid" "{{apiKey}}" in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/profile/getCurrentUser.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "phpsessid: {{apiKey}}"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/profile/getCurrentUser.php', [
  'headers' => [
    'phpsessid' => '{{apiKey}}',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/profile/getCurrentUser.php');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/profile/getCurrentUser.php');
$request->setRequestMethod('GET');
$request->setHeaders([
  'phpsessid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/profile/getCurrentUser.php' -Method GET -Headers $headers

$headers=@{}
$headers.Add("phpsessid", "{{apiKey}}")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/profile/getCurrentUser.php' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = { 'phpsessid': "{{apiKey}}" }

conn.request("GET", "/baseUrl/api/profile/getCurrentUser.php", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/profile/getCurrentUser.php"

headers = {"phpsessid": "{{apiKey}}"}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/profile/getCurrentUser.php"

response <- VERB("GET", url, add_headers('phpsessid' = '{{apiKey}}'), content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/profile/getCurrentUser.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["phpsessid"] = '{{apiKey}}'

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/profile/getCurrentUser.php') do |req|
  req.headers['phpsessid'] = '{{apiKey}}'
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/profile/getCurrentUser.php";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/profile/getCurrentUser.php \
  --header 'phpsessid: {{apiKey}}'

http GET {{baseUrl}}/api/profile/getCurrentUser.php \
  phpsessid:'{{apiKey}}'

wget --quiet \
  --method GET \
  --header 'phpsessid: {{apiKey}}' \
  --output-document \
  - {{baseUrl}}/api/profile/getCurrentUser.php

import Foundation

let headers = ["phpsessid": "{{apiKey}}"]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/profile/getCurrentUser.php")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": "Unauthorized"
}

DELETE Remove a user

{{baseUrl}}/api/removeUser.php

BODY json

{
  "username": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/removeUser.php");

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  \"username\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/removeUser.php" {:content-type :json
                                                                 :form-params {:username ""}})

require "http/client"

url = "{{baseUrl}}/api/removeUser.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"username\": \"\"\n}"

response = HTTP::Client.delete url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/removeUser.php"),
    Content = new StringContent("{\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/removeUser.php");
var request = new RestRequest("", Method.Delete);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"username\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/removeUser.php"

	payload := strings.NewReader("{\n  \"username\": \"\"\n}")

	req, _ := http.NewRequest("DELETE", 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))

}

DELETE /baseUrl/api/removeUser.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "username": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/removeUser.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"username\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/removeUser.php"))
    .header("content-type", "application/json")
    .method("DELETE", HttpRequest.BodyPublishers.ofString("{\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  \"username\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/removeUser.php")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/removeUser.php")
  .header("content-type", "application/json")
  .body("{\n  \"username\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  username: ''
});

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/removeUser.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/removeUser.php',
  headers: {'content-type': 'application/json'},
  data: {username: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/removeUser.php';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"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/removeUser.php',
  method: 'DELETE',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\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  \"username\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/removeUser.php")
  .delete(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/removeUser.php',
  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({username: ''}));
req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/removeUser.php',
  headers: {'content-type': 'application/json'},
  body: {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('DELETE', '{{baseUrl}}/api/removeUser.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  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: 'DELETE',
  url: '{{baseUrl}}/api/removeUser.php',
  headers: {'content-type': 'application/json'},
  data: {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/removeUser.php';
const options = {
  method: 'DELETE',
  headers: {'content-type': 'application/json'},
  body: '{"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 = @{ @"username": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/removeUser.php"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[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/removeUser.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"username\": \"\"\n}" in

Client.call ~headers ~body `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/removeUser.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_POSTFIELDS => json_encode([
    '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('DELETE', '{{baseUrl}}/api/removeUser.php', [
  'body' => '{
  "username": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/removeUser.php');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'username' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'username' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/removeUser.php');
$request->setRequestMethod('DELETE');
$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/removeUser.php' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "username": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/removeUser.php' -Method DELETE -Headers $headers -ContentType 'application/json' -Body '{
  "username": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"username\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("DELETE", "/baseUrl/api/removeUser.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/removeUser.php"

payload = { "username": "" }
headers = {"content-type": "application/json"}

response = requests.delete(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/removeUser.php"

payload <- "{\n  \"username\": \"\"\n}"

encode <- "json"

response <- VERB("DELETE", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/removeUser.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["content-type"] = 'application/json'
request.body = "{\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.delete('/baseUrl/api/removeUser.php') do |req|
  req.body = "{\n  \"username\": \"\"\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/removeUser.php";

    let payload = json!({"username": ""});

    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("DELETE").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/removeUser.php \
  --header 'content-type: application/json' \
  --data '{
  "username": ""
}'

echo '{
  "username": ""
}' |  \
  http DELETE {{baseUrl}}/api/removeUser.php \
  content-type:application/json

wget --quiet \
  --method DELETE \
  --header 'content-type: application/json' \
  --body-data '{\n  "username": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/removeUser.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["username": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/removeUser.php")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "User removed successfully"
}

GET Retrieve a list of users

{{baseUrl}}/api/getUsers.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/getUsers.php");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/getUsers.php")

require "http/client"

url = "{{baseUrl}}/api/getUsers.php"

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/getUsers.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/getUsers.php");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/getUsers.php"

	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/getUsers.php HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/getUsers.php")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/getUsers.php"))
    .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/getUsers.php")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/getUsers.php")
  .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/getUsers.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/getUsers.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/getUsers.php';
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/getUsers.php',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/getUsers.php")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/getUsers.php',
  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/getUsers.php'};

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/getUsers.php');

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/getUsers.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/getUsers.php';
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/getUsers.php"]
                                                       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/getUsers.php" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/getUsers.php",
  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/getUsers.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/getUsers.php');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/getUsers.php');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/getUsers.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/getUsers.php' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/getUsers.php")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/getUsers.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/getUsers.php"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/getUsers.php")

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/getUsers.php') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/getUsers.php";

    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/getUsers.php

http GET {{baseUrl}}/api/getUsers.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/getUsers.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/getUsers.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "username": "johndoe",
    "role": "admin"
  }
]

GET Retrieve user permissions

{{baseUrl}}/api/getUserPermissions.php

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/getUserPermissions.php");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/getUserPermissions.php")

require "http/client"

url = "{{baseUrl}}/api/getUserPermissions.php"

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/getUserPermissions.php"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/getUserPermissions.php");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/getUserPermissions.php"

	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/getUserPermissions.php HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/getUserPermissions.php")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/getUserPermissions.php"))
    .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/getUserPermissions.php")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/getUserPermissions.php")
  .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/getUserPermissions.php');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/api/getUserPermissions.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/getUserPermissions.php';
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/getUserPermissions.php',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/getUserPermissions.php")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/getUserPermissions.php',
  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/getUserPermissions.php'};

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/getUserPermissions.php');

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/getUserPermissions.php'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/getUserPermissions.php';
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/getUserPermissions.php"]
                                                       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/getUserPermissions.php" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/getUserPermissions.php",
  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/getUserPermissions.php');

echo $response->getBody();

setUrl('{{baseUrl}}/api/getUserPermissions.php');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/getUserPermissions.php');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/getUserPermissions.php' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/getUserPermissions.php' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/api/getUserPermissions.php")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/getUserPermissions.php"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/getUserPermissions.php"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/getUserPermissions.php")

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/getUserPermissions.php') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/getUserPermissions.php";

    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/getUserPermissions.php

http GET {{baseUrl}}/api/getUserPermissions.php

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/api/getUserPermissions.php

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/getUserPermissions.php")! 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 Update user panel settings

{{baseUrl}}/api/updateUserPanel.php

BODY json

{
  "totp_enabled": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/updateUserPanel.php");

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  \"totp_enabled\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/updateUserPanel.php" {:content-type :json
                                                                   :form-params {:totp_enabled false}})

require "http/client"

url = "{{baseUrl}}/api/updateUserPanel.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"totp_enabled\": false\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/updateUserPanel.php"),
    Content = new StringContent("{\n  \"totp_enabled\": false\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/updateUserPanel.php");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"totp_enabled\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/updateUserPanel.php"

	payload := strings.NewReader("{\n  \"totp_enabled\": false\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/updateUserPanel.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 27

{
  "totp_enabled": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/updateUserPanel.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"totp_enabled\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/updateUserPanel.php"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"totp_enabled\": false\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  \"totp_enabled\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/updateUserPanel.php")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/updateUserPanel.php")
  .header("content-type", "application/json")
  .body("{\n  \"totp_enabled\": false\n}")
  .asString();

const data = JSON.stringify({
  totp_enabled: false
});

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/updateUserPanel.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/updateUserPanel.php',
  headers: {'content-type': 'application/json'},
  data: {totp_enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/updateUserPanel.php';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"totp_enabled":false}'
};

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/updateUserPanel.php',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "totp_enabled": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"totp_enabled\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/updateUserPanel.php")
  .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/updateUserPanel.php',
  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({totp_enabled: false}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/updateUserPanel.php',
  headers: {'content-type': 'application/json'},
  body: {totp_enabled: false},
  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/updateUserPanel.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  totp_enabled: false
});

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/updateUserPanel.php',
  headers: {'content-type': 'application/json'},
  data: {totp_enabled: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/updateUserPanel.php';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"totp_enabled":false}'
};

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 = @{ @"totp_enabled": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/updateUserPanel.php"]
                                                       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/updateUserPanel.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"totp_enabled\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/updateUserPanel.php",
  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([
    'totp_enabled' => null
  ]),
  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/updateUserPanel.php', [
  'body' => '{
  "totp_enabled": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/updateUserPanel.php');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'totp_enabled' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'totp_enabled' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/updateUserPanel.php');
$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/updateUserPanel.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "totp_enabled": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/updateUserPanel.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "totp_enabled": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"totp_enabled\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/updateUserPanel.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/updateUserPanel.php"

payload = { "totp_enabled": False }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/updateUserPanel.php"

payload <- "{\n  \"totp_enabled\": false\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/updateUserPanel.php")

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  \"totp_enabled\": false\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/updateUserPanel.php') do |req|
  req.body = "{\n  \"totp_enabled\": false\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/updateUserPanel.php";

    let payload = json!({"totp_enabled": false});

    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/updateUserPanel.php \
  --header 'content-type: application/json' \
  --data '{
  "totp_enabled": false
}'

echo '{
  "totp_enabled": false
}' |  \
  http PUT {{baseUrl}}/api/updateUserPanel.php \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "totp_enabled": false\n}' \
  --output-document \
  - {{baseUrl}}/api/updateUserPanel.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["totp_enabled": false] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/updateUserPanel.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "User panel updated: TOTP disabled"
}

PUT Update user permissions

{{baseUrl}}/api/updateUserPermissions.php

BODY json

{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/updateUserPermissions.php");

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  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/updateUserPermissions.php" {:content-type :json
                                                                         :form-params {:permissions [{:username ""
                                                                                                      :folderOnly false
                                                                                                      :readOnly false
                                                                                                      :disableUpload false}]}})

require "http/client"

url = "{{baseUrl}}/api/updateUserPermissions.php"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\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/updateUserPermissions.php"),
    Content = new StringContent("{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\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/updateUserPermissions.php");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/updateUserPermissions.php"

	payload := strings.NewReader("{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\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/updateUserPermissions.php HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 141

{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/updateUserPermissions.php")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/updateUserPermissions.php"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\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  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/updateUserPermissions.php")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/updateUserPermissions.php")
  .header("content-type", "application/json")
  .body("{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  permissions: [
    {
      username: '',
      folderOnly: false,
      readOnly: false,
      disableUpload: false
    }
  ]
});

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/updateUserPermissions.php');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/updateUserPermissions.php',
  headers: {'content-type': 'application/json'},
  data: {
    permissions: [{username: '', folderOnly: false, readOnly: false, disableUpload: false}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/updateUserPermissions.php';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[{"username":"","folderOnly":false,"readOnly":false,"disableUpload":false}]}'
};

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/updateUserPermissions.php',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "permissions": [\n    {\n      "username": "",\n      "folderOnly": false,\n      "readOnly": false,\n      "disableUpload": false\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  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/updateUserPermissions.php")
  .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/updateUserPermissions.php',
  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({
  permissions: [{username: '', folderOnly: false, readOnly: false, disableUpload: false}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/updateUserPermissions.php',
  headers: {'content-type': 'application/json'},
  body: {
    permissions: [{username: '', folderOnly: false, readOnly: false, disableUpload: false}]
  },
  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/updateUserPermissions.php');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  permissions: [
    {
      username: '',
      folderOnly: false,
      readOnly: false,
      disableUpload: false
    }
  ]
});

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/updateUserPermissions.php',
  headers: {'content-type': 'application/json'},
  data: {
    permissions: [{username: '', folderOnly: false, readOnly: false, disableUpload: false}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/updateUserPermissions.php';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"permissions":[{"username":"","folderOnly":false,"readOnly":false,"disableUpload":false}]}'
};

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 = @{ @"permissions": @[ @{ @"username": @"", @"folderOnly": @NO, @"readOnly": @NO, @"disableUpload": @NO } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/updateUserPermissions.php"]
                                                       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/updateUserPermissions.php" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/updateUserPermissions.php",
  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([
    'permissions' => [
        [
                'username' => '',
                'folderOnly' => null,
                'readOnly' => null,
                'disableUpload' => null
        ]
    ]
  ]),
  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/updateUserPermissions.php', [
  'body' => '{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/updateUserPermissions.php');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'permissions' => [
    [
        'username' => '',
        'folderOnly' => null,
        'readOnly' => null,
        'disableUpload' => null
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'permissions' => [
    [
        'username' => '',
        'folderOnly' => null,
        'readOnly' => null,
        'disableUpload' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/updateUserPermissions.php');
$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/updateUserPermissions.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/updateUserPermissions.php' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/api/updateUserPermissions.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/updateUserPermissions.php"

payload = { "permissions": [
        {
            "username": "",
            "folderOnly": False,
            "readOnly": False,
            "disableUpload": False
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/updateUserPermissions.php"

payload <- "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\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/updateUserPermissions.php")

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  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\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.put('/baseUrl/api/updateUserPermissions.php') do |req|
  req.body = "{\n  \"permissions\": [\n    {\n      \"username\": \"\",\n      \"folderOnly\": false,\n      \"readOnly\": false,\n      \"disableUpload\": false\n    }\n  ]\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/updateUserPermissions.php";

    let payload = json!({"permissions": (
            json!({
                "username": "",
                "folderOnly": false,
                "readOnly": false,
                "disableUpload": false
            })
        )});

    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/updateUserPermissions.php \
  --header 'content-type: application/json' \
  --data '{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}'

echo '{
  "permissions": [
    {
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    }
  ]
}' |  \
  http PUT {{baseUrl}}/api/updateUserPermissions.php \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "permissions": [\n    {\n      "username": "",\n      "folderOnly": false,\n      "readOnly": false,\n      "disableUpload": false\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/updateUserPermissions.php

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["permissions": [
    [
      "username": "",
      "folderOnly": false,
      "readOnly": false,
      "disableUpload": false
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/updateUserPermissions.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": "User permissions updated successfully."
}

POST Upload or replace the current user's profile picture

{{baseUrl}}/api/profile/uploadPicture.php

HEADERS

X-CSRF-Token

PHPSESSID

BODY multipartForm

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/profile/uploadPicture.php");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-csrf-token: ");
headers = curl_slist_append(headers, "phpsessid: {{apiKey}}");
headers = curl_slist_append(headers, "content-type: multipart/form-data; boundary=---011000010111000001101001");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/profile/uploadPicture.php" {:headers {:x-csrf-token ""
                                                                                    :phpsessid "{{apiKey}}"}
                                                                          :multipart [{:name "profile_picture"
                                                                                       :content ""}]})

require "http/client"

url = "{{baseUrl}}/api/profile/uploadPicture.php"
headers = HTTP::Headers{
  "x-csrf-token" => ""
  "phpsessid" => "{{apiKey}}"
  "content-type" => "multipart/form-data; boundary=---011000010111000001101001"
}
reqBody = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\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/profile/uploadPicture.php"),
    Headers =
    {
        { "x-csrf-token", "" },
        { "phpsessid", "{{apiKey}}" },
    },
    Content = new MultipartFormDataContent
    {
        new StringContent("")
        {
            Headers =
            {
                ContentDisposition = new ContentDispositionHeaderValue("form-data")
                {
                    Name = "profile_picture",
                }
            }
        },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/profile/uploadPicture.php");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-csrf-token", "");
request.AddHeader("phpsessid", "{{apiKey}}");
request.AddHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001");
request.AddParameter("multipart/form-data; boundary=---011000010111000001101001", "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/profile/uploadPicture.php"

	payload := strings.NewReader("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-csrf-token", "")
	req.Header.Add("phpsessid", "{{apiKey}}")
	req.Header.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/profile/uploadPicture.php HTTP/1.1
X-Csrf-Token: 
Phpsessid: {{apiKey}}
Content-Type: multipart/form-data; boundary=---011000010111000001101001
Host: example.com
Content-Length: 124

-----011000010111000001101001
Content-Disposition: form-data; name="profile_picture"


-----011000010111000001101001--

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/profile/uploadPicture.php")
  .setHeader("x-csrf-token", "")
  .setHeader("phpsessid", "{{apiKey}}")
  .setHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .setBody("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/profile/uploadPicture.php"))
    .header("x-csrf-token", "")
    .header("phpsessid", "{{apiKey}}")
    .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
    .method("POST", HttpRequest.BodyPublishers.ofString("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001");
RequestBody body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/profile/uploadPicture.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/profile/uploadPicture.php")
  .header("x-csrf-token", "")
  .header("phpsessid", "{{apiKey}}")
  .header("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .body("-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
  .asString();

const data = new FormData();
data.append('profile_picture', '');

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/profile/uploadPicture.php');
xhr.setRequestHeader('x-csrf-token', '');
xhr.setRequestHeader('phpsessid', '{{apiKey}}');

xhr.send(data);

import axios from 'axios';

const form = new FormData();
form.append('profile_picture', '');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/profile/uploadPicture.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '[form]'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/profile/uploadPicture.php';
const form = new FormData();
form.append('profile_picture', '');

const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};

options.body = form;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const form = new FormData();
form.append('profile_picture', '');

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/profile/uploadPicture.php',
  method: 'POST',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}'
  },
  processData: false,
  contentType: false,
  mimeType: 'multipart/form-data',
  data: form
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("multipart/form-data; boundary=---011000010111000001101001")
val body = RequestBody.create(mediaType, "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n")
val request = Request.Builder()
  .url("{{baseUrl}}/api/profile/uploadPicture.php")
  .post(body)
  .addHeader("x-csrf-token", "")
  .addHeader("phpsessid", "{{apiKey}}")
  .addHeader("content-type", "multipart/form-data; boundary=---011000010111000001101001")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/profile/uploadPicture.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  }
};

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('-----011000010111000001101001\r\nContent-Disposition: form-data; name="profile_picture"\r\n\r\n\r\n-----011000010111000001101001--\r\n');
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/profile/uploadPicture.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  formData: {profile_picture: ''}
};

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/profile/uploadPicture.php');

req.headers({
  'x-csrf-token': '',
  phpsessid: '{{apiKey}}',
  'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
});

req.multipart([]);

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/profile/uploadPicture.php',
  headers: {
    'x-csrf-token': '',
    phpsessid: '{{apiKey}}',
    'content-type': 'multipart/form-data; boundary=---011000010111000001101001'
  },
  data: '-----011000010111000001101001\r\nContent-Disposition: form-data; name="profile_picture"\r\n\r\n\r\n-----011000010111000001101001--\r\n'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const FormData = require('form-data');
const fetch = require('node-fetch');

const formData = new FormData();
formData.append('profile_picture', '');

const url = '{{baseUrl}}/api/profile/uploadPicture.php';
const options = {method: 'POST', headers: {'x-csrf-token': '', phpsessid: '{{apiKey}}'}};
options.body = formData;

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-csrf-token": @"",
                           @"phpsessid": @"{{apiKey}}",
                           @"content-type": @"multipart/form-data; boundary=---011000010111000001101001" };
NSArray *parameters = @[ @{ @"name": @"profile_picture", @"value": @"" } ];
NSString *boundary = @"---011000010111000001101001";

NSError *error;
NSMutableString *body = [NSMutableString string];
for (NSDictionary *param in parameters) {
    [body appendFormat:@"--%@\r\n", boundary];
    if (param[@"fileName"]) {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"; filename=\"%@\"\r\n", param[@"name"], param[@"fileName"]];
        [body appendFormat:@"Content-Type: %@\r\n\r\n", param[@"contentType"]];
        [body appendFormat:@"%@", [NSString stringWithContentsOfFile:param[@"fileName"] encoding:NSUTF8StringEncoding error:&error]];
        if (error) {
            NSLog(@"%@", error);
        }
    } else {
        [body appendFormat:@"Content-Disposition:form-data; name=\"%@\"\r\n\r\n", param[@"name"]];
        [body appendFormat:@"%@", param[@"value"]];
    }
}
[body appendFormat:@"\r\n--%@--\r\n", boundary];
NSData *postData = [body dataUsingEncoding:NSUTF8StringEncoding];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/profile/uploadPicture.php"]
                                                       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/profile/uploadPicture.php" in
let headers = Header.add_list (Header.init ()) [
  ("x-csrf-token", "");
  ("phpsessid", "{{apiKey}}");
  ("content-type", "multipart/form-data; boundary=---011000010111000001101001");
] in
let body = Cohttp_lwt_body.of_string "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/profile/uploadPicture.php",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n",
  CURLOPT_HTTPHEADER => [
    "content-type: multipart/form-data; boundary=---011000010111000001101001",
    "phpsessid: {{apiKey}}",
    "x-csrf-token: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/profile/uploadPicture.php', [
  'headers' => [
    'content-type' => 'multipart/form-data; boundary=---011000010111000001101001',
    'phpsessid' => '{{apiKey}}',
    'x-csrf-token' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/profile/uploadPicture.php');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}',
  'content-type' => 'multipart/form-data; boundary=---011000010111000001101001'
]);

$request->setBody('-----011000010111000001101001
Content-Disposition: form-data; name="profile_picture"


-----011000010111000001101001--
');

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

addForm(null, null);

$request->setRequestUrl('{{baseUrl}}/api/profile/uploadPicture.php');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-csrf-token' => '',
  'phpsessid' => '{{apiKey}}'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/profile/uploadPicture.php' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="profile_picture"


-----011000010111000001101001--
'

$headers=@{}
$headers.Add("x-csrf-token", "")
$headers.Add("phpsessid", "{{apiKey}}")
$headers.Add("content-type", "multipart/form-data; boundary=---011000010111000001101001")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/profile/uploadPicture.php' -Method POST -Headers $headers -ContentType 'multipart/form-data; boundary=---011000010111000001101001' -Body '-----011000010111000001101001
Content-Disposition: form-data; name="profile_picture"


-----011000010111000001101001--
'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

headers = {
    'x-csrf-token': "",
    'phpsessid': "{{apiKey}}",
    'content-type': "multipart/form-data; boundary=---011000010111000001101001"
}

conn.request("POST", "/baseUrl/api/profile/uploadPicture.php", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/profile/uploadPicture.php"

payload = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
headers = {
    "x-csrf-token": "",
    "phpsessid": "{{apiKey}}",
    "content-type": "multipart/form-data; boundary=---011000010111000001101001"
}

response = requests.post(url, data=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/profile/uploadPicture.php"

payload <- "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

encode <- "multipart"

response <- VERB("POST", url, body = payload, add_headers('x-csrf-token' = '', 'phpsessid' = '{{apiKey}}'), content_type("multipart/form-data"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/profile/uploadPicture.php")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-csrf-token"] = ''
request["phpsessid"] = '{{apiKey}}'
request["content-type"] = 'multipart/form-data; boundary=---011000010111000001101001'
request.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'multipart/form-data; boundary=---011000010111000001101001'}
)

response = conn.post('/baseUrl/api/profile/uploadPicture.php') do |req|
  req.headers['x-csrf-token'] = ''
  req.headers['phpsessid'] = '{{apiKey}}'
  req.body = "-----011000010111000001101001\r\nContent-Disposition: form-data; name=\"profile_picture\"\r\n\r\n\r\n-----011000010111000001101001--\r\n"
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/profile/uploadPicture.php";

    let form = reqwest::multipart::Form::new()
        .text("profile_picture", "");
    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-csrf-token", "".parse().unwrap());
    headers.insert("phpsessid", "{{apiKey}}".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .multipart(form)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/profile/uploadPicture.php \
  --header 'content-type: multipart/form-data' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'x-csrf-token: ' \
  --form profile_picture=

echo '-----011000010111000001101001
Content-Disposition: form-data; name="profile_picture"


-----011000010111000001101001--
' |  \
  http POST {{baseUrl}}/api/profile/uploadPicture.php \
  content-type:'multipart/form-data; boundary=---011000010111000001101001' \
  phpsessid:'{{apiKey}}' \
  x-csrf-token:''

wget --quiet \
  --method POST \
  --header 'x-csrf-token: ' \
  --header 'phpsessid: {{apiKey}}' \
  --header 'content-type: multipart/form-data; boundary=---011000010111000001101001' \
  --body-data '-----011000010111000001101001\r\nContent-Disposition: form-data; name="profile_picture"\r\n\r\n\r\n-----011000010111000001101001--\r\n' \
  --output-document \
  - {{baseUrl}}/api/profile/uploadPicture.php

import Foundation

let headers = [
  "x-csrf-token": "",
  "phpsessid": "{{apiKey}}",
  "content-type": "multipart/form-data; boundary=---011000010111000001101001"
]
let parameters = [
  [
    "name": "profile_picture",
    "value": ""
  ]
]

let boundary = "---011000010111000001101001"

var body = ""
var error: NSError? = nil
for param in parameters {
  let paramName = param["name"]!
  body += "--\(boundary)\r\n"
  body += "Content-Disposition:form-data; name=\"\(paramName)\""
  if let filename = param["fileName"] {
    let contentType = param["content-type"]!
    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
    if (error != nil) {
      print(error as Any)
    }
    body += "; filename=\"\(filename)\"\r\n"
    body += "Content-Type: \(contentType)\r\n\r\n"
    body += fileContent
  } else if let paramValue = param["value"] {
    body += "\r\n\r\n\(paramValue)"
  }
}

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/profile/uploadPicture.php")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "success": true,
  "url": "/uploads/profile_pics/alice_9f3c2e1a8bcd.png"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": "Unauthorized"
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": "Invalid CSRF token."
}