@raketa-cloud/admin 0.0.102 → 1.0.0

package/src/handlers/articles/DeletesHandler.js

@@ -0,0 +1,72 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const article = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  if (!article) {
+    throw new Error(`Missing ${ctx.resourceConfig.articleType} #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      article,
+      resource: {
+        id: article.id,
+        redirect: "",
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const params = ctx.resourceParams.resource;
+  const article = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  if (!article) {
+    throw new Error(`Missing ${ctx.resourceConfig.articleType} #${parent_id}`);
+  }
+
+  let redirect = null;
+
+  if (params.redirect === "301" || params.redirect === "410") {
+    redirect = {
+      url: ctx.remoteConfig.resourcePath(
+        article,
+        article.articleType.slug,
+        ctx.locale
+      ),
+      destination: params.redirect === "301" ? params.destination : "/",
+      httpResponseCode: Number.parseInt(params.redirect, 10),
+      note: "Created via article deletion process",
+    };
+  }
+
+  const { errors } = await ctx.client.articles.delete(
+    article.id,
+    ctx.locale,
+    redirect
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: { ...params, id: article.id },
+        errors: {
+          resource: ctx.client.articles.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.articleTypePlural}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/articles/HistoryHandler.js

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

package/src/handlers/articles/TranslationsHandler.js

@@ -0,0 +1,231 @@
+const index = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const { translations } = ctx.query;
+  let translatedArticles = [];
+
+  if (translations) {
+    const translationPairs = translations.split(";").map((pair) => {
+      const [locale, id] = pair.split(":");
+      return { locale, id };
+    });
+
+    translatedArticles = await Promise.all(
+      translationPairs.map(async ({ locale, id }) => {
+        const article = await ctx.client.articles.find(id, locale);
+
+        if (!article) {
+          throw new Error(
+            `Cannot find translated article with id ${id} and locale ${locale}`
+          );
+        }
+
+        const revisions = await ctx.client.articleRevisions.all(id, locale);
+        const openRevision = revisions.list[0];
+
+        return {
+          ...article,
+          translationLocale: locale,
+          revisionId: openRevision?.id,
+        };
+      })
+    );
+  }
+
+  const items = await ctx.client.articles.list(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.articleType
+  );
+
+  const originalArticle = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  return {
+    assigns: {
+      items,
+      visibilityOptions: ctx.client.articles.visibilityOptions(),
+      translations: translatedArticles,
+      parent_id,
+      articleTitle: originalArticle.title,
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const { target_locale = "" } = ctx.query;
+
+  const { parent_id } = ctx.params;
+  const blueprint = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  if (!blueprint) {
+    throw new Error(`Cannot find article 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.articles.find(parent_id, originalLocale);
+
+  if (!ctx.resourceParams?.resource?.languages) {
+    return {
+      assigns: {
+        resource: {
+          translations: blueprint.translations || {},
+          languages: [],
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.articles.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,
+    title: blueprint.title,
+    slug: blueprint.slug,
+    tags: [],
+  };
+
+  const resource = ctx.client.articles.deepMerge(params, {
+    visibility: "private",
+  });
+
+  const translationIds = [];
+
+  const translations = await ctx.client.articles.translateBatch(
+    parent_id,
+    selectedLocales,
+    resource
+  );
+
+  if (!translations) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          translations: blueprint.translations || {},
+          languages: formLanguages,
+        },
+        blueprint,
+        targetLocale: originalLocale,
+        errors: {
+          resource: ctx.client.articles.formatErrors([
+            {
+              key: "generalError",
+              message: "Failed to process translations",
+            },
+          ]),
+        },
+      },
+    };
+  }
+
+  for (let i = 0; i < translations.length; i++) {
+    const { article } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (article) {
+      blueprint.translations = {
+        ...blueprint.translations,
+        [locale]: {
+          id: article.id,
+          slug: article.slug,
+          visibility: article.visibility,
+        },
+      };
+    }
+  }
+
+  const revisionInputs = [];
+
+  for (let i = 0; i < translations.length; i++) {
+    const { errors, article } = translations[i];
+    const locale = selectedLocales[i];
+
+    if (errors) {
+      return {
+        assigns: {
+          resource: {
+            ...resource,
+            translations: blueprint.translations || {},
+            languages: formLanguages,
+          },
+          blueprint,
+          targetLocale: locale,
+          errors: { resource: ctx.client.articles.formatErrors(errors) },
+        },
+      };
+    }
+
+    if (article) {
+      translationIds.push(`${locale}:${article.id}`);
+      revisionInputs.push({ articleId: article.id, locale });
+    }
+  }
+
+  const revisionResults =
+    await ctx.client.articleRevisions.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.articles.formatErrors(revisionErrors),
+          },
+        },
+      };
+    }
+  }
+
+  return {
+    redirect: `/${originalLocale}/${ctx.resourceConfig.articleTypePlural}/${parent_id}/translations?translations=${translationIds.join(";")}`,
+  };
+};
+
+export default {
+  index,
+  create_form,
+  create,
+};

package/src/handlers/articles/URLsHandler.js

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

package/src/handlers/categories/index.js

@@ -0,0 +1,122 @@
+const index = async (ctx) => {
+  const items = await ctx.client.categories.list(
+    ctx.query,
+    ctx.locale,
+    ctx.resourceConfig.categoryType
+  );
+
+  return {
+    assigns: {
+      items,
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  return {
+    assigns: {
+      resource: {},
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const params = { ...ctx.resourceParams.resource };
+  const resource = { ...params };
+
+  const { errors } = await ctx.client.categories.create(
+    resource,
+    ctx.locale,
+    ctx.resourceConfig.categoryType
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource,
+
+        errors: { resource: ctx.client.categories.formatErrors(errors) },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.categoryTypePlural}`,
+  };
+};
+
+const edit_form = async (ctx) => {
+  const { id } = ctx.router.req.param();
+  const resource = await ctx.client.categories.find(id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing category #${id}`);
+  }
+
+  return {
+    assigns: {
+      resource,
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const update = async (ctx) => {
+  const { id } = ctx.params;
+  const params = ctx.resourceParams.resource;
+
+  const { errors } = await ctx.client.categories.update(
+    id,
+    {
+      name: params.name,
+      slug: params.slug,
+      settings: params.settings || {},
+    },
+    ctx.locale,
+    ctx.resourceConfig.categoryType
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: { ...params, id },
+        errors: { resource: ctx.client.categories.formatErrors(errors) },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.categoryTypePlural}`,
+  };
+};
+
+const destroy = async (ctx) => {
+  const { id } = ctx.params;
+
+  const { errors } = await ctx.client.categories.delete(id, ctx.locale);
+
+  if (errors) {
+    throw `Failed to delete category #${id}.`;
+  }
+
+  return {
+    headers: {
+      "HX-Redirect": `/${ctx.locale}/${ctx.resourceConfig.categoryTypePlural}`,
+    },
+    json: {},
+  };
+};
+
+export default {
+  index,
+  create_form,
+  create,
+  edit_form,
+  update,
+  destroy,
+};

package/src/handlers/event_revisions/CancelSchedulesHandler.js

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

package/src/handlers/event_revisions/CodeHandler.js

@@ -0,0 +1,72 @@
+import { toDateTimeInput } from "../../utils";
+
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const resource = await ctx.client.eventRevisions.find(parent_id, ctx.locale);
+
+  if (!resource) {
+    throw new Error(`Missing revision #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      resource: {
+        ...resource,
+        publishAt: toDateTimeInput(resource.publishAt),
+        startsAt: toDateTimeInput(resource.startsAt),
+        endsAt: toDateTimeInput(resource.endsAt),
+      },
+      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.resource;
+  const resource = ctx.client.eventRevisions.deepMerge(
+    revision,
+    ctx.client.eventRevisions.formatDates(params)
+  );
+
+  const { errors } = await ctx.client.eventRevisions.update(
+    revision.id,
+    ctx.locale,
+    ctx.client.eventRevisions.selectUpdateParams(resource)
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        resource: {
+          ...resource,
+          publishAt: toDateTimeInput(resource.publishAt),
+          startsAt: toDateTimeInput(resource.startsAt),
+          endsAt: toDateTimeInput(resource.endsAt),
+        },
+        errors: {
+          resource: ctx.client.eventRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/${ctx.resourceConfig.eventType}_revisions/${revision.id}/codes/edit?success=1`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/event_revisions/EventRevisionsHandler.js

@@ -0,0 +1,47 @@
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const { errors, eventErrors } = await ctx.client.eventRevisions.create(
+    parent_id,
+    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}/${ctx.resourceConfig.eventTypePlural}/${parent_id}`,
+  };
+};
+
+const destroy = async (ctx) => {
+  const { id } = ctx.params;
+
+  const { errors, revision } = await ctx.client.eventRevisions.delete(
+    id,
+    ctx.locale
+  );
+
+  if (errors) {
+    throw new Error(
+      `Failed to delete revision#${id}: ${JSON.stringify(errors)}`
+    );
+  }
+
+  return {
+    headers: {
+      "HX-Redirect": `/${ctx.locale}/${ctx.resourceConfig.eventTypePlural}/${revision.originalId}`,
+    },
+    json: {},
+  };
+};
+
+export default {
+  destroy,
+  create,
+};