@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/handlers/events/EventsHandler.js

@@ -0,0 +1,111 @@
+import { toDateTimeInput } from "../../utils";
+
+const index = async (ctx) => {
+  const items = await ctx.client.events.list(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.eventType
+  );
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  return {
+    assigns: {
+      tags: tags.list,
+      items,
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+    },
+  };
+};
+
+const show = async (ctx) => {
+  const { id } = ctx.params;
+  const resource = await ctx.client.events.find(id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing ${ctx.resourceConfig.eventType} #${id}`);
+  }
+
+  const revisions = await ctx.client.eventRevisions.all(id, ctx.locale);
+  const changes = await ctx.client.eventChanges.list({}, id, ctx.locale);
+
+  return {
+    assigns: {
+      resource,
+      revisions: revisions.list,
+      changes: changes,
+      _translations: Object.keys(ctx.locales)
+        .map((locale) => {
+          const translation = resource.translations[locale];
+
+          if (translation) {
+            return {
+              locale,
+              path: `/${locale}/${ctx.resourceConfig.eventTypePlural}/${translation.id}`,
+            };
+          }
+
+          return null;
+        })
+        .filter(Boolean),
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  return {
+    assigns: {
+      resource: { ...ctx.client.events.defaults() },
+      tags: tags.list,
+      errors: {},
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const params = { ...ctx.resourceParams.resource };
+
+  const resource = ctx.client.events.deepMerge(
+    ctx.client.events.defaults(),
+    ctx.client.events.formatDates(params)
+  );
+
+  const { errors } = await ctx.client.events.create(
+    resource,
+    ctx.locale,
+    ctx.resourceConfig.eventType
+  );
+
+  if (errors) {
+    const tags = await ctx.client.tags.all(ctx.locale);
+
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          publishAt: toDateTimeInput(resource.publishAt),
+          startsAt: toDateTimeInput(resource.startsAt),
+          endsAt: toDateTimeInput(resource.endsAt),
+        },
+        tags: tags.list,
+        errors: { resource: ctx.client.events.formatErrors(errors) },
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.eventTypePlural}`,
+  };
+};
+
+export default {
+  index,
+  show,
+  create_form,
+  create,
+};

package/src/handlers/events/HistoryHandler.js

@@ -0,0 +1,31 @@
+const index = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const resource = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing ${ctx.resourceConfig.eventType} #${parent_id}`);
+  }
+
+  const changes = await ctx.client.eventChanges.list(
+    ctx.query,
+    parent_id,
+    ctx.locale
+  );
+
+  const editors = await ctx.client.eventChanges.all_editors(
+    parent_id,
+    ctx.locale
+  );
+
+  return {
+    assigns: {
+      resource,
+      changes: changes,
+      editors,
+    },
+  };
+};
+
+export default {
+  index,
+};

package/src/handlers/events/TranslationsHandler.js

@@ -0,0 +1,233 @@
+const index = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { translations } = ctx.query;
+  let translatedEvents = [];
+
+  if (translations) {
+    const translationPairs = translations.split(";").map((pair) => {
+      const [locale, id] = pair.split(":");
+      return { locale, id };
+    });
+
+    translatedEvents = await Promise.all(
+      translationPairs.map(async ({ locale, id }) => {
+        const event = await ctx.client.events.find(id, locale);
+
+        if (!event) {
+          throw new Error(
+            `Cannot find translated event with id ${id} and locale ${locale}`
+          );
+        }
+
+        const revisions = await ctx.client.eventRevisions.all(id, locale);
+        const openRevision = revisions.list[0];
+
+        return {
+          ...event,
+          translationLocale: locale,
+          revisionId: openRevision?.id,
+        };
+      })
+    );
+  }
+
+  const items = await ctx.client.events.list(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.eventType
+  );
+
+  const originalEvent = await ctx.client.events.find(parent_id, ctx.locale);
+
+  return {
+    assigns: {
+      items,
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      translations: translatedEvents,
+      parent_id,
+      eventTitle: originalEvent.title,
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const { target_locale = "" } = ctx.query;
+
+  const { parent_id } = ctx.params;
+  const blueprint = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!blueprint) {
+    throw new Error(`Cannot find event with id ${parent_id}`);
+  }
+
+  const resource = structuredClone(blueprint);
+
+  return {
+    assigns: {
+      resource,
+      blueprint,
+      targetLocale: target_locale,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const originalLocale = ctx.locale;
+  const blueprint = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!ctx.resourceParams?.resource?.languages) {
+    return {
+      assigns: {
+        resource: {
+          translations: blueprint.translations || {},
+          languages: [],
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.events.formatErrors([
+            {
+              key: "languages",
+              message: "select at least one language for translation",
+            },
+          ]),
+        },
+      },
+    };
+  }
+
+  const formLanguages = Array.isArray(ctx.resourceParams.resource.languages)
+    ? ctx.resourceParams.resource.languages
+    : [ctx.resourceParams.resource.languages].filter(Boolean);
+
+  const existingTranslations = Object.keys(blueprint.translations || {});
+  const selectedLocales = formLanguages.filter(
+    (locale) =>
+      locale !== originalLocale && !existingTranslations.includes(locale)
+  );
+
+  const params = {
+    settings: blueprint.settings,
+    widgets: blueprint.widgets,
+    categories: blueprint.categories.map((category) => category.id),
+    publishAt: blueprint.publishAt,
+    startsAt: blueprint.startsAt,
+    endsAt: blueprint.endsAt,
+    title: blueprint.title,
+    slug: blueprint.slug,
+    tags: [],
+  };
+
+  const resource = ctx.client.events.deepMerge(params, {
+    visibility: "private",
+  });
+
+  const translationIds = [];
+
+  const translations = await ctx.client.events.translateBatch(
+    parent_id,
+    selectedLocales,
+    resource
+  );
+
+  if (!translations) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          translations: blueprint.translations || {},
+          languages: formLanguages,
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.events.formatErrors([
+            {
+              key: "generalError",
+              message: "Failed to process translations",
+            },
+          ]),
+        },
+      },
+    };
+  }
+
+  for (let i = 0; i < translations.length; i++) {
+    const { event } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (event) {
+      blueprint.translations = {
+        ...blueprint.translations,
+        [locale]: {
+          id: event.id,
+          slug: event.slug,
+          visibility: event.visibility,
+        },
+      };
+    }
+  }
+
+  const revisionInputs = [];
+
+  for (let i = 0; i < translations.length; i++) {
+    const { errors, event } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (errors) {
+      return {
+        assigns: {
+          resource: {
+            ...resource,
+            translations: blueprint.translations || {},
+            languages: formLanguages,
+          },
+          blueprint,
+          targetLocale: locale,
+          errors: { resource: ctx.client.events.formatErrors(errors) },
+        },
+      };
+    }
+
+    if (event) {
+      translationIds.push(`${locale}:${event.id}`);
+      revisionInputs.push({ eventId: event.id, locale });
+    }
+  }
+
+  const revisionResults =
+    await ctx.client.eventRevisions.createBatch(revisionInputs);
+
+  for (let i = 0; i < revisionResults.length; i++) {
+    const { errors: revisionErrors } = revisionResults[i];
+    if (revisionErrors) {
+      return {
+        assigns: {
+          resource: {
+            ...resource,
+            translations: blueprint.translations || {},
+            languages: formLanguages,
+          },
+          blueprint,
+          targetLocale: selectedLocales[i],
+          errors: {
+            resource: ctx.client.events.formatErrors(revisionErrors),
+          },
+        },
+      };
+    }
+  }
+
+  return {
+    redirect: `/${originalLocale}/${ctx.resourceConfig.eventTypePlural}/${parent_id}/translations?translations=${translationIds.join(";")}`,
+  };
+};
+
+export default {
+  index,
+  create_form,
+  create,
+};

package/src/handlers/events/URLsHandler.js

@@ -0,0 +1,81 @@
+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(
+      `Cannot find ${ctx.resourceConfig.eventType} with id ${parent_id}`
+    );
+  }
+
+  return {
+    assigns: {
+      event,
+      resource: {
+        id: event.id,
+        slug: event.slug,
+        redirect: null,
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const resource = ctx.resourceParams.resource;
+
+  const event = await ctx.client.events.find(parent_id, ctx.locale);
+
+  if (!event) {
+    throw new Error(`Cannot find event with id ${parent_id}`);
+  }
+
+  let redirectParams = null;
+
+  if (resource.redirect) {
+    redirectParams = {
+      url: ctx.remoteConfig.resourcePath(
+        event,
+        event.eventType.slug,
+        ctx.locale
+      ),
+      destination: ctx.remoteConfig.resourcePath(
+        { slug: resource.slug },
+        event.eventType.slug,
+        ctx.locale
+      ),
+      httpResponseCode: 301,
+      note: `Created with changed URL for a resource of type ${ctx.resourceConfig.eventType}`,
+    };
+  }
+
+  const { errors } = await ctx.client.events.updateSlug(
+    parent_id,
+    resource.slug,
+    ctx.locale,
+    redirectParams
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: { ...resource, id: event.id },
+        errors: {
+          resource: ctx.client.events.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.eventTypePlural}/${parent_id}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/page_revisions/CancelSchedulesHandler.js

@@ -0,0 +1,26 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const { revision, errors, pageErrors } =
+    await ctx.client.pageRevisions.cancelSchedule(parent_id, ctx.locale);
+
+  if (errors) {
+    throw new Error(
+      `Failed to cancel schedule for revision: ${JSON.stringify(errors)}`
+    );
+  }
+
+  if (pageErrors) {
+    throw new Error(
+      `Failed to cancel schedule for revision: ${JSON.stringify(pageErrors)}`
+    );
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.pageTypePlural}/${revision.originalId}`,
+  };
+};
+
+export default {
+  create,
+};

package/src/handlers/page_revisions/CodeHandler.js

@@ -0,0 +1,57 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const resource = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.resource;
+  const resource = ctx.client.pageRevisions.deepMerge(revision, params);
+
+  const { errors } = await ctx.client.pageRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.pageRevisions.selectUpdateParams(resource)
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+        errors: {
+          resource: ctx.client.pageRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.pageType}_revisions/${revision.id}/codes/edit?success=1`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/page_revisions/GeneralHandler.js

@@ -0,0 +1,59 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const resource = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      visibilityOptions: ctx.client.pages.visibilityOptions(),
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const params = ctx.resourceParams.resource;
+  const resource = ctx.client.pageRevisions.deepMerge(revision, params);
+
+  const { errors } = await ctx.client.pageRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.pageRevisions.selectUpdateParams(resource)
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+        visibilityOptions: ctx.client.pages.visibilityOptions(),
+        errors: {
+          resource: ctx.client.pageRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.pageType}_revisions/${revision.id}/general/edit?success=1`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/page_revisions/LocksHandler.js

@@ -0,0 +1,69 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const resource = {
+    id: revision.id,
+    originalId: revision.originalId,
+    message: "",
+  };
+
+  return {
+    assigns: {
+      resource,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { message } = ctx.resourceParams.resource;
+
+  const revision = await ctx.client.pageRevisions.find(parent_id, ctx.locale);
+
+  if (!revision) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  const { errors, pageErrors } = await ctx.client.pageRevisions.lock(
+    parent_id,
+    ctx.locale,
+    message
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: {
+          id: revision.id,
+          originalId: revision.originalId,
+          message,
+        },
+        errors: {
+          resource: ctx.client.pageRevisions.formatErrors(errors, "message"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  if (pageErrors) {
+    throw new Error(`Failed to lock revision: ${JSON.stringify(pageErrors)}`);
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.pageTypePlural}/${revision.originalId}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};