@raketa-cloud/admin 0.0.14 → 0.0.16

package/src/handlers/article_revisions/RevertsHandler.js

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

package/src/handlers/article_revisions/TagHandler.js

@@ -0,0 +1,89 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.articleRevisions.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.articleRevisions.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.articleRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: revision.slug,
+      title: revision.title,
+      visibility: revision.visibility,
+      publishAt: revision.publishAt,
+      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.articleRevisions.formatErrors(errors),
+        },
+        tags: tags.list,
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/article_revisions/${revision.id}/tags/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/article_revisions/UnlocksHandler.js

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

package/src/handlers/article_revisions/VisualHandler.js

@@ -0,0 +1,84 @@
+const edit_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.articleRevisions.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.articleRevisions.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.articleRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: revision.slug,
+      title: revision.title,
+      visibility: revision.visibility,
+      publishAt: revision.publishAt,
+      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.articleRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/article_revisions/${revision.id}/visuals/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/article_revisions/WidgetHandler.js

@@ -0,0 +1,47 @@
+const show = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.articleRevisions.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.articleRevisions.find(
+    parent_id,
+    ctx.locale
+  );
+
+  const params = ctx.resourceParams;
+
+  const data = await ctx.client.articleRevisions.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/articles/ArticlesHandler.js

@@ -0,0 +1,119 @@
+import { toUTCISO8601String } from "../../utils";
+
+const index = async (ctx) => {
+  const items = await ctx.client.articles.list(ctx.query, ctx.locale);
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  return {
+    assigns: {
+      tags: tags.list,
+      items,
+      visibilityOptions: ctx.client.articles.visibilityOptions(),
+    },
+  };
+};
+
+const show = async (ctx) => {
+  const { id } = ctx.params;
+  const article = await ctx.client.articles.find(id, ctx.locale);
+
+  if (!article) {
+    throw new Error(`Missing article #${id}`);
+  }
+
+  const revisions = await ctx.client.articleRevisions.all(id, ctx.locale);
+  const changes = await ctx.client.articleChanges.all(id, ctx.locale);
+
+  return {
+    assigns: {
+      article,
+      revisions: revisions.list,
+      changes: changes.list,
+      _translations: Object.keys(ctx.locales)
+        .map((locale) => {
+          const translation = article.translations[locale];
+
+          if (translation) {
+            return {
+              locale,
+              path: `/${locale}/articles/${translation.id}`,
+            };
+          }
+
+          return null;
+        })
+        .filter(Boolean),
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  return {
+    assigns: {
+      article: { ...ctx.client.articles.defaults(), meta_image: {} },
+      tags: tags.list,
+      errors: {},
+      visibilityOptions: ctx.client.articles.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const params = { ...ctx.resourceParams.article };
+
+  params.meta_image = JSON.parse(params.meta_image || "{}");
+
+  const { errors } = await ctx.client.articles.create(
+    {
+      title: params.title,
+      slug: params.slug,
+      visibility: params.visibility,
+      publishAt: toUTCISO8601String(params.publish_at),
+      settings: {
+        layout: params.layout,
+        meta: {
+          title: params.meta_title,
+          description: params.meta_description,
+          image: params.meta_image,
+        },
+        credentials: {
+          user: params.username || "",
+          password: params.password || "",
+        },
+      },
+      widgets: [],
+      tags: params.tags || [],
+      categories: params.categories || [],
+    },
+    ctx.locale,
+    "article"
+  );
+
+  if (errors) {
+    const tags = await ctx.client.tags.all(ctx.locale);
+
+    return {
+      assigns: {
+        article: params,
+        tags: tags.list,
+        errors: { article: ctx.client.articles.formatErrors(errors) },
+        visibilityOptions: ctx.client.articles.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/articles`,
+  };
+};
+
+export default {
+  index,
+  show,
+  create_form,
+  create,
+};

package/src/handlers/articles/ClonesHandler.js

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

package/src/handlers/articles/DeletesHandler.js

@@ -0,0 +1,68 @@
+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 article #${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      deleteAction: {
+        id: article.id,
+        redirect: "",
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const params = ctx.resourceParams.deleteAction;
+  const article = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  if (!article) {
+    throw new Error(`Missing article #${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: `/${article.slug}`,
+      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: {
+        deleteAction: { ...params, id: article.id },
+        errors: {
+          deleteAction: ctx.client.articles.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/articles`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/articles/TranslationsHandler.js

@@ -0,0 +1,103 @@
+import { toDateTimeInput, toUTCISO8601String } from "../../utils";
+
+const create_form = async (ctx) => {
+  // const tags = await ctx.client.tags.all(ctx.locale);
+  const { target_locale } = ctx.query;
+  const target_locate_tags = await ctx.client.tags.all(target_locale);
+
+  const { parent_id } = ctx.params;
+  const blueprint_article = await ctx.client.articles.find(
+    parent_id,
+    ctx.locale
+  );
+
+  const translation = {
+    title: blueprint_article.title,
+    slug: blueprint_article.slug,
+    visibility: blueprint_article.visibility,
+    publish_at: toDateTimeInput(blueprint_article.publishAt),
+    layout: blueprint_article.settings.layout,
+    meta_title: blueprint_article.settings.meta.title,
+    meta_description: blueprint_article.settings.meta.description,
+    meta_image: blueprint_article.settings.meta?.image || {},
+    username: blueprint_article.settings.credentials?.user,
+    password: blueprint_article.settings.credentials?.password,
+    tags: [],
+    // categories: blueprint_article.categories, # TODO: this will be added later?
+  };
+
+  return {
+    assigns: {
+      article: blueprint_article,
+      translation: translation,
+      targetLocale: target_locale,
+      tags: target_locate_tags.list,
+      blueprint_tags: blueprint_article.tags,
+      errors: {},
+      visibilityOptions: ctx.client.articles.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const blueprint_article = await ctx.client.articles.find(
+    parent_id,
+    ctx.locale
+  );
+
+  const { target_locale } = ctx.resourceParams;
+  const translation = { ...ctx.translation };
+
+  translation.meta_image = JSON.parse(translation.meta_image || "{}");
+
+  const { errors } = await ctx.client.articles.translate(
+    parent_id,
+    target_locale,
+    {
+      title: translation.title,
+      slug: translation.slug,
+      visibility: translation.visibility,
+      publishAt: toUTCISO8601String(translation.publish_at),
+      settings: {
+        ...blueprint_article.settings,
+        layout: translation.layout,
+        meta: {
+          title: translation.meta_title,
+          description: translation.meta_description,
+          image: translation.meta_image || "{}",
+        },
+        credentials: {
+          user: translation.username || "",
+          password: translation.password || "",
+        },
+      },
+      widgets: blueprint_article.widgets,
+      tags: translation.tags || [],
+      categories: blueprint_article.categories.map((category) => category.id),
+    }
+  );
+  if (errors) {
+    const tags = await ctx.client.tags.all(target_locale);
+    return {
+      assigns: {
+        article: blueprint_article,
+        translation: translation,
+        targetLocale: translation.target_locate,
+        tags: tags.list,
+        errors: {},
+        visibilityOptions: ctx.client.articles.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+  return {
+    redirect: `/${ctx.locale}/articles/${parent_id}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/articles/URLsHandler.js

@@ -0,0 +1,71 @@
+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 article with id ${parent_id}`);
+  }
+
+  return {
+    assigns: {
+      change: {
+        id: article.id,
+        slug: article.slug,
+        redirect: null,
+      },
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const change = ctx.resourceParams.change;
+
+  const article = await ctx.client.articles.find(parent_id, ctx.locale);
+
+  if (!article) {
+    throw new Error(`Cannot find article with id ${parent_id}`);
+  }
+
+  let redirectParams = null;
+
+  if (change.redirect) {
+    redirectParams = {
+      // TODO: We need some config from the FE project on how to build paths here!
+      url: `/${article.slug}`,
+      destination: change.slug,
+      httpResponseCode: 301,
+      note: "Created with changed URL for a article",
+    };
+  }
+
+  const { errors } = await ctx.client.articles.updateSlug(
+    parent_id,
+    change.slug,
+    ctx.locale,
+    redirectParams
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        change: { ...change, id: article.id },
+        errors: {
+          change: ctx.client.articles.formatErrors(errors, "redirect"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/articles/${parent_id}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};