Replicar la agenda en un calendario

# Export FILMO_API_KEY first: a key with the scopes listed above.
FILMO_URL="${FILMO_BASE_URL:-https://app.filmo.io}"

// filmo.mjs: a small client. Node 22 or later, no dependencies.
export const API = (process.env.FILMO_BASE_URL ?? "https://app.filmo.io") + "/api/v1";
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

// GET with query parameters. Waits out a 429 as Retry-After says.
export async function get(path, query = {}, headers = {}) {
  const url = new URL(API + path);
  for (const [key, value] of Object.entries(query)) url.searchParams.set(key, String(value));
  for (;;) {
    const res = await fetch(url, {
      headers: { Authorization: ["Bearer", process.env.FILMO_API_KEY].join(" "), ...headers },
    });
    if (res.status === 429) {
      await sleep(Number(res.headers.get("Retry-After") ?? 1) * 1000);
      continue;
    }
    if (res.status === 304) return { status: 304, etag: res.headers.get("ETag") };
    if (!res.ok) {
      throw Object.assign(new Error(res.status + " " + (await res.text())), { status: res.status });
    }
    return {
      ...(await res.json()),
      status: res.status,
      etag: res.headers.get("ETag"),
      serverTime: new Date(res.headers.get("Date")), // the server's clock, not yours
    };
  }
}

# filmo.py: a small client. Python 3 and requests.
import os
import time
from email.utils import parsedate_to_datetime

import requests

API = os.environ.get("FILMO_BASE_URL", "https://app.filmo.io") + "/api/v1"
session = requests.Session()
session.headers["Authorization"] = f"Bearer {os.environ['FILMO_API_KEY']}"


def get(path, headers=None, **query):
    """GET with query parameters. Waits out a 429 as Retry-After says."""
    while True:
        res = session.get(API + path, params=query, headers=headers)
        if res.status_code == 429:
            time.sleep(int(res.headers.get("Retry-After", "1")))
            continue
        if res.status_code == 304:
            return {"status": 304, "etag": res.headers.get("ETag")}
        res.raise_for_status()
        body = res.json()
        body["status"] = res.status_code
        body["etag"] = res.headers.get("ETag")
        body["serverTime"] = parsedate_to_datetime(res.headers["Date"])  # the server's clock
        return body

# Export FILMO_API_KEY first: a key with the scopes listed above.
FILMO_URL="${FILMO_BASE_URL:-https://app.filmo.io}"

curl -sS "$FILMO_URL/api/v1/account" \
  -H "Authorization: Bearer $FILMO_API_KEY"

import { get } from "./filmo.mjs";

const { data: account } = await get("/account");
console.log(account.timezone, account.currency, account.rateLimits.global.perMinute);

from filmo import get

account = get("/account")["data"]
print(account["timezone"], account["currency"], account["rateLimits"]["global"]["perMinute"])

FILMO_URL="${FILMO_BASE_URL:-https://app.filmo.io}"

# A fixed window, as instants with an offset. Keep the window the same between polls.
curl -sS -i -G "$FILMO_URL/api/v1/schedule" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  --data-urlencode "startDate=2026-10-02T00:00:00Z" \
  --data-urlencode "endDate=2026-12-08T00:00:00Z" \
  --data-urlencode "layers=projects,orders,tasks,internal_services"

# Repeat it with the ETag you received. 304 means nothing changed and the copy you hold is current.
curl -sS -i -G "$FILMO_URL/api/v1/schedule" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  -H "If-None-Match: $ETAG" \
  --data-urlencode "startDate=2026-10-02T00:00:00Z" \
  --data-urlencode "endDate=2026-12-08T00:00:00Z" \
  --data-urlencode "layers=projects,orders,tasks,internal_services"

import { get } from "./filmo.mjs";

const DAY = 24 * 3600 * 1000;
const today = Math.floor(Date.now() / DAY) * DAY; // midnight UTC, so the window repeats all day
const query = {
  startDate: new Date(today - 7 * DAY).toISOString(),
  endDate: new Date(today + 60 * DAY).toISOString(),
  layers: "projects,orders,tasks,internal_services",
};

const first = await get("/schedule", query);
console.log(first.data.tasks.length + " tasks, ETag " + first.etag);

const again = await get("/schedule", query, { "If-None-Match": first.etag });
console.log(again.status); // 304: no body, nothing changed

import time
from datetime import datetime, timedelta, timezone

from filmo import get

today = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)  # the window repeats all day
query = {
    "startDate": (today - timedelta(days=7)).isoformat().replace("+00:00", "Z"),
    "endDate": (today + timedelta(days=60)).isoformat().replace("+00:00", "Z"),
    "layers": "projects,orders,tasks,internal_services",
}

first = get("/schedule", **query)
print(len(first["data"]["tasks"]), "tasks, ETag", first["etag"])

again = get("/schedule", headers={"If-None-Match": first["etag"]}, **query)
print(again["status"])  # 304: no body, nothing changed

# What has to be covered in the window. staffMemberId and vehicleId at null mean uncovered.
curl -sS -G "$FILMO_URL/api/v1/planner/services" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  --data-urlencode "startDate=2026-10-02T00:00:00Z" \
  --data-urlencode "endDate=2026-12-08T00:00:00Z" \
  --data-urlencode "orderStatus=all"

# With whom: the staff and the fleet that can cover it.
curl -sS -G "$FILMO_URL/api/v1/planner/resources" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  --data-urlencode "resourceType=both"

import { get } from "./filmo.mjs";

const DAY = 24 * 3600 * 1000;
const today = Math.floor(Date.now() / DAY) * DAY; // midnight UTC
const startDate = new Date(today - 7 * DAY).toISOString();
const endDate = new Date(today + 60 * DAY).toISOString();

// A service comes as several rows that share an orderServiceId: one with rowKind "summary" (the
// service itself, staffMemberId and vehicleId at null) and one "detail" row for each person or
// vehicle assigned. Rows with an empty orderId are internal services, which the schedule already
// returns: skip them.
function groupServices(rows) {
  const byService = new Map();
  for (const row of rows) {
    if (row.orderId === "") continue;
    const service = byService.get(row.orderServiceId) ?? { staff: [], vehicles: [] };
    if (row.rowKind === "summary") Object.assign(service, row); // the service itself
    else {
      if (row.staffMemberId) service.staff.push(row.staffMemberId);
      if (row.vehicleId) service.vehicles.push(row.vehicleId);
    }
    byService.set(row.orderServiceId, service);
  }
  return [...byService.values()];
}

const services = await get("/planner/services", { startDate, endDate, orderStatus: "all" });
const grouped = groupServices(services.data);
const uncovered = grouped.filter((s) => s.staff.length === 0 && s.vehicles.length === 0);
console.log(uncovered.length + " of " + grouped.length + " services without a staff member or a vehicle");

const resources = await get("/planner/resources", { resourceType: "both" });
for (const r of resources.data) console.log(r.type, r.id, r.name);

from datetime import datetime, timedelta, timezone

from filmo import get

today = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
start_date = (today - timedelta(days=7)).isoformat().replace("+00:00", "Z")
end_date = (today + timedelta(days=60)).isoformat().replace("+00:00", "Z")


def group_services(rows):
    """A service comes as several rows that share an orderServiceId: one with rowKind "summary" (the
    service itself, staffMemberId and vehicleId at null) and one "detail" row for each person or
    vehicle assigned. Rows with an empty orderId are internal services, which the schedule already
    returns: skip them."""
    by_service = {}
    for row in rows:
        if row["orderId"] == "":
            continue
        service = by_service.setdefault(row["orderServiceId"], {"staff": [], "vehicles": []})
        if row["rowKind"] == "summary":
            service.update(row)  # the service itself
        else:
            if row["staffMemberId"]:
                service["staff"].append(row["staffMemberId"])
            if row["vehicleId"]:
                service["vehicles"].append(row["vehicleId"])
    return list(by_service.values())


services = get("/planner/services", startDate=start_date, endDate=end_date, orderStatus="all")["data"]
grouped = group_services(services)
uncovered = [s for s in grouped if not s["staff"] and not s["vehicles"]]
print(len(uncovered), "of", len(grouped), "services without a staff member or a vehicle")

for r in get("/planner/resources", resourceType="both")["data"]:
    print(r["type"], r["id"], r["name"])

# resourceType is required: staff, vehicle or space. Repeat the call for each one.
curl -sS -G "$FILMO_URL/api/v1/availability/unavailabilities" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  --data-urlencode "resourceType=staff" \
  --data-urlencode "startDate=2026-10-02T00:00:00Z" \
  --data-urlencode "endDate=2026-12-08T00:00:00Z" \
  --data-urlencode "limit=500"

// unavailabilities.mjs
import { get } from "./filmo.mjs";

// Follows the list's own date cursor until it ends.
export async function listUnavailabilities(resourceType, startDate, endDate) {
  const found = [];
  let cursor;
  do {
    const page = await get("/availability/unavailabilities", {
      resourceType,
      startDate,
      endDate,
      limit: 500,
      ...(cursor && { cursor }),
    });
    found.push(...page.data);
    cursor = page.pagination.hasMore ? page.pagination.nextCursor : undefined;
  } while (cursor);
  return found;
}

// Use: await listUnavailabilities("staff", startDate, endDate), then "vehicle" and "space".

# unavailabilities.py
from filmo import get


def list_unavailabilities(resource_type, start_date, end_date):
    """Follows the list's own date cursor until it ends."""
    found, cursor = [], None
    while True:
        params = {"resourceType": resource_type, "startDate": start_date, "endDate": end_date, "limit": 500}
        if cursor:
            params["cursor"] = cursor
        page = get("/availability/unavailabilities", **params)
        found += page["data"]
        if not page["pagination"]["hasMore"]:
            return found
        cursor = page["pagination"]["nextCursor"]


# Use: list_unavailabilities("staff", start_date, end_date), then "vehicle" and "space".

# Tasks that overlap [from, to], with the fields the schedule leaves out.
curl -sS -G "$FILMO_URL/api/v1/tasks" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  --data-urlencode "from=2026-10-02T00:00:00Z" \
  --data-urlencode "to=2026-12-08T00:00:00Z" \
  --data-urlencode "sort=startDate" \
  --data-urlencode "limit=500"

import { get } from "./filmo.mjs";

const DAY = 24 * 3600 * 1000;
const today = Math.floor(Date.now() / DAY) * DAY; // midnight UTC
const from = new Date(today - 7 * DAY).toISOString();
const to = new Date(today + 60 * DAY).toISOString();

const tasks = await get("/tasks", { from, to, sort: "startDate", limit: 500 });
for (const t of tasks.data) {
  console.log(t.title, t.isRecurring, t.recurrencePattern?.frequency, t.relatedDocumentType, t.description);
}
console.log(tasks.pagination.hasMore ? "more pages: follow the cursor" : "complete");

from datetime import datetime, timedelta, timezone

from filmo import get

today = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
start = (today - timedelta(days=7)).isoformat().replace("+00:00", "Z")
end = (today + timedelta(days=60)).isoformat().replace("+00:00", "Z")

tasks = get("/tasks", **{"from": start, "to": end, "sort": "startDate", "limit": 500})
for t in tasks["data"]:
    pattern = t["recurrencePattern"] or {}
    print(t["title"], t["isRecurring"], pattern.get("frequency"), t["relatedDocumentType"], t["description"])
print("more pages: follow the cursor" if tasks["pagination"]["hasMore"] else "complete")

# Shares the 30 requests per minute of the availability queries. Up to 100 staffIds per call.
curl -sS -X POST "$FILMO_URL/api/v1/staff/availability" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "startDate": "2026-10-14T08:00:00+02:00",
    "endDate": "2026-10-14T20:00:00+02:00",
    "staffIds": ["'"$STAFF_ID"'"]
  }'

import { API } from "./filmo.mjs";

const res = await fetch(API + "/staff/availability", {
  method: "POST",
  headers: {
    Authorization: ["Bearer", process.env.FILMO_API_KEY].join(" "),
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    startDate: "2026-10-14T08:00:00+02:00",
    endDate: "2026-10-14T20:00:00+02:00",
    staffIds: [process.env.STAFF_ID],
  }),
});
if (res.status === 429) {
  console.log("Availability quota spent; retry in " + res.headers.get("Retry-After") + " s");
} else {
  const { data } = await res.json();
  for (const entry of data) {
    if (entry.error) console.log(entry.resourceId, entry.error.code);
    else console.log(entry.name, entry.available, entry.commitments.map((c) => c.kind));
  }
}

import os

from filmo import API, session

res = session.post(
    API + "/staff/availability",
    json={
        "startDate": "2026-10-14T08:00:00+02:00",
        "endDate": "2026-10-14T20:00:00+02:00",
        "staffIds": [os.environ["STAFF_ID"]],
    },
)
if res.status_code == 429:
    print("Availability quota spent; retry in", res.headers["Retry-After"], "s")
else:
    res.raise_for_status()
    for entry in res.json()["data"]:
        if "error" in entry:
            print(entry["resourceId"], entry["error"]["code"])
        else:
            print(entry["name"], entry["available"], [c["kind"] for c in entry["commitments"]])

// mirror.mjs: one cycle of the calendar mirror. Run it every 5 minutes.
import { readFile, writeFile } from "node:fs/promises";
import { get } from "./filmo.mjs";
import { listUnavailabilities } from "./unavailabilities.mjs";

const STATE = "schedule-mirror.json";
const DAY = 24 * 3600 * 1000;
const LAYERS = ["projects", "orders", "tasks", "internalServices"];
const iso = (ms) => new Date(ms).toISOString();

// The schedule returns at most this many records per layer and says nothing when it cuts the list.
const CAP = { projects: 200, orders: 200, tasks: 500 };
// It also leaves out finished and cancelled records: these are the states it still shows.
const SCHEDULED = {
  order: new Set(["draft", "reserved", "prepared_partially", "prepared", "picked_up_partially", "picked_up", "returned_partially", "returned", "checked_in_partially"]),
  project: new Set(["draft", "budgeted", "confirmed", "in_progress"]),
};

// A layer that comes back exactly full may have been cut: read the window again in halves.
async function readSchedule(from, to) {
  const { data } = await get("/schedule", {
    startDate: iso(from), endDate: iso(to), layers: "projects,orders,tasks,internal_services",
  });
  const full = Object.entries(CAP).some(([layer, cap]) => data[layer].length >= cap);
  if (!full) return { data, complete: true };
  if (to - from <= DAY) return { data, complete: false }; // a single day is still cut
  const middle = from + Math.floor((to - from) / 2);
  const [a, b] = [await readSchedule(from, middle), await readSchedule(middle, to)];
  const merged = {};
  for (const layer of LAYERS) {
    merged[layer] = [...new Map([...a.data[layer], ...b.data[layer]].map((x) => [x.id, x])).values()];
  }
  return { data: merged, complete: a.complete && b.complete };
}

// A service comes as one "summary" row plus one "detail" row per person or vehicle assigned,
// all with the same orderServiceId. Internal services (empty orderId) are already in the schedule.
function groupServices(rows) {
  const byService = new Map();
  for (const row of rows) {
    if (row.orderId === "") continue;
    const service = byService.get(row.orderServiceId) ?? { staff: [], vehicles: [] };
    if (row.rowKind === "summary") Object.assign(service, row); // the service itself
    else {
      if (row.staffMemberId) service.staff.push(row.staffMemberId);
      if (row.vehicleId) service.vehicles.push(row.vehicleId);
    }
    byService.set(row.orderServiceId, service);
  }
  return [...byService.values()];
}

// One item of each layer becomes one calendar event, keyed by layer and id.
function toEvents(schedule, services, absences) {
  const events = new Map();
  for (const p of schedule.projects) {
    events.set("project:" + p.id, { title: p.name, start: p.startDate, end: p.endDate });
  }
  for (const o of schedule.orders) {
    events.set("order:" + o.id, { title: "Order " + o.orderNumber, start: o.startDate, end: o.endDate });
  }
  for (const t of schedule.tasks) {
    if (!t.startDate) continue;
    events.set("task:" + t.id, {
      title: t.title, start: t.startDate, end: t.endDate, allDay: t.isAllDay,
      done: t.isCompleted, staff: t.assignedStaff.map((s) => s.id),
    });
  }
  for (const s of schedule.internalServices) {
    events.set("internal:" + s.id, {
      title: s.title, start: s.startDate, end: s.endDate, staff: s.assignedStaff.map((m) => m.id),
    });
  }
  for (const s of services) {
    events.set("service:" + s.orderServiceId, {
      title: s.serviceName + " (" + s.orderNumber + ")", start: s.startDate, end: s.endDate,
      staff: s.staff, vehicles: s.vehicles,
    });
  }
  for (const a of absences) {
    events.set("absence:" + a.id, {
      title: (a.resourceName ?? a.resourceId) + " " + a.state, start: a.startDate, end: a.endDate,
    });
  }
  return events;
}

// Missing from a read is only a suspicion. Confirm it with the record's own read.
async function isGone(key, held) {
  const [kind, id] = key.split(":");
  // The list returns only the absences in force or still to come: one that ended drops out by itself.
  if (kind === "absence") return held.end > new Date().toISOString();
  const path = { project: "/projects/", order: "/orders/", task: "/tasks/" }[kind];
  if (!path) return true; // internal and planner services are not capped: absent means removed
  try {
    const { data } = await get(path + id);
    if (SCHEDULED[kind]) return !SCHEDULED[kind].has(data.status); // finished or cancelled: it left the schedule
    return false; // a task you can still read is still there
  } catch (error) {
    if (error.status === 404) return true; // deleted, or an archived order
    throw error; // a failed read removes nothing
  }
}

export async function cycle() {
  const state = JSON.parse(await readFile(STATE, "utf8").catch(() => "{}"));
  const today = Math.floor(Date.now() / DAY) * DAY;
  const from = today - 7 * DAY;
  const to = today + 60 * DAY;
  const startDate = iso(from);
  const endDate = iso(to);

  const schedule = await readSchedule(from, to);
  const services = await get("/planner/services", { startDate, endDate, orderStatus: "all" });
  const absences = [];
  for (const type of ["staff", "vehicle", "space"]) {
    absences.push(...(await listUnavailabilities(type, startDate, endDate)));
  }

  const next = toEvents(schedule.data, groupServices(services.data), absences);
  const known = state.events ?? {};
  const upsert = [];
  const remove = [];

  for (const [id, event] of next) {
    const json = JSON.stringify(event);
    if (known[id]?.json !== json) upsert.push({ id, ...event });
    known[id] = { json, start: event.start, end: event.end ?? event.start };
  }
  // Only judge events that overlap this window; the rest simply scrolled out of it. When a layer
  // may have been cut, judge none: a record that did not fit looks exactly like a removed one.
  if (schedule.complete) {
    for (const [id, held] of Object.entries(known)) {
      if (!next.has(id) && held.end >= startDate && held.start < endDate && (await isGone(id, held))) {
        remove.push(id);
        delete known[id];
      }
    }
  }

  await writeFile(STATE, JSON.stringify({ events: known }));
  return { upsert, remove }; // send these to your calendar's own API
}

console.log(await cycle());

# mirror.py: one cycle of the calendar mirror. Run it every 5 minutes.
import json
from datetime import datetime, timedelta, timezone

import requests

from filmo import get
from unavailabilities import list_unavailabilities

STATE = "schedule-mirror.json"
LAYERS = ("projects", "orders", "tasks", "internalServices")

# The schedule returns at most this many records per layer and says nothing when it cuts the list.
CAP = {"projects": 200, "orders": 200, "tasks": 500}
# It also leaves out finished and cancelled records: these are the states it still shows.
SCHEDULED = {
    "order": {"draft", "reserved", "prepared_partially", "prepared", "picked_up_partially", "picked_up",
              "returned_partially", "returned", "checked_in_partially"},
    "project": {"draft", "budgeted", "confirmed", "in_progress"},
}


def iso(moment):
    return moment.isoformat().replace("+00:00", "Z")


def read_schedule(start, end):
    """A layer that comes back exactly full may have been cut: read the window again in halves."""
    data = get("/schedule", startDate=iso(start), endDate=iso(end), layers="projects,orders,tasks,internal_services")["data"]
    if not any(len(data[layer]) >= cap for layer, cap in CAP.items()):
        return data, True
    if end - start <= timedelta(days=1):
        return data, False  # a single day is still cut
    middle = start + (end - start) / 2
    first, first_ok = read_schedule(start, middle)
    second, second_ok = read_schedule(middle, end)
    merged = {layer: list({x["id"]: x for x in first[layer] + second[layer]}.values()) for layer in LAYERS}
    return merged, first_ok and second_ok


def group_services(rows):
    """A service comes as one "summary" row plus one "detail" row per person or vehicle assigned,
    all with the same orderServiceId. Internal services (empty orderId) are already in the schedule."""
    by_service = {}
    for row in rows:
        if row["orderId"] == "":
            continue
        service = by_service.setdefault(row["orderServiceId"], {"staff": [], "vehicles": []})
        if row["rowKind"] == "summary":
            service.update(row)  # the service itself
        else:
            if row["staffMemberId"]:
                service["staff"].append(row["staffMemberId"])
            if row["vehicleId"]:
                service["vehicles"].append(row["vehicleId"])
    return list(by_service.values())


def to_events(schedule, services, absences):
    """One item of each layer becomes one calendar event, keyed by layer and id."""
    events = {}
    for p in schedule["projects"]:
        events["project:" + p["id"]] = {"title": p["name"], "start": p["startDate"], "end": p["endDate"]}
    for o in schedule["orders"]:
        events["order:" + o["id"]] = {"title": "Order " + o["orderNumber"], "start": o["startDate"], "end": o["endDate"]}
    for t in schedule["tasks"]:
        if not t["startDate"]:
            continue
        events["task:" + t["id"]] = {
            "title": t["title"], "start": t["startDate"], "end": t["endDate"], "allDay": t["isAllDay"],
            "done": t["isCompleted"], "staff": [s["id"] for s in t["assignedStaff"]],
        }
    for s in schedule["internalServices"]:
        events["internal:" + s["id"]] = {
            "title": s["title"], "start": s["startDate"], "end": s["endDate"],
            "staff": [m["id"] for m in s["assignedStaff"]],
        }
    for s in services:
        events["service:" + s["orderServiceId"]] = {
            "title": s["serviceName"] + " (" + s["orderNumber"] + ")", "start": s["startDate"], "end": s["endDate"],
            "staff": s["staff"], "vehicles": s["vehicles"],
        }
    for a in absences:
        events["absence:" + a["id"]] = {
            "title": (a["resourceName"] or a["resourceId"]) + " " + a["state"], "start": a["startDate"], "end": a["endDate"],
        }
    return events


def is_gone(key, held):
    """Missing from a read is only a suspicion. Confirm it with the record's own read."""
    kind, record_id = key.split(":", 1)
    # The list returns only the absences in force or still to come: one that ended drops out by itself.
    if kind == "absence":
        return held["end"] > iso(datetime.now(timezone.utc))
    path = {"project": "/projects/", "order": "/orders/", "task": "/tasks/"}.get(kind)
    if path is None:
        return True  # internal and planner services are not capped: absent means removed
    try:
        record = get(path + record_id)["data"]
    except requests.HTTPError as error:
        if error.response.status_code == 404:
            return True  # deleted, or an archived order
        raise  # a failed read removes nothing
    if kind in SCHEDULED:
        return record["status"] not in SCHEDULED[kind]  # finished or cancelled: it left the schedule
    return False  # a task you can still read is still there


def cycle():
    try:
        with open(STATE) as f:
            known = json.load(f)["events"]
    except FileNotFoundError:
        known = {}
    today = datetime.now(timezone.utc).replace(hour=0, minute=0, second=0, microsecond=0)
    start, end = today - timedelta(days=7), today + timedelta(days=60)

    schedule, complete = read_schedule(start, end)
    services = get("/planner/services", startDate=iso(start), endDate=iso(end), orderStatus="all")["data"]
    absences = []
    for kind in ("staff", "vehicle", "space"):
        absences += list_unavailabilities(kind, iso(start), iso(end))

    nxt = to_events(schedule, group_services(services), absences)
    upsert, remove = [], []
    for event_id, event in nxt.items():
        as_json = json.dumps(event, sort_keys=True)
        if known.get(event_id, {}).get("json") != as_json:
            upsert.append({"id": event_id, **event})
        known[event_id] = {"json": as_json, "start": event["start"], "end": event["end"] or event["start"]}
    # Only judge events that overlap this window; the rest simply scrolled out of it. When a layer
    # may have been cut, judge none: a record that did not fit looks exactly like a removed one.
    if complete:
        for event_id, held in list(known.items()):
            if event_id not in nxt and held["end"] >= iso(start) and held["start"] < iso(end) and is_gone(event_id, held):
                remove.append(event_id)
                del known[event_id]

    with open(STATE, "w") as f:
        json.dump({"events": known}, f)
    return {"upsert": upsert, "remove": remove}  # send these to your calendar's own API


print(cycle())

import { get } from "./filmo.mjs";

const { data: account } = await get("/account");
const instant = "2026-10-14T07:00:00Z"; // responses carry UTC

// Show it in the business timezone, whatever the server or the viewer is set to.
console.log(
  new Date(instant).toLocaleString("en-GB", { timeZone: account.timezone, dateStyle: "medium", timeStyle: "short" }),
);

// A write needs an offset. Build it from the business timezone, never from your server's.
// "2026-10-14T09:00:00+02:00" is the same instant as the one above in a UTC+2 timezone.

from datetime import datetime
from zoneinfo import ZoneInfo

from filmo import get

account = get("/account")["data"]
instant = datetime.fromisoformat("2026-10-14T07:00:00+00:00")  # responses carry UTC

# Show it in the business timezone, whatever the server or the viewer is set to.
print(instant.astimezone(ZoneInfo(account["timezone"])).strftime("%d %b %Y %H:%M"))

# A write needs an offset. Build it from the business timezone, never from your server's.
local = datetime(2026, 10, 14, 9, 0, tzinfo=ZoneInfo(account["timezone"]))
print(local.isoformat())  # for example 2026-10-14T09:00:00+02:00