Contrats de travail par l'API

export COMUSFLOW_TOKEN="cfat_…"

curl -sS -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people?limit=100" | jq

{
  "data": [
    { "id": 314, "first_name": "Camille", "last_name": "Blanc",
      "email": "camille.blanc@example.org" },
    { "id": 271, "first_name": "Sacha",   "last_name": "Duval",
      "email": "sacha.duval@example.org" }
  ],
  "pagination": { "limit": 100, "offset": 0, "total": 2, "has_more": false }
}

# Le numéro voyage dans le corps, jamais dans l'URL.
PERSON_ID=$(curl -sS -X POST "https://app.preprod.comusflow.com/api/v1/ma-salle/people/match" \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"guso_number": "1234567890"}' \
  | jq -r '.data[0].id // empty')

echo "person_id = ${PERSON_ID:-inconnue}"

{
  "data": [
    { "id": 314, "first_name": "Camille", "last_name": "Blanc",
      "nickname": null, "email": "camille.blanc@example.org" }
  ]
}

# L'email est la clé de réconciliation la plus sûre : deux personnes peuvent
# être homonymes, elles ne partagent pas une adresse.
PERSON_ID=$(curl -sS -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people?limit=100" \
  | jq -r '.data[] | select(.email == "camille.blanc@example.org") | .id')

echo "person_id = $PERSON_ID"

# Personne ne répond à cette adresse : on la crée, puis on repart avec son id.
# La clé d'idempotence est DÉRIVÉE de l'identité visée, pas tirée au hasard :
# relancer le script ne peut donc pas créer deux fiches.
KEY=$(printf 'person|%s' "$EMAIL" | sha256sum | cut -d' ' -f1)

PERSON_ID=$(curl -sS -X POST "https://app.preprod.comusflow.com/api/v1/ma-salle/people" \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  -H "Idempotency-Key: $KEY" \
  -H "Content-Type: application/json" \
  -d "{\"first_name\": \"Camille\", \"last_name\": \"Blanc\", \"email\": \"$EMAIL\"}" \
  | jq -r .id)

{ "id": 314, "first_name": "Camille", "last_name": "Blanc",
  "email": "camille.blanc@example.org" }

export COMUSFLOW_TOKEN="cfat_…"

curl -sS -X POST \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people/314/contracts" \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  -H "Idempotency-Key: $(uuidgen)" \
  -F "contract_type=cddu" \
  -F "title=CDDU novembre — régie lumière" \
  -F "period_start=2026-11-02" \
  -F "period_end=2026-11-08" \
  -F "file=@contrat-signe.pdf"

HTTP/1.1 201 Created

{
  "id": 1204,
  "person_id": 314,
  "contract_type": "cddu",
  "title": "CDDU novembre — régie lumière",
  "period_start": "2026-11-02",
  "period_end": "2026-11-08",
  "created_at": "2026-11-02T09:41:07Z"
}

import uuid
import requests

BASE = "https://app.preprod.comusflow.com/api/v1/ma-salle"
HEADERS = {"Authorization": f"Bearer {TOKEN}"}

# La clé identifie l'INTENTION, pas la tentative : on la calcule une fois,
# hors de la boucle de retry, sinon chaque nouvel essai crée un doublon.
key = str(uuid.uuid4())

with open("contrat-signe.pdf", "rb") as handle:
    response = requests.post(
        f"{BASE}/people/314/contracts",
        headers={**HEADERS, "Idempotency-Key": key},
        data={
            "contract_type": "cddu",
            "title": "CDDU novembre — régie lumière",
            "period_start": "2026-11-02",
            "period_end": "2026-11-08",
        },
        files={"file": ("contrat-signe.pdf", handle, "application/pdf")},
        timeout=30,
    )

response.raise_for_status()
if response.headers.get("Idempotency-Replayed") == "true":
    print("déjà déposé — rien n'a été exécuté cette fois-ci")
print(response.json()["id"])

HTTP/1.1 422 Unprocessable Entity

{
  "error": "Validation failed",
  "code": "INVALID_INPUT",
  "request_id": "5f2c…",
  "fields": {
    "period_end": ["La fin de période ne peut pas être antérieure à son début."]
  }
}

curl -sS \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people/314/contracts/1204/coverage" \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN"
# → {"coverage": "covered"}

curl -sS -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people/314/contracts?limit=100" | jq

{
  "data": [
    {
      "id": 1204,
      "person_id": 314,
      "contract_type": "cddu",
      "title": "CDDU novembre — régie lumière",
      "period_start": "2026-11-02",
      "period_end": "2026-11-08",
      "created_at": "2026-11-02T09:41:07Z"
    }
  ],
  "pagination": { "limit": 100, "offset": 0, "total": 1, "has_more": false }
}

curl -sS -L -OJ \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people/314/contracts/1204/download"

curl -sS -X DELETE \
  "https://app.preprod.comusflow.com/api/v1/ma-salle/people/314/contracts/1204" \
  -H "Authorization: Bearer $COMUSFLOW_TOKEN" \
  -H "Idempotency-Key: $(uuidgen)" \
  -w '%{http_code}\n'
# → 204

# Retraitement d'un PDF déjà déposé : on retire, puis on redépose.
# La clé de RETRAIT est dérivée du contrat visé — deux exécutions du script
# ne peuvent donc pas retirer deux contrats différents par mégarde.
DROP_KEY=$(printf 'withdraw|%s' "$CONTRACT_ID" | sha256sum | cut -d' ' -f1)

curl -sS -X DELETE "$BASE/people/$PERSON_ID/contracts/$CONTRACT_ID" \
  "${AUTH[@]}" -H "Idempotency-Key: $DROP_KEY" -o /dev/null -w '%{http_code}\n'

curl -sS -X POST "$BASE/people/$PERSON_ID/contracts" \
  "${AUTH[@]}" -H "Idempotency-Key: $NEW_KEY" \
  -F "contract_type=$TYPE" -F "title=$TITLE" \
  -F "period_start=$START" -F "period_end=$END" \
  -F "file=@$FILE"

#!/usr/bin/env bash
# Dépose un contrat de travail, de bout en bout, sans doublon possible.
set -euo pipefail

: "${COMUSFLOW_TOKEN:?jeton absent}"
BASE="https://app.preprod.comusflow.com/api/v1/ma-salle"
AUTH=(-H "Authorization: Bearer $COMUSFLOW_TOKEN")

GUSO="1234567890"
EMAIL="camille.blanc@example.org"
TYPE="cddu"
TITLE="CDDU novembre — régie lumière"
START="2026-11-02"
END="2026-11-08"
FILE="contrat-signe.pdf"

# 1. Désigner la personne par son n° GUSO. C'est une lecture portée par un POST :
#    le numéro voyage dans le corps, jamais dans une URL.
PERSON_ID=$(curl -sS -X POST "$BASE/people/match" "${AUTH[@]}" \
  -H "Content-Type: application/json" \
  -d "{\"guso_number\": \"$GUSO\"}" \
  | jq -r '.data[0].id // empty')

# 1 bis. Inconnue ? On la crée, avec une clé dérivée de l'identité visée — deux
#        exécutions ne peuvent donc pas produire deux fiches.
if [ -z "$PERSON_ID" ]; then
  PERSON_KEY=$(printf 'person|%s' "$GUSO" | sha256sum | cut -d' ' -f1)
  PERSON_ID=$(curl -sS -X POST "$BASE/people" "${AUTH[@]}" \
    -H "Idempotency-Key: $PERSON_KEY" -H "Content-Type: application/json" \
    -d "{\"first_name\": \"Camille\", \"last_name\": \"Blanc\", \"email\": \"$EMAIL\", \"guso_number\": \"$GUSO\"}" \
    | jq -r .id)
fi
[ -n "$PERSON_ID" ] && [ "$PERSON_ID" != "null" ] || { echo "personne irrésolue : $GUSO" >&2; exit 1; }

# 2. Une clé DÉRIVÉE de l'intention, pas tirée au hasard : relancer ce script
#    deux fois de suite ne peut alors pas créer deux contrats.
KEY=$(printf '%s|%s|%s|%s|%s' "$PERSON_ID" "$TYPE" "$TITLE" "$START" "$END" \
  | sha256sum | cut -d' ' -f1)

# 3. Déposer.
HTTP=$(curl -sS -o /tmp/contract.json -D /tmp/contract.headers -w '%{http_code}' \
  -X POST "$BASE/people/$PERSON_ID/contracts" \
  "${AUTH[@]}" -H "Idempotency-Key: $KEY" \
  -F "contract_type=$TYPE" -F "title=$TITLE" \
  -F "period_start=$START" -F "period_end=$END" \
  -F "file=@$FILE")

case "$HTTP" in
  201)
    if grep -qi '^idempotency-replayed: true' /tmp/contract.headers; then
      echo "déjà déposé — aucune écriture cette fois-ci"
    else
      echo "contrat déposé : $(jq -r .id /tmp/contract.json)"
    fi ;;
  409) echo "dépôt concurrent en cours, réessayez dans un instant" >&2; exit 75 ;;
  *)   echo "échec ($HTTP) : $(jq -r '.code // "?"' /tmp/contract.json)" >&2; exit 1 ;;
esac

# 4. Le contrat déposé couvre-t-il un engagement ? Un avertissement, jamais un
#    nouveau dépôt : un contrat « non couvert » se signale à un humain.
CONTRACT_ID=$(jq -r .id /tmp/contract.json)
COVERAGE=$(curl -sS "$BASE/people/$PERSON_ID/contracts/$CONTRACT_ID/coverage" \
  "${AUTH[@]}" | jq -r '.coverage // "?"')
if [ "$COVERAGE" = "not_covered" ]; then
  echo "AVERTISSEMENT : contrat $CONTRACT_ID sans engagement — à signaler à un humain" >&2
fi

# Parcourir tous les contrats d'une personne, page par page.
OFFSET=0
while : ; do
  PAGE=$(curl -sS "${AUTH[@]}" \
    "$BASE/people/$PERSON_ID/contracts?limit=100&offset=$OFFSET")
  echo "$PAGE" | jq -c '.data[]'
  TOTAL=$(echo "$PAGE" | jq -r '.pagination.total')
  OFFSET=$((OFFSET + 100))
  [ "$OFFSET" -lt "$TOTAL" ] || break
done