@evolver-fi/evolver-basics-admin-components 0.0.20 → 1.0.0

package/dist/ScheduledTasksRoute-BAetDHqN.js

@@ -0,0 +1,611 @@
+import { redirect as M, useLoaderData as W, useParams as X, useNavigate as _, useSubmit as B, useActionData as Y, useNavigation as ee, useSearchParams as se } from "react-router";
+import { a as H, g as te } from "./pagination-Dy4ansKN.js";
+import { a as re } from "./api-BD_4zyJw.js";
+import { j as e } from "./jsx-runtime-D858t2LC.js";
+import K from "cronstrue";
+import { useState as F } from "react";
+import { Box as v, Collapse as ae, Alert as ie, Paper as ne, Typography as h, Stack as z, TextField as x, FormControl as E, InputLabel as C, Select as A, MenuItem as y, FormHelperText as oe, Button as g, CircularProgress as le, TableContainer as ce, Table as de, TableHead as ue, TableRow as U, TableCell as o, TableBody as me, TablePagination as he } from "@mui/material";
+import { e as D } from "./exhaustiveValues-Dx50G3yz.js";
+import { s as p, N as $, o as G, _ as Z, n as T } from "./schemas-CBHIJ_eF.js";
+const ge = async (r, t) => {
+  const s = await t.GET("/schedule", {
+    params: {
+      query: r
+    }
+  });
+  if ("error" in s)
+    throw new Error(`Failed to fetch scheduled tasks: ${s.response.status}`);
+  return s.data;
+}, pe = async (r, t) => {
+  const s = await t.GET("/schedule/{id}", {
+    params: {
+      path: { id: r }
+    }
+  });
+  if ("error" in s)
+    throw new Error(`Failed to fetch scheduled task: ${s.response.status}`);
+  return s.data;
+}, xe = async (r, t) => {
+  const s = await t.POST("/schedule", {
+    body: r
+  });
+  if ("error" in s)
+    throw new Error(`Failed to save scheduled task: ${s.response.status}`);
+  return s.response.status;
+}, Te = async (r, t) => {
+  const s = await t.POST("/schedule/{id}/delete", {
+    params: {
+      path: { id: r }
+    }
+  });
+  if ("error" in s)
+    throw new Error(`Failed to delete scheduled task: ${s.response.status}`);
+  return s.response.status;
+}, je = async (r, t) => {
+  const s = await t.POST("/schedule/{id}/run", {
+    params: {
+      path: { id: r }
+    }
+  });
+  if ("error" in s)
+    throw new Error(`Failed to trigger scheduled task: ${s.response.status}`);
+  return s.response.status;
+}, fe = async (r, t, s) => {
+  if (!t)
+    throw new Error("State is required to update scheduled task state");
+  const a = await s.POST("/schedule/{id}/state/{state}", {
+    params: {
+      path: { id: r, state: t }
+    }
+  });
+  if ("error" in a)
+    throw new Error(`Failed to update scheduled task state: ${a.response.status}`);
+  return a.response.status;
+}, We = (r) => async ({ request: t }) => {
+  try {
+    const s = await t.json();
+    switch (s.type) {
+      case "save": {
+        if (!s.task)
+          return { status: 400, message: "Task data is required" };
+        const a = await xe(s.task, r);
+        if (a === 204) {
+          if (s.task.id === void 0 || s.task.id === 0)
+            throw M("/scheduled-tasks");
+          return {
+            status: 204,
+            message: "Task updated"
+          };
+        }
+        return { status: a, message: "Failed to save task" };
+      }
+      case "delete": {
+        if (!s.id)
+          return { status: 400, message: "Task ID is required" };
+        const a = await Te(s.id, r);
+        if (a === 204)
+          throw M("/scheduled-tasks");
+        return a === 404 ? { status: 404, message: "Task not found" } : { status: a, message: "Failed to delete task" };
+      }
+      default:
+        return { status: 400, message: "Invalid action type" };
+    }
+  } catch (s) {
+    if (s instanceof Response && s.status >= 300 && s.status < 400)
+      throw s;
+    return console.error(s), {
+      status: 500,
+      message: "Failed to process request"
+    };
+  }
+}, _e = (r) => async ({ request: t }) => {
+  try {
+    const s = await t.json();
+    switch (s.type) {
+      case "trigger": {
+        if (!s.id)
+          return { status: 400, message: "Task ID is required" };
+        const a = await je(s.id, r);
+        return a === 200 || a === 204 ? { status: a, message: "Task triggered" } : { status: a, message: "Failed to trigger task" };
+      }
+      case "updateState": {
+        if (!s.id || !s.state)
+          return {
+            status: 400,
+            message: "Task ID and state are required"
+          };
+        const a = await fe(s.id, s.state, r);
+        return a === 200 || a === 204 ? { status: a, message: "Task state updated" } : {
+          status: a,
+          message: "Failed to update task state"
+        };
+      }
+      default:
+        return { status: 400, message: "Invalid action type" };
+    }
+  } catch (s) {
+    return console.error(s), {
+      status: 500,
+      message: "Failed to process request"
+    };
+  }
+}, be = () => ({
+  name: "",
+  state: "WAITING",
+  cronExpression: "",
+  timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+  triggerable: "",
+  priority: 0,
+  timeoutMs: 0,
+  missPolicy: "SKIP_ALL",
+  args: {}
+}), Be = (r) => async ({ params: t }) => {
+  const s = t.id, a = await re(r);
+  if (s === "new")
+    return {
+      task: be(),
+      triggerables: a
+    };
+  if (!s && s !== "0" || Number.isNaN(parseInt(s, 10)))
+    throw new Response("", {
+      status: 404,
+      statusText: "Not found"
+    });
+  const d = parseInt(s, 10);
+  return {
+    task: await pe(d, r),
+    triggerables: a
+  };
+}, He = (r) => async ({ request: t }) => {
+  try {
+    const s = new URL(t.url), a = H(s.searchParams);
+    return await ge(a, r);
+  } catch (s) {
+    throw console.error(s), new Error("Failed to fetch scheduled tasks");
+  }
+}, R = D()([
+  "WAITING",
+  "RUNNING",
+  "PAUSED"
+]), L = D()([
+  "SKIP_ALL",
+  "RUN_ONCE",
+  "RUN_ALL"
+]), ke = (r) => R.some((t) => t === r), ye = (r) => L.some((t) => t === r), ve = (r) => {
+  const t = r.trim();
+  try {
+    return K.toString(t, {
+      use24HourTimeFormat: !0
+    }), !0;
+  } catch {
+    return !1;
+  }
+}, Se = (r) => {
+  try {
+    return Intl.DateTimeFormat(void 0, { timeZone: r }), !0;
+  } catch {
+    return !1;
+  }
+}, we = p().transform((r, t) => {
+  try {
+    const s = JSON.parse(r || "{}");
+    return !s || typeof s != "object" || Array.isArray(s) ? (t.addIssue({
+      code: "custom",
+      message: "Args must be a JSON object"
+    }), $) : Object.fromEntries(
+      Object.entries(s).map(([a, d]) => [a, String(d)])
+    );
+  } catch {
+    return t.addIssue({
+      code: "custom",
+      message: "Args must be valid JSON"
+    }), $;
+  }
+}), Ie = G({
+  task: G({
+    id: T().optional(),
+    name: p().trim().min(1, { message: "Name is required" }),
+    state: Z(R).optional(),
+    cronExpression: p().trim().min(1, { message: "Cron expression is required" }).refine(ve, {
+      message: "Cron expression must be a valid Spring cron expression"
+    }),
+    timeZone: p().trim().min(1, { message: "Time zone is required" }).refine(Se, { message: "Invalid IANA time zone" }),
+    lastFiredTime: T().optional(),
+    lastFinishedTime: T().optional(),
+    nextFireTime: T().optional(),
+    triggerable: p().trim().min(1, { message: "Triggerable is required" }),
+    priority: T().refine(Number.isFinite, { message: "Priority is required" }).refine(Number.isInteger, { message: "Priority must be an integer" }),
+    timeoutMs: T().refine(Number.isFinite, { message: "Timeout is required" }).refine(Number.isInteger, { message: "Timeout must be an integer" }).refine((r) => r >= 0, { message: "Timeout must be zero or greater" }),
+    missPolicy: Z(L),
+    lastInitiator: p().optional(),
+    running: p().optional()
+  }),
+  argsText: we
+}).transform(
+  ({ task: r, argsText: t }) => ({
+    ...r,
+    args: t
+  })
+), Ne = D()([
+  "id",
+  "name",
+  "state",
+  "cronExpression",
+  "timeZone",
+  "lastFiredTime",
+  "lastFinishedTime",
+  "nextFireTime",
+  "triggerable",
+  "priority",
+  "timeoutMs",
+  "missPolicy",
+  "lastInitiator",
+  "running",
+  "args"
+]), Pe = (r) => typeof r == "string" && Ne.some((t) => t === r), Fe = (r) => {
+  const [t, s] = r;
+  if (t === "argsText")
+    return "args";
+  if (t === "task" && Pe(s))
+    return s;
+}, Ee = (r, t) => {
+  const s = Ie.safeParse({ task: r, argsText: t });
+  if (s.success)
+    return { ok: !0, value: s.data };
+  const a = {};
+  return s.error.issues.forEach((d) => {
+    const l = Fe(d.path);
+    l !== void 0 && !(l in a) && (a[l] = d.message);
+  }), { ok: !1, errors: a };
+}, O = (r) => r === void 0 ? "-" : new Date(r).toISOString(), Ce = (r) => JSON.stringify(r ?? {}, null, 2), Ae = (r) => {
+  const t = r.name ?? "(unnamed)", s = r.type ? `: ${r.type}` : "", a = r.required ? "required" : "optional";
+  return `${t}${s} (${a})`;
+}, Oe = (r) => {
+  if (r.trim())
+    try {
+      return K.toString(r, {
+        use24HourTimeFormat: !0
+      });
+    } catch {
+      return;
+    }
+}, Ke = () => {
+  const r = W(), [t, s] = F(r.task), [a, d] = F(Ce(r.task.args)), [l, j] = F({}), f = Object.keys(r.triggerables).sort((i, u) => i.localeCompare(u)), S = t.triggerable && !f.includes(t.triggerable) ? [t.triggerable, ...f] : f, k = r.triggerables[t.triggerable] ?? [], w = k.length ? k.map(Ae).join(", ") : "Selected triggerable does not declare args.", I = Oe(t.cronExpression), b = X(), { id: n } = b, c = _(), m = B(), N = Y(), J = () => {
+    n === "new" || t.id === void 0 || !window.confirm(`Delete scheduled task "${t.name || t.id}"?`) || m(
+      { type: "delete", id: t.id },
+      {
+        method: "POST",
+        encType: "application/json"
+      }
+    );
+  }, V = () => {
+    const i = Ee(t, a);
+    if (!i.ok) {
+      j(i.errors);
+      return;
+    }
+    j({});
+    let u;
+    if (n !== "new" && i.value.id !== 0)
+      u = i.value;
+    else {
+      const { id: qe, ...Q } = i.value;
+      u = Q;
+    }
+    m(
+      { type: "save", task: u },
+      {
+        method: "POST",
+        encType: "application/json"
+      }
+    );
+  }, P = N ? {
+    severity: N.status < 300 ? "success" : "error",
+    message: N.message
+  } : null;
+  return /* @__PURE__ */ e.jsxs(v, { component: "section", sx: { p: 2, maxWidth: 1e3 }, children: [
+    /* @__PURE__ */ e.jsx(ae, { in: P !== null, unmountOnExit: !0, children: /* @__PURE__ */ e.jsx(ie, { severity: P?.severity, children: P?.message }) }),
+    /* @__PURE__ */ e.jsxs(ne, { sx: { p: 2, mt: 2 }, children: [
+      /* @__PURE__ */ e.jsx(h, { variant: "h4", component: "h1", sx: { mb: 2 }, children: n === "new" ? "New scheduled task" : "Edit scheduled task" }),
+      /* @__PURE__ */ e.jsxs(z, { gap: 2, children: [
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            label: "Name",
+            required: !0,
+            value: t.name,
+            error: !!l.name,
+            helperText: l.name,
+            onChange: (i) => s({ ...t, name: i.target.value })
+          }
+        ),
+        /* @__PURE__ */ e.jsxs(E, { children: [
+          /* @__PURE__ */ e.jsx(C, { id: "scheduled-task-state-label", children: "State" }),
+          /* @__PURE__ */ e.jsx(
+            A,
+            {
+              labelId: "scheduled-task-state-label",
+              label: "State",
+              value: t.state ?? "WAITING",
+              onChange: (i) => {
+                const u = i.target.value;
+                ke(u) && s({
+                  ...t,
+                  state: u
+                });
+              },
+              children: R.map((i) => /* @__PURE__ */ e.jsx(y, { value: i, children: i }, i))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            label: "Cron expression",
+            required: !0,
+            value: t.cronExpression,
+            error: !!l.cronExpression,
+            helperText: l.cronExpression ?? I ?? "Cron preview unavailable. The value will still be submitted to the backend.",
+            onChange: (i) => s({ ...t, cronExpression: i.target.value })
+          }
+        ),
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            label: "Time zone",
+            required: !0,
+            value: t.timeZone,
+            error: !!l.timeZone,
+            helperText: l.timeZone ?? "IANA time zone, for example Europe/Helsinki or UTC.",
+            onChange: (i) => s({ ...t, timeZone: i.target.value })
+          }
+        ),
+        /* @__PURE__ */ e.jsxs(E, { required: !0, error: !!l.triggerable, children: [
+          /* @__PURE__ */ e.jsx(C, { id: "scheduled-task-triggerable-label", children: "Triggerable" }),
+          /* @__PURE__ */ e.jsxs(
+            A,
+            {
+              labelId: "scheduled-task-triggerable-label",
+              label: "Triggerable",
+              value: t.triggerable,
+              onChange: (i) => s({ ...t, triggerable: i.target.value }),
+              children: [
+                /* @__PURE__ */ e.jsx(y, { value: "", children: /* @__PURE__ */ e.jsx("em", { children: "Select triggerable" }) }),
+                S.map((i) => /* @__PURE__ */ e.jsx(y, { value: i, children: i }, i))
+              ]
+            }
+          ),
+          /* @__PURE__ */ e.jsx(oe, { children: l.triggerable ?? "Fetched from the triggerables endpoint." })
+        ] }),
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            type: "number",
+            label: "Priority",
+            value: t.priority,
+            error: !!l.priority,
+            helperText: l.priority,
+            onChange: (i) => s({
+              ...t,
+              priority: Number.parseInt(i.target.value, 10)
+            })
+          }
+        ),
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            type: "number",
+            label: "Timeout, ms",
+            value: t.timeoutMs,
+            error: !!l.timeoutMs,
+            helperText: l.timeoutMs,
+            onChange: (i) => s({
+              ...t,
+              timeoutMs: Number.parseInt(i.target.value, 10)
+            })
+          }
+        ),
+        /* @__PURE__ */ e.jsxs(E, { children: [
+          /* @__PURE__ */ e.jsx(C, { id: "scheduled-task-miss-policy-label", children: "Miss policy" }),
+          /* @__PURE__ */ e.jsx(
+            A,
+            {
+              labelId: "scheduled-task-miss-policy-label",
+              label: "Miss policy",
+              value: t.missPolicy,
+              onChange: (i) => {
+                const u = i.target.value;
+                ye(u) && s({
+                  ...t,
+                  missPolicy: u
+                });
+              },
+              children: L.map((i) => /* @__PURE__ */ e.jsx(y, { value: i, children: i }, i))
+            }
+          )
+        ] }),
+        /* @__PURE__ */ e.jsx(
+          x,
+          {
+            label: "Args",
+            multiline: !0,
+            minRows: 4,
+            value: a,
+            error: !!l.args,
+            helperText: l.args ?? "JSON object. Values are saved as strings.",
+            onChange: (i) => d(i.target.value)
+          }
+        ),
+        t.triggerable && /* @__PURE__ */ e.jsxs(
+          v,
+          {
+            sx: {
+              mt: -1,
+              px: 1.75,
+              py: 1,
+              bgcolor: "grey.100",
+              borderRadius: 1
+            },
+            children: [
+              /* @__PURE__ */ e.jsxs(h, { variant: "caption", color: "text.secondary", component: "div", children: [
+                "Declared args for ",
+                t.triggerable
+              ] }),
+              /* @__PURE__ */ e.jsx(h, { variant: "body2", children: w })
+            ]
+          }
+        ),
+        n !== "new" && /* @__PURE__ */ e.jsxs(v, { component: "dl", sx: { display: "grid", gridTemplateColumns: "160px 1fr", gap: 1 }, children: [
+          /* @__PURE__ */ e.jsx(h, { component: "dt", children: "Last fired" }),
+          /* @__PURE__ */ e.jsx(h, { component: "dd", sx: { m: 0 }, children: O(t.lastFiredTime) }),
+          /* @__PURE__ */ e.jsx(h, { component: "dt", children: "Last finished" }),
+          /* @__PURE__ */ e.jsx(h, { component: "dd", sx: { m: 0 }, children: O(t.lastFinishedTime) }),
+          /* @__PURE__ */ e.jsx(h, { component: "dt", children: "Next fire" }),
+          /* @__PURE__ */ e.jsx(h, { component: "dd", sx: { m: 0 }, children: O(t.nextFireTime) })
+        ] }),
+        /* @__PURE__ */ e.jsxs(z, { direction: "row", gap: 1, children: [
+          /* @__PURE__ */ e.jsx(g, { variant: "contained", onClick: V, children: "Save" }),
+          n !== "new" && /* @__PURE__ */ e.jsx(g, { color: "error", variant: "outlined", onClick: J, children: "Delete" }),
+          /* @__PURE__ */ e.jsx(g, { variant: "outlined", onClick: () => c("/scheduled-tasks"), children: "Cancel" })
+        ] })
+      ] })
+    ] })
+  ] });
+}, q = (r) => r === void 0 ? "-" : new Date(r).toISOString(), Je = () => {
+  const r = _(), t = ee(), s = B(), [a, d] = se(), l = H(a), j = t.state, f = W(), { content: S, totalElements: k } = f, w = (n) => {
+    d(te(a, n));
+  }, I = (n) => {
+    s(
+      { type: "trigger", id: n },
+      {
+        method: "POST",
+        encType: "application/json"
+      }
+    );
+  }, b = (n, c) => {
+    s(
+      { type: "updateState", id: n, state: c },
+      {
+        method: "POST",
+        encType: "application/json"
+      }
+    );
+  };
+  return j === "loading" ? /* @__PURE__ */ e.jsx(le, {}) : /* @__PURE__ */ e.jsxs(e.Fragment, { children: [
+    /* @__PURE__ */ e.jsx(v, { sx: { p: 1 }, children: /* @__PURE__ */ e.jsx(g, { variant: "contained", onClick: () => r("./new", { relative: "path" }), children: "New scheduled task" }) }),
+    /* @__PURE__ */ e.jsx(ce, { sx: { height: "calc(100vh - 180px)" }, children: /* @__PURE__ */ e.jsxs(de, { size: "small", stickyHeader: !0, children: [
+      /* @__PURE__ */ e.jsx(ue, { children: /* @__PURE__ */ e.jsxs(U, { children: [
+        /* @__PURE__ */ e.jsx(o, { children: "Name" }),
+        /* @__PURE__ */ e.jsx(o, { children: "State" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Cron expression" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Time zone" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Last fired" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Last finished" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Next fire" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Triggerable" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Priority" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Timeout, ms" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Miss policy" }),
+        /* @__PURE__ */ e.jsx(o, { children: "Trigger" }),
+        /* @__PURE__ */ e.jsx(o, { children: "State action" })
+      ] }) }),
+      /* @__PURE__ */ e.jsx(me, { children: (S ?? []).map((n) => {
+        const c = n.id;
+        return /* @__PURE__ */ e.jsxs(
+          U,
+          {
+            hover: !0,
+            sx: { cursor: c !== void 0 ? "pointer" : "default" },
+            onClick: () => {
+              c !== void 0 && r(`/scheduled-tasks/${c}`);
+            },
+            children: [
+              /* @__PURE__ */ e.jsx(o, { children: n.name }),
+              /* @__PURE__ */ e.jsx(o, { children: n.state }),
+              /* @__PURE__ */ e.jsx(o, { children: n.cronExpression }),
+              /* @__PURE__ */ e.jsx(o, { children: n.timeZone }),
+              /* @__PURE__ */ e.jsx(o, { children: q(n.lastFiredTime) }),
+              /* @__PURE__ */ e.jsx(o, { children: q(n.lastFinishedTime) }),
+              /* @__PURE__ */ e.jsx(o, { children: q(n.nextFireTime) }),
+              /* @__PURE__ */ e.jsx(o, { children: n.triggerable }),
+              /* @__PURE__ */ e.jsx(o, { children: n.priority }),
+              /* @__PURE__ */ e.jsx(o, { children: n.timeoutMs }),
+              /* @__PURE__ */ e.jsx(o, { children: n.missPolicy }),
+              /* @__PURE__ */ e.jsx(o, { children: c !== void 0 && n.state !== "RUNNING" && /* @__PURE__ */ e.jsx(
+                g,
+                {
+                  size: "small",
+                  onClick: (m) => {
+                    m.stopPropagation(), I(c);
+                  },
+                  children: "Trigger"
+                }
+              ) }),
+              /* @__PURE__ */ e.jsxs(o, { children: [
+                c !== void 0 && n.state === "PAUSED" && /* @__PURE__ */ e.jsx(
+                  g,
+                  {
+                    size: "small",
+                    onClick: (m) => {
+                      m.stopPropagation(), b(c, "WAITING");
+                    },
+                    children: "Activate"
+                  }
+                ),
+                c !== void 0 && n.state === "WAITING" && /* @__PURE__ */ e.jsx(
+                  g,
+                  {
+                    size: "small",
+                    onClick: (m) => {
+                      m.stopPropagation(), b(c, "PAUSED");
+                    },
+                    children: "Pause"
+                  }
+                ),
+                c !== void 0 && n.state === "RUNNING" && /* @__PURE__ */ e.jsx(
+                  g,
+                  {
+                    size: "small",
+                    onClick: (m) => {
+                      m.stopPropagation(), b(c, "WAITING");
+                    },
+                    children: "Stop"
+                  }
+                )
+              ] })
+            ]
+          },
+          c ?? n.name
+        );
+      }) })
+    ] }) }),
+    /* @__PURE__ */ e.jsx(
+      he,
+      {
+        component: "div",
+        count: k ?? 0,
+        rowsPerPage: l.size ?? 100,
+        page: l.page,
+        onPageChange: (n, c) => w(c),
+        rowsPerPageOptions: [],
+        showFirstButton: !0,
+        showLastButton: !0
+      }
+    )
+  ] });
+};
+export {
+  Ke as S,
+  Je as a,
+  ge as b,
+  _e as c,
+  Te as d,
+  He as e,
+  pe as f,
+  We as g,
+  Be as h,
+  je as r,
+  xe as s,
+  fe as u
+};
+//# sourceMappingURL=ScheduledTasksRoute-BAetDHqN.js.map