Hermiis REST API

token = System.get_env("HERMIIS_API_TOKEN")
base  = "https://hermiis.com/api/v1"
hdrs  = [{"authorization", "Bearer #{token}"}]

# List workspaces
{:ok, %{body: body}} =
  Req.get("#{base}/workspaces", headers: hdrs)

# Create a task
{:ok, %{status: 201, body: %{"task" => task}}} =
  Req.post("#{base}/workspaces/acme/boards/mt/tasks",
    headers: hdrs,
    json: %{title: "Deploy to production", priority: "high"}
  )

import httpx, os

TOKEN   = os.environ["HERMIIS_API_TOKEN"]
BASE    = "https://hermiis.com/api/v1"
HEADERS = {"Authorization": f"Bearer {TOKEN}"}

# List tasks
tasks = httpx.get(f"{BASE}/workspaces/acme/boards/mt/tasks",
                  headers=HEADERS).json()["tasks"]

# Create a task
task = httpx.post(
    f"{BASE}/workspaces/acme/boards/mt/tasks",
    headers=HEADERS,
    json={"title": "Deploy to production", "priority": "high"},
).json()["task"]

const TOKEN   = process.env.HERMIIS_API_TOKEN;
const BASE    = "https://hermiis.com/api/v1";
const headers = { Authorization: `Bearer ${TOKEN}`, "Content-Type": "application/json" };

// List boards
const boards = await fetch(`${BASE}/workspaces/acme/boards`, { headers })
  .then(r => r.json()).then(b => b.boards);

// Create a task
const task = await fetch(`${BASE}/workspaces/acme/boards/mt/tasks`, {
  method: "POST",
  headers,
  body: JSON.stringify({ title: "Deploy to production", priority: "high" }),
}).then(r => r.json()).then(b => b.task);

require 'net/http'
require 'json'
require 'uri'

TOKEN = ENV['HERMIIS_API_TOKEN']
BASE  = 'https://hermiis.com/api/v1'
HDRS  = { 'Authorization' => "Bearer #{TOKEN}", 'Content-Type' => 'application/json' }

# List tasks
uri   = URI("#{BASE}/workspaces/acme/boards/mt/tasks")
resp  = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.get(uri.path, HDRS) }
tasks = JSON.parse(resp.body)['tasks']

# Create a task
uri     = URI("#{BASE}/workspaces/acme/boards/mt/tasks")
resp    = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |h|
  req      = Net::HTTP::Post.new(uri, HDRS)
  req.body = { title: 'Deploy to production', priority: 'high' }.to_json
  h.request(req)
end
task = JSON.parse(resp.body)['task']

<?php

use GuzzleHttp\Client;

$client = new Client([
    'base_uri' => 'https://hermiis.com/api/v1/',
    'headers'  => [
        'Authorization' => 'Bearer ' . getenv('HERMIIS_API_TOKEN'),
        'Accept'        => 'application/json',
        'Content-Type'  => 'application/json',
    ],
]);

// List tasks
$tasks = json_decode(
    $client->get('workspaces/acme/boards/mt/tasks')->getBody(),
    true
)['tasks'];

// Create a task
$task = json_decode(
    $client->post('workspaces/acme/boards/mt/tasks', [
        'json' => ['title' => 'Deploy to production', 'priority' => 'high'],
    ])->getBody(),
    true
)['task'];

package main

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

const base = "https://hermiis.com/api/v1"

func main() {
	token  := os.Getenv("HERMIIS_API_TOKEN")
	client := &http.Client{}

	// List tasks
	req, _ := http.NewRequest("GET", base+"/workspaces/acme/boards/mt/tasks", nil)
	req.Header.Set("Authorization", "Bearer "+token)
	resp, _ := client.Do(req)
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	fmt.Println(string(body))

	// Create a task
	payload, _ := json.Marshal(map[string]any{"title": "Deploy to production", "priority": "high"})
	req, _ = http.NewRequest("POST", base+"/workspaces/acme/boards/mt/tasks", bytes.NewBuffer(payload))
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")
	resp, _ = client.Do(req)
	defer resp.Body.Close()
}

use reqwest::header::{AUTHORIZATION, CONTENT_TYPE, HeaderMap, HeaderValue};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let token  = std::env::var("HERMIIS_API_TOKEN")?;
    let base   = "https://hermiis.com/api/v1";
    let client = reqwest::Client::new();

    let mut headers = HeaderMap::new();
    headers.insert(AUTHORIZATION, HeaderValue::from_str(&format!("Bearer {token}"))?);

    // List tasks
    let tasks: serde_json::Value = client
        .get(format!("{base}/workspaces/acme/boards/mt/tasks"))
        .headers(headers.clone())
        .send().await?
        .json().await?;
    println!("{tasks:#?}");

    // Create a task
    let task: serde_json::Value = client
        .post(format!("{base}/workspaces/acme/boards/mt/tasks"))
        .headers(headers)
        .header(CONTENT_TYPE, "application/json")
        .json(&json!({"title": "Deploy to production", "priority": "high"}))
        .send().await?
        .json().await?;
    println!("{task:#?}");
    Ok(())
}

(ns hermiis-client.core
  (:require [clj-http.client :as http]
            [cheshire.core   :as json]))

(def token (System/getenv "HERMIIS_API_TOKEN"))
(def base  "https://hermiis.com/api/v1")
(def hdrs  {:headers {"Authorization" (str "Bearer " token)
                      "Content-Type"  "application/json"}
            :as :json})

;; List tasks
(def tasks
  (-> (http/get (str base "/workspaces/acme/boards/mt/tasks") hdrs)
      :body :tasks))

;; Create a task
(def task
  (-> (http/post (str base "/workspaces/acme/boards/mt/tasks")
                 (assoc hdrs :body (json/generate-string {:title "Deploy to production" :priority "high"})))
      :body :task))