@raketa-cloud/admin 0.0.15 → 0.0.16

package/src/handlers/event_revisions/GeneralHandler.js

@@ -0,0 +1,93 @@
+import { toDateTimeInput, toUTCISO8601String } from "../../utils";
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const general_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    title: revision.title,
+    slug: revision.slug,
+    publish_at: toDateTimeInput(revision.publishAt),
+    starts_at: toDateTimeInput(revision.startsAt),
+    ends_at: toDateTimeInput(revision.endsAt),
+    visibility: revision.visibility,
+    username: revision.settings?.credentials?.user || "",
+    password: revision.settings?.credentials?.password || "",
+  };
+
+  return {
+    assigns: {
+      general_settings,
+      errors: {},
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.general_settings;
+
+  const { errors } = await ctx.client.eventRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: params.slug,
+      title: params.title,
+      visibility: params.visibility,
+      publishAt: toUTCISO8601String(params.publish_at),
+      startsAt: toUTCISO8601String(params.starts_at),
+      endsAt: toUTCISO8601String(params.ends_at),
+      widgets: JSON.stringify(revision.widgets),
+      tags: revision.tags.map((t) => t.id),
+      categories: revision.categories.map((c) => c.id),
+      settings: JSON.stringify({
+        ...revision.settings,
+        credentials: {
+          user: params.username,
+          password: params.password,
+        },
+      }),
+    }
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        general_settings: {
+          ...params,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          general_settings: ctx.client.eventRevisions.formatErrors(errors),
+        },
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/event_revisions/${revision.id}/general/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/event_revisions/LocksHandler.js

@@ -0,0 +1,51 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  const lock_settings = {
+    revision,
+    message: "",
+  };
+
+  return {
+    assigns: {
+      lock_settings,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { message } = ctx.resourceParams.lock_settings;
+
+  const { revision, errors, eventErrors } =
+    await ctx.client.eventRevisions.lock(parent_id, ctx.locale, message);
+
+  if (errors) {
+    return {
+      assigns: {
+        lock_settings: { revision, message },
+        errors: {
+          lock_settings: ctx.client.events.formatErrors(errors, "message"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  if (eventErrors) {
+    throw `Failed to lock revisions: ${JSON.stringify(eventErrors)}`;
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events/${revision.originalId}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/event_revisions/MetaHandler.js

@@ -0,0 +1,86 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const meta_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    title: revision.settings.meta?.title || "",
+    description: revision.settings.meta?.description || "",
+    image: revision.settings.meta?.image || {},
+  };
+
+  return {
+    assigns: {
+      meta_settings,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.meta_settings;
+
+  const { errors } = await ctx.client.eventRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: revision.slug,
+      title: revision.title,
+      visibility: revision.visibility,
+      publishAt: revision.publishAt,
+      startsAt: revision.startsAt,
+      endsAt: revision.endsAt,
+      widgets: JSON.stringify(revision.widgets),
+      tags: revision.tags.map((t) => t.id),
+      categories: revision.categories.map((c) => c.id),
+      settings: JSON.stringify({
+        ...revision.settings,
+        meta: {
+          title: params.title,
+          description: params.description,
+          image: JSON.parse(params.image),
+        },
+      }),
+    }
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        meta_settings: {
+          ...params,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          meta_settings: ctx.client.eventRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/event_revisions/${revision.id}/meta/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/event_revisions/PublishesHandler.js

@@ -0,0 +1,84 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  return {
+    assigns: {
+      publishing: {
+        id: revision.id,
+        originalId: revision.originalId,
+        title: revision.meta.title,
+        description: revision.meta.description,
+        visibility: revision.visibility,
+        username: revision.settings?.credentials?.user,
+        password: revision.settings?.credentials?.password,
+      },
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+function publishEventParams(
+  { visibility, username, password },
+  currentSettings
+) {
+  if (visibility === "protected") {
+    const credentials = {
+      user: username,
+      password: password,
+    };
+
+    return {
+      visibility,
+      settings: JSON.stringify({
+        ...currentSettings,
+        credentials,
+      }),
+    };
+  }
+
+  return { visibility };
+}
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const publishing = ctx.resourceParams.publishing;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+  const { errors } = await ctx.client.eventRevisions.publish(
+    revision.id,
+    ctx.locale,
+    {
+      title: publishing.title || "",
+      description: publishing.description || "",
+    },
+    publishEventParams(publishing, revision.settings)
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        publishing: {
+          ...publishing,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        errors: ctx.client.eventRevisions.formatErrors(errors),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events/${revision.originalId}`,
+  };
+};
+
+export default {
+  create,
+  create_form,
+};

package/src/handlers/event_revisions/RevertsHandler.js

@@ -0,0 +1,26 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { version } = ctx.resourceParams;
+
+  const { errors, eventErrors } = await ctx.client.eventRevisions.revert(
+    parent_id,
+    Number.parseInt(version, 10),
+    ctx.locale
+  );
+
+  if (errors) {
+    throw new Error(`Failed to start revision: ${JSON.stringify(errors)}`);
+  }
+
+  if (eventErrors) {
+    throw new Error(`Failed to start revision: ${JSON.stringify(eventErrors)}`);
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events/${parent_id}`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/event_revisions/TagHandler.js

@@ -0,0 +1,85 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  const tag_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    tags: revision.tags.map((t) => t.id),
+  };
+
+  return {
+    assigns: {
+      tag_settings,
+      errors: {},
+      tags: tags.list,
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.tag_settings;
+
+  const { errors } = await ctx.client.eventRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: revision.slug,
+      title: revision.title,
+      visibility: revision.visibility,
+      publishAt: revision.publishAt,
+      startsAt: revision.startsAt,
+      endsAt: revision.endsAt,
+      widgets: JSON.stringify(revision.widgets),
+      tags: params.tags,
+      categories: revision.categories.map((c) => c.id),
+      settings: JSON.stringify({
+        ...revision.settings,
+      }),
+    }
+  );
+
+  if (errors) {
+    const tags = await ctx.client.tags.all(ctx.locale);
+
+    return {
+      assigns: {
+        tag_settings: {
+          ...params,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          tag_settings: ctx.client.eventRevisions.formatErrors(errors),
+        },
+        tags: tags.list,
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/event_revisions/${revision.id}/tags/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/event_revisions/UnlocksHandler.js

@@ -0,0 +1,22 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const { revision, errors, eventErrors } =
+    await ctx.client.eventRevisions.unlock(parent_id, ctx.locale);
+
+  if (errors) {
+    throw new Error(`Failed to unlock revision: ${JSON.stringify(errors)}`);
+  }
+
+  if (eventErrors) {
+    throw `Failed to start revision: ${JSON.stringify(eventErrors)}`;
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events/${revision.originalId}`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/event_revisions/VisualHandler.js

@@ -0,0 +1,80 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const visual_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    layout: revision.settings.layout,
+  };
+
+  return {
+    assigns: {
+      visual_settings,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.visual_settings;
+
+  const { errors } = await ctx.client.eventRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: revision.slug,
+      title: revision.title,
+      visibility: revision.visibility,
+      publishAt: revision.publishAt,
+      startsAt: revision.startsAt,
+      endsAt: revision.endsAt,
+      widgets: JSON.stringify(revision.widgets),
+      tags: revision.tags.map((t) => t.id),
+      categories: revision.categories.map((c) => c.id),
+      settings: JSON.stringify({
+        ...revision.settings,
+        layout: params.layout,
+      }),
+    }
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        visual_settings: {
+          ...params,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          visual_settings: ctx.client.eventRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/event_revisions/${revision.id}/visuals/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/event_revisions/WidgetHandler.js

@@ -0,0 +1,41 @@
+const show = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+  const settings = await ctx.client.settings.find(ctx.locale);
+
+  return {
+    json: {
+      revision: { ...revision, websiteSettings: settings },
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  const params = ctx.resourceParams;
+
+  const data = await ctx.client.eventRevisions.updateWidgets(
+    revision.id,
+    ctx.locale,
+    params.widgets || []
+  );
+
+  if (data.revision) {
+    const settings = await ctx.client.settings.find(ctx.locale);
+
+    data.revision = { ...data.revision, websiteSettings: settings };
+  }
+
+  return {
+    json: data,
+  };
+};
+
+export default {
+  update,
+  show,
+};

package/src/handlers/events/ClonesHandler.js

@@ -0,0 +1,17 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const { errors } = await ctx.client.events.clone(parent_id, ctx.locale);
+
+  if (errors) {
+    throw new Error(`Error cloning event: ${JSON.stringify(errors)}`);
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/events/DeletesHandler.js

@@ -0,0 +1,68 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const event = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!event) {
+    throw new Error(`Missing event #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      deleteAction: {
+        id: event.id,
+        redirect: "",
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const params = ctx.resourceParams.deleteAction;
+  const event = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!event) {
+    throw new Error(`Missing event #${parent_id}`);
+  }
+
+  let redirect = null;
+
+  if (params.redirect === "301" || params.redirect === "410") {
+    redirect = {
+      // TODO: fix url with consideration of locale & defaultLocale in the frontend project
+      url: `/${event.slug}`,
+      destination: params.redirect === "301" ? params.destination : "/",
+      httpResponseCode: Number.parseInt(params.redirect, 10),
+      note: "Created via event deletion process",
+    };
+  }
+
+  const { errors } = await ctx.client.events.delete(
+    event.id,
+    ctx.locale,
+    redirect
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        deleteAction: { ...params, id: event.id },
+        errors: {
+          deleteAction: ctx.client.events.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};