API Guide

import requests

url = 'https://rdmfile.eu/api/upload'
files = {'file': open('NAME_FILE', 'rb')}
response = requests.post(url, files=files)
print(response.json())

import requests

url = "https://rdmfile.eu/api/get/FOLDER_NAME"
response = requests.get(url)
print(response.json())

import axios from "axios";
import fs from "fs";
import FormData from "form-data";

const url = "https://rdmfile.eu/api/upload";

const form = new FormData();
form.append("file", fs.createReadStream("NAME_FILE"));

const response = await axios.post(url, form, {
  headers: form.getHeaders(),
});

console.log(response.data);

const url = "https://rdmfile.eu/api/get/FOLDER_NAME";

const response = await fetch(url);
const data = await response.json();

console.log(data);

curl -F "file=@NAME_FILE" https://rdmfile.eu/api/upload

curl https://rdmfile.eu/api/get/FOLDER_NAME

<?php
$file = new CURLFile('NAME_FILE');
$post = array('file' => $file);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://rdmfile.eu/api/upload');
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $post);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

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

echo json_decode($response);
?>

<?php
$url = "https://rdmfile.eu/api/get/FOLDER_NAME";
$response = file_get_contents($url);
$data = json_decode($response, true);
print_r($data);
?>

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"os"
)

func main() {
	file, err := os.Open("NAME_FILE")
	defer file.Close()

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)
	part, _ := writer.CreateFormFile("file", "NAME_FILE")
	io.Copy(part, file)
	writer.Close()

	req, _ := http.NewRequest("POST", "https://rdmfile.eu/api/upload", body)
	req.Header.Set("Content-Type", writer.FormDataContentType())

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

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

package main

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

func main() {
	resp, _ := http.Get("https://rdmfile.eu/api/get/FOLDER_NAME")
	defer resp.Body.Close()

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

require 'net/http'
require 'uri'

uri = URI('https://rdmfile.eu/api/upload')
file = File.open('NAME_FILE', 'rb')

request = Net::HTTP::Post.new(uri)
request.set_form([['file', file]], 'multipart/form-data')

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
response = http.request(request)

puts response.body

require 'net/http'
require 'json'

uri = URI('https://rdmfile.eu/api/get/FOLDER_NAME')
response = Net::HTTP.get(uri)

data = JSON.parse(response)
puts data

import java.io.*;
import java.net.*;

public class Upload {
    public static void main(String[] args) throws Exception {
        String url = "https://rdmfile.eu/api/upload";
        File file = new File("NAME_FILE");
        
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setDoOutput(true);
        connection.setRequestMethod("POST");
        
        String boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW";
        connection.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
        
        OutputStream os = connection.getOutputStream();
        os.write(("--" + boundary + "\r\n").getBytes());
        os.write(("Content-Disposition: form-data; name=\"file\"; filename=\"" + file.getName() + "\"\r\n\r\n").getBytes());
        
        FileInputStream fis = new FileInputStream(file);
        byte[] buffer = new byte[1024];
        int bytesRead;
        while ((bytesRead = fis.read(buffer)) != -1) {
            os.write(buffer, 0, bytesRead);
        }
        fis.close();
        
        os.write(("\r\n--" + boundary + "--\r\n").getBytes());
        os.flush();
        
        BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }
}

import java.net.*;
import java.io.*;

public class Get {
    public static void main(String[] args) throws Exception {
        String url = "https://rdmfile.eu/api/get/FOLDER_NAME";
        HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
        connection.setRequestMethod("GET");
        
        BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
        String line;
        while ((line = br.readLine()) != null) {
            System.out.println(line);
        }
    }
}

using System;
using System.Net.Http;
using System.IO;
using System.Threading.Tasks;

class Upload {
    static async Task Main() {
        using (HttpClient client = new HttpClient()) {
            using (MultipartFormDataContent form = new MultipartFormDataContent()) {
                FileStream fileStream = File.OpenRead("NAME_FILE");
                form.Add(new StreamContent(fileStream), "file", "NAME_FILE");
                
                var response = await client.PostAsync("https://rdmfile.eu/api/upload", form);
                var content = await response.Content.ReadAsStringAsync();
                Console.WriteLine(content);
            }
        }
    }
}

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Get {
    static async Task Main() {
        using (HttpClient client = new HttpClient()) {
            var response = await client.GetAsync("https://rdmfile.eu/api/get/FOLDER_NAME");
            var content = await response.Content.ReadAsStringAsync();
            Console.WriteLine(content);
        }
    }
}

#include <curl/curl.h>
#include <iostream>

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://rdmfile.eu/api/upload");
        
        struct curl_httppost *formpost = NULL;
        struct curl_httppost *lastptr = NULL;
        curl_formadd(&formpost, &lastptr, CURLFORM_FILE, "NAME_FILE", CURLFORM_END);
        curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
        
        curl_easy_perform(curl);
        
        curl_formfree(formpost);
        curl_easy_cleanup(curl);
    }
    return 0;
}

#include <curl/curl.h>
#include <iostream>

size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
    s->append((char*)contents, size * nmemb);
    return size * nmemb;
}

int main() {
    CURL *curl = curl_easy_init();
    if(curl) {
        std::string readBuffer;
        curl_easy_setopt(curl, CURLOPT_URL, "https://rdmfile.eu/api/get/FOLDER_NAME");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);
        
        std::cout << readBuffer << std::endl;
    }
    return 0;
}

#include <curl/curl.h>
#include <stdio.h>

int main(void) {
    CURL *curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://rdmfile.eu/api/upload");
        
        struct curl_httppost *formpost = NULL;
        struct curl_httppost *lastptr = NULL;
        curl_formadd(&formpost, &lastptr, CURLFORM_FILE, "NAME_FILE", CURLFORM_END);
        curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
        
        curl_easy_perform(curl);
        
        curl_formfree(formpost);
        curl_easy_cleanup(curl);
    }
    return 0;
}

#include <curl/curl.h>
#include <stdio.h>

size_t write_data(void *ptr, size_t size, size_t nmemb, FILE *stream) {
    return fwrite(ptr, size, nmemb, stream);
}

int main(void) {
    CURL *curl = curl_easy_init();
    if(curl) {
        curl_easy_setopt(curl, CURLOPT_URL, "https://rdmfile.eu/api/get/FOLDER_NAME");
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, stdout);
        curl_easy_perform(curl);
        curl_easy_cleanup(curl);
    }
    return 0;
}

import Foundation

let url = URL(string: "https://rdmfile.eu/api/upload")!
let fileURL = URL(fileURLWithPath: "NAME_FILE")

var request = URLRequest(url: url)
request.httpMethod = "POST"

let boundary = "----WebKitFormBoundary7MA4YWxkTrZu0gW"
request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

var body = Data()
body.append("--\(boundary)\r\n".data(using: .utf8)!)
body.append("Content-Disposition: form-data; name=\"file\"; filename=\"NAME_FILE\"\r\n\r\n".data(using: .utf8)!)
body.append(try! Data(contentsOf: fileURL))
body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)

request.httpBody = body

URLSession.shared.dataTask(with: request) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}.resume()

import Foundation

let url = URL(string: "https://rdmfile.eu/api/get/FOLDER_NAME")!

URLSession.shared.dataTask(with: url) { data, response, error in
    if let data = data {
        print(String(data: data, encoding: .utf8) ?? "")
    }
}.resume()

import java.io.File
import okhttp3.*

fun main() {
    val file = File("NAME_FILE")
    val requestBody = MultipartBody.Builder()
        .setType(MultipartBody.FORM)
        .addFormDataPart("file", file.name, file.asRequestBody("application/octet-stream".toMediaType()))
        .build()

    val request = Request.Builder()
        .url("https://rdmfile.eu/api/upload")
        .post(requestBody)
        .build()

    val client = OkHttpClient()
    val response = client.newCall(request).execute()
    println(response.body?.string())
}

import okhttp3.OkHttpClient

fun main() {
    val client = OkHttpClient()
    val request = okhttp3.Request.Builder()
        .url("https://rdmfile.eu/api/get/FOLDER_NAME")
        .build()

    val response = client.newCall(request).execute()
    println(response.body?.string())
}

use reqwest::Client;
use std::fs::File;
use tokio::runtime;

fn main() {
    let rt = runtime::Runtime::new().unwrap();
    rt.block_on(async {
        let client = Client::new();
        let file = File::open("NAME_FILE").unwrap();
        
        let form = reqwest::multipart::Form::new()
            .file("file", "NAME_FILE").unwrap();

        let response = client
            .post("https://rdmfile.eu/api/upload")
            .multipart(form)
            .send()
            .await;

        match response {
            Ok(resp) => println!("{}", resp.text().await.unwrap()),
            Err(e) => println!("Error: {}", e),
        }
    });
}

use reqwest::Client;
use tokio::runtime;

fn main() {
    let rt = runtime::Runtime::new().unwrap();
    rt.block_on(async {
        let client = Client::new();
        let response = client
            .get("https://rdmfile.eu/api/get/FOLDER_NAME")
            .send()
            .await;

        match response {
            Ok(resp) => println!("{}", resp.text().await.unwrap()),
            Err(e) => println!("Error: {}", e),
        }
    });
}

import axios from 'axios';
import FormData from 'form-data';
import fs from 'fs';

async function uploadFile(filePath: string): Promise<void> {
    const form = new FormData();
    form.append('file', fs.createReadStream(filePath));

    try {
        const response = await axios.post('https://rdmfile.eu/api/upload', form, {
            headers: form.getHeaders(),
        });
        console.log(response.data);
    } catch (error) {
        console.error('Upload error:', error);
    }
}

uploadFile('NAME_FILE');

import axios from 'axios';

async function getFiles(folderName: string): Promise<void> {
    try {
        const response = await axios.get(`https://rdmfile.eu/api/get/${folderName}`);
        console.log(response.data);
    } catch (error) {
        console.error('Get error:', error);
    }
}

getFiles('FOLDER_NAME');

import 'package:http/http.dart' as http;
import 'dart:io';

Future<void> uploadFile(String filePath) async {
    var uri = Uri.parse('https://rdmfile.eu/api/upload');
    var request = http.MultipartRequest('POST', uri);
    request.files.add(await http.MultipartFile.fromPath('file', filePath));

    var response = await request.send();
    print(await response.stream.bytesToString());
}

void main() {
    uploadFile('NAME_FILE');
}

import 'package:http/http.dart' as http;

Future<void> getFiles(String folderName) async {
    final response = await http.get(Uri.parse('https://rdmfile.eu/api/get/$folderName'));
    print(response.body);
}

void main() {
    getFiles('FOLDER_NAME');
}

import scala.io.Source
import scalaj.http.Http

object Upload {
    def main(args: Array[String]) {
        val file = new java.io.File("NAME_FILE")
        val response = Http("https://rdmfile.eu/api/upload")
            .postMulti(scala.collection.mutable.LinkedHashMap(
                "file" -> file
            ))
            .asString
        println(response.body)
    }
}

import scalaj.http.Http

object Get {
    def main(args: Array[String]) {
        val response = Http("https://rdmfile.eu/api/get/FOLDER_NAME").asString
        println(response.body)
    }
}

use LWP::UserAgent;
use HTTP::Request::Common;

my $ua = LWP::UserAgent->new;
my $req = POST 'https://rdmfile.eu/api/upload',
    Content_Type => 'form-data',
    Content => [file => ["NAME_FILE"]];

my $res = $ua->request($req);
print $res->content;

use LWP::UserAgent;

my $ua = LWP::UserAgent->new;
my $response = $ua->get('https://rdmfile.eu/api/get/FOLDER_NAME');

if ($response->is_success) {
    print $response->decoded_content;
}

library(httr)

file_path <- "NAME_FILE"
response <- POST("https://rdmfile.eu/api/upload",
    body = list(file = upload_file(file_path)))

content(response, "text")

library(httr)
library(jsonlite)

response <- GET("https://rdmfile.eu/api/get/FOLDER_NAME")
data <- fromJSON(content(response, "text"))
print(data)

#!/bin/bash
curl -F "file=@NAME_FILE" https://rdmfile.eu/api/upload

#!/bin/bash
curl https://rdmfile.eu/api/get/FOLDER_NAME

$file = Get-Item -Path "NAME_FILE"
$uri = "https://rdmfile.eu/api/upload"

$form = @{
    file = $file
}

Invoke-WebRequest -Uri $uri -Method Post -Form $form | Select-Object -ExpandProperty Content

$response = Invoke-WebRequest -Uri "https://rdmfile.eu/api/get/FOLDER_NAME"
$response.Content

local http = require("socket.http")
local ltn12 = require("ltn12")

local file = io.open("NAME_FILE", "rb")
local body = file:read("*a")
file:close()

local result = {}
local response, status = http.request {
    url = "https://rdmfile.eu/api/upload",
    method = "POST",
    source = ltn12.source.string(body),
    sink = ltn12.sink.table(result),
    headers = {
        ["content-length"] = #body
    }
}

print(table.concat(result))

local http = require("socket.http")

local result = {}
http.request {
    url = "https://rdmfile.eu/api/get/FOLDER_NAME",
    sink = ltn12.sink.table(result)
}

print(table.concat(result))

{-# LANGUAGE OverloadedStrings #-}

import Network.HTTP.Client
import Network.HTTP.Client.MultipartFormData
import qualified Data.ByteString.Lazy as L

main :: IO ()
main = do
    manager <- newManager defaultManagerSettings
    req <- parseRequest "POST https://rdmfile.eu/api/upload"
    
    reqWithFile <- formDataBody [partFileSource "file" "NAME_FILE"] req
    
    response <- httpLbs reqWithFile manager
    print $ responseBody response

import Network.HTTP.Client
import Network.HTTP.Client.TLS

main :: IO ()
main = do
    manager <- newManager tlsManagerSettings
    request <- parseRequest "https://rdmfile.eu/api/get/FOLDER_NAME"
    response <- httpLbs request manager
    print $ responseBody response

defmodule Upload do
    def upload_file(file_path) do
        {:ok, _} = HTTPoison.start()
        
        {:ok, file} = File.read(file_path)
        
        {:ok, response} = HTTPoison.post(
            "https://rdmfile.eu/api/upload",
            {:multipart, [{:file, file_path}]},
            []
        )
        
        IO.inspect(response.body)
    end
end

Upload.upload_file("NAME_FILE")

defmodule Get do
    def get_files(folder_name) do
        {:ok, _} = HTTPoison.start()
        
        {:ok, response} = HTTPoison.get("https://rdmfile.eu/api/get/#{folder_name}")
        
        IO.inspect(response.body)
    end
end

Get.get_files("FOLDER_NAME")

@Grab('org.codehaus.groovy.modules.http-builder:http-builder:0.7.1')

import groovyx.net.http.HTTPBuilder
import static groovyx.net.http.Method.POST

def http = new HTTPBuilder('https://rdmfile.eu/api/upload')

http.request(POST) { req ->
    requestContentType = 'multipart/form-data'
    
    MultipartEntity entity = new MultipartEntity()
    entity.addPart('file', new FileBody(new File('NAME_FILE')))
    
    req.setEntity(entity)
    
    response.success = { resp, reader ->
        println reader.text
    }
}

@Grab('org.codehaus.groovy.modules.http-builder:http-builder:0.7.1')

import groovyx.net.http.HTTPBuilder
import static groovyx.net.http.Method.GET

def http = new HTTPBuilder('https://rdmfile.eu/api/get/FOLDER_NAME')

http.request(GET) { req ->
    response.success = { resp, reader ->
        println reader.text
    }
}

(ns clojure-upload.core
    (:require [clj-http.client :as client]
              [clojure.java.io :as io]))

(defn upload-file [file-path]
    (client/post "https://rdmfile.eu/api/upload"
        {:multipart [{:name "file"
                      :content (io/file file-path)}]}))

(println (upload-file "NAME_FILE"))

(ns clojure-get.core
    (:require [clj-http.client :as client]))

(defn get-files [folder-name]
    (client/get (str "https://rdmfile.eu/api/get/" folder-name)))

(println (get-files "FOLDER_NAME"))