Nessuna scatola nera. Il sorgente è lì, e si apre.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

{
  "columns": {
    "praticaId":       { "type": "id", "primaryKey": true },
    "ownerUserId":     { "type": "reference", "nullable": false },
    "clienteId":       { "type": "reference", "references": { "table": "clienti", "column": "clienteId" } },
    "titolo":          { "type": "text", "nullable": false, "minLen": 3, "maxLen": 160 },
    "stato":           { "type": "enum", "enum": ["aperta", "in_corso", "sospesa", "chiusa"], "default": "aperta" },
    "priorita":        { "type": "enum", "enum": ["bassa", "media", "alta"], "default": "media" },
    "scadenza":        { "type": "datetime", "nullable": true },
    "createdAt":       { "type": "datetime", "default": "now" }
  },
  "indexes": [{ "columns": ["ownerUserId"] }, { "columns": ["stato"] }],

  "access": {
    "ops": {
      "list":   { "who": ["owner", "role:staff"] },
      "get":    { "who": ["owner", "role:staff"] },
      "update": { "who": ["role:staff"] },
      "delete": { "who": ["role:staff"] }
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import { data, db, req, tokenData, fail } from "@spelltech/api-sdk";
import { PRIORITA } from "@lib/pratiche.js";

export const description = "Apre una nuova pratica a nome di chi chiama";
export const access = ["authenticated"];

export const input = {
  titolo:      { type: "text", required: true, minLen: 3, maxLen: 160 },
  descrizione: { type: "text", maxLen: 4000 },
  priorita:    "enum:bassa|media|alta?",
  clienteId:   "text?",
};

export default async () => {
  if (data.clienteId) {
    const cliente = await db.clienti.findFirst({ where: { clienteId: data.clienteId } });
    if (!cliente) fail("CLIENTE_INESISTENTE", "Questo cliente non è in anagrafica", { fields: ["clienteId"] });
  }

  const pratica = await db.pratiche.create({
    data: {
      ownerUserId: tokenData.userId,
      titolo: String(data.titolo).trim(),
      priorita: PRIORITA.includes(data.priorita) ? data.priorita : "media",
      stato: "aperta",
    },
  });

  req.toast({ type: "success", text: "Richiesta inviata: la trovi fra le tue pratiche" });
  return { data: { praticaId: pratica.praticaId } };
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

import { useState } from "react";
import { definePage, useApiState } from "@spelltech/react";
import { Badge, Button, Card, EmptyState, PageHeader, ToggleGroup, ToggleGroupItem } from "@spelltech/ui";

export default definePage(Pratiche, {
  title: "Pratiche",
  nav: { label: "Pratiche", icon: "folder-open", order: 20 },
});

const WHERE = {
  aperte: { stato: { in: ["aperta", "in_corso", "sospesa"] } },
  chiuse: { stato: "chiusa" },
  tutte:  {},
};

function Pratiche() {
  const [filtro, setFiltro] = useState("aperte");
  const { data, loading } = useApiState("pratiche.list", {
    data: { where: WHERE[filtro], sort: "createdAt", order: "desc", limit: 200 },
  });

  return (
    <>
      <PageHeader title="Pratiche" description="Tutto quello che è stato chiesto, con il suo stato." />

      <ToggleGroup type="single" value={filtro} onValueChange={setFiltro}>
        <ToggleGroupItem value="aperte">Aperte</ToggleGroupItem>
        <ToggleGroupItem value="chiuse">Chiuse</ToggleGroupItem>
        <ToggleGroupItem value="tutte">Tutte</ToggleGroupItem>
      </ToggleGroup>

      {data?.items.map((p) => (
        <Card key={p.praticaId} className="p-4">
          <div className="font-medium">{p.titolo}</div>
          <Badge>{p.stato}</Badge>
        </Card>
      ))}
    </>
  );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

import { db, mail } from "@spelltech/api-sdk";

export const schedule = "0 * * * *";   // ogni ora

const FINESTRA_ORE = 24;

export default async function () {
  const fino = new Date(Date.now() + FINESTRA_ORE * 3_600_000).toISOString();

  const fasce = await db.fasce.findMany({
    where: { inizio: { gte: new Date().toISOString(), lte: fino } },
    take: 500,
  });
  if (!fasce.length) return;

  const prenotazioni = await db.prenotazioni.findMany({
    where: { fasciaId: { in: fasce.map((f) => f.fasciaId) }, stato: "confermata" },
  });

  for (const p of prenotazioni) {
    if (p.promemoriaAt) continue;        // il timbro impedisce il doppio invio
    await mail.send({ to: p.email, template: "promemoria", data: { nome: p.nome } });
    await db.prenotazioni.update({
      where: { prenotazioneId: p.prenotazioneId },
      data: { promemoriaAt: new Date().toISOString() },
    });
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

{
  "permissions": {
    "pratiche.gestisci": { "label": "Prende in carico e chiude le pratiche di chiunque" },
    "clienti.gestisci":  { "label": "Tiene l'anagrafica dei clienti" },
    "persone.gestisci":  { "label": "Invita le persone e assegna i ruoli" }
  },

  "roles": {
    "staff": {
      "label": "Staff",
      "description": "Lavora le pratiche di tutti, tiene l'anagrafica e invita le persone",
      "permissions": ["*"]
    },
    "cliente": {
      "label": "Cliente",
      "description": "Apre le proprie richieste e ne segue l'avanzamento",
      "permissions": [],
      "default": true
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

{
  "region": "fra",
  "size":   { "cpuKind": "shared", "cpus": 2, "memoryMb": 2048 },
  "diskGb": 10,

  "image":  { "base": "debian:bookworm", "packages": ["ffmpeg", "nodejs"] },
  "start":  "node server.mjs",

  "ports": [
    { "name": "http", "port": 8080, "access": "public" }
  ],

  "secrets": ["STRIPE_KEY"],
  "sleep":   { "enabled": true, "afterMin": 3 },
  "grants":  ["db", "fs"]
}