# Step 1 — declare what you are about to upload.
curl --fail-with-body -X POST https://maatstays.wtf/v1/properties/3c9d1f42-7b60-4a18-9e55-0d2a6f8c31b7/photos/presign \
  -H "Authorization: Bearer $MAAT_PARTNER_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"files": [{"content_type": "image/jpeg", "size": 482113}]}'

# Step 2 — POST the bytes to the returned url, sending every returned
# field first and `file` LAST.
curl --fail-with-body -X POST "$UPLOAD_URL" \
  -F key="$FIELD_KEY" \
  -F policy="$FIELD_POLICY" \
  -F x-amz-signature="$FIELD_SIGNATURE" \
  -F file=@living-room.jpg

import { readFile } from 'node:fs/promises';

const bytes = await readFile('living-room.jpg');

// Step 1 — declare the file. `size` must be the REAL byte length: the
// form's length range is pinned to it.
const presign = await fetch(
    'https://maatstays.wtf/v1/properties/3c9d1f42-7b60-4a18-9e55-0d2a6f8c31b7/photos/presign',
    {
        method: 'POST',
        headers: {
            Authorization: `Bearer ${process.env.MAAT_PARTNER_TOKEN}`,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            files: [{ content_type: 'image/jpeg', size: bytes.byteLength }],
        }),
    },
);

const body = await presign.json();
if (!presign.ok) throw new Error(`${body.code}: ${body.detail}`);

const [upload] = body.uploads;

// Step 2 — POST the bytes. Every returned field first, in order, then the
// file. Anything after the file part is ignored.
const form = new FormData();
for (const [name, value] of Object.entries(upload.fields)) form.append(name, value);
form.append('file', new Blob([bytes], { type: 'image/jpeg' }), 'living-room.jpg');

const put = await fetch(upload.url, { method: 'POST', body: form });
if (!put.ok) throw new Error(`upload rejected: ${put.status}`);

// Step 3 — the photo is `pending`. Poll GET …/photos until it is `ready`.
console.log(upload.photo_id, body.quota.remaining_today);

import os
from pathlib import Path

import requests

image = Path("living-room.jpg")
data = image.read_bytes()

# Step 1 — declare the file. `size` must be the REAL byte length: the
# form's length range is pinned to it.
presign = requests.post(
    "https://maatstays.wtf/v1/properties/3c9d1f42-7b60-4a18-9e55-0d2a6f8c31b7/photos/presign",
    headers={"Authorization": f"Bearer {os.environ['MAAT_PARTNER_TOKEN']}"},
    json={"files": [{"content_type": "image/jpeg", "size": len(data)}]},
    timeout=30,
)

body = presign.json()
if presign.status_code >= 400:
    raise RuntimeError(f"{body['code']}: {body.get('detail')}")

upload = body["uploads"][0]

# Step 2 — POST the bytes. Every returned field first, in order, then the
# file. Anything after the file part is ignored.
sent = requests.post(
    upload["url"],
    data=upload["fields"],
    files={"file": (image.name, data, "image/jpeg")},
    timeout=120,
)
sent.raise_for_status()

# Step 3 — the photo is `pending`. Poll GET …/photos until it is `ready`.
print(upload["photo_id"], body["quota"]["remaining_today"])

package main

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

type upload struct {
    PhotoID   string            `json:"photo_id"`
    URL       string            `json:"url"`
    Fields    map[string]string `json:"fields"`
    ExpiresAt string            `json:"expires_at"`
}

func main() {
    data, err := os.ReadFile("living-room.jpg")
    if err != nil {
        log.Fatal(err)
    }

    // Step 1 — declare the file. `size` must be the REAL byte length:
    // the form's length range is pinned to it.
    payload, _ := json.Marshal(map[string]any{
        "files": []map[string]any{
            {"content_type": "image/jpeg", "size": len(data)},
        },
    })

    req, _ := http.NewRequest(http.MethodPost,
        "https://maatstays.wtf/v1/properties/3c9d1f42-7b60-4a18-9e55-0d2a6f8c31b7/photos/presign",
        bytes.NewReader(payload))
    req.Header.Set("Authorization", "Bearer "+os.Getenv("MAAT_PARTNER_TOKEN"))
    req.Header.Set("Content-Type", "application/json")

    res, err := http.DefaultClient.Do(req)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()

    if res.StatusCode >= 400 {
        log.Fatalf("presign failed: %d", res.StatusCode)
    }

    var body struct {
        Uploads []upload `json:"uploads"`
        Quota   struct {
            RemainingToday int `json:"remaining_today"`
        } `json:"quota"`
    }
    if err := json.NewDecoder(res.Body).Decode(&body); err != nil {
        log.Fatal(err)
    }
    u := body.Uploads[0]

    // Step 2 — POST the bytes. Every returned field first, in order,
    // then the file. Anything after the file part is ignored.
    var form bytes.Buffer
    writer := multipart.NewWriter(&form)
    for name, value := range u.Fields {
        _ = writer.WriteField(name, value)
    }
    part, _ := writer.CreateFormFile("file", "living-room.jpg")
    if _, err := io.Copy(part, bytes.NewReader(data)); err != nil {
        log.Fatal(err)
    }
    writer.Close()

    sent, err := http.Post(u.URL, writer.FormDataContentType(), &form)
    if err != nil {
        log.Fatal(err)
    }
    defer sent.Body.Close()
    if sent.StatusCode >= 400 {
        log.Fatalf("upload rejected: %d", sent.StatusCode)
    }

    // Step 3 — the photo is `pending`. Poll GET …/photos until it is ready.
    fmt.Println(u.PhotoID, body.Quota.RemainingToday)
}