@raketa-cloud/admin 0.0.15 → 0.0.16

package/src/handlers/events/EventsHandler.js

@@ -0,0 +1,121 @@
+import { toUTCISO8601String } from "../../utils";
+
+const index = async (ctx) => {
+  const items = await ctx.client.events.list(ctx.query, ctx.locale);
+  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 event = await ctx.client.events.find(id, ctx.locale);
+
+  if (!event) {
+    throw new Error(`Missing event #${id}`);
+  }
+
+  const revisions = await ctx.client.eventRevisions.all(id, ctx.locale);
+  const changes = await ctx.client.eventChanges.all(id, ctx.locale);
+
+  return {
+    assigns: {
+      event,
+      revisions: revisions.list,
+      changes: changes.list,
+      _translations: Object.keys(ctx.locales)
+        .map((locale) => {
+          const translation = event.translations[locale];
+
+          if (translation) {
+            return {
+              locale,
+              path: `/${locale}/events/${translation.id}`,
+            };
+          }
+
+          return null;
+        })
+        .filter(Boolean),
+    },
+  };
+};
+
+const create_form = async (ctx) => {
+  const tags = await ctx.client.tags.all(ctx.locale);
+
+  return {
+    assigns: {
+      event: { ...ctx.client.events.defaults(), meta_image: {} },
+      tags: tags.list,
+      errors: {},
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const params = { ...ctx.resourceParams.event };
+
+  params.meta_image = JSON.parse(params.meta_image || "{}");
+
+  const { errors } = await ctx.client.events.create(
+    {
+      title: params.title,
+      slug: params.slug,
+      visibility: params.visibility,
+      publishAt: toUTCISO8601String(params.publish_at),
+      startsAt: toUTCISO8601String(params.starts_at),
+      endsAt: toUTCISO8601String(params.ends_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,
+    "event"
+  );
+
+  if (errors) {
+    const tags = await ctx.client.tags.all(ctx.locale);
+
+    return {
+      assigns: {
+        event: params,
+        tags: tags.list,
+        errors: { event: ctx.client.events.formatErrors(errors) },
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/events`,
+  };
+};
+
+export default {
+  index,
+  show,
+  create_form,
+  create,
+};

package/src/handlers/events/TranslationsHandler.js

@@ -0,0 +1,99 @@
+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_event = await ctx.client.events.find(parent_id, ctx.locale);
+
+  const translation = {
+    title: blueprint_event.title,
+    slug: blueprint_event.slug,
+    visibility: blueprint_event.visibility,
+    publish_at: toDateTimeInput(blueprint_event.publishAt),
+    layout: blueprint_event.settings.layout,
+    meta_title: blueprint_event.settings.meta.title,
+    meta_description: blueprint_event.settings.meta.description,
+    meta_image: blueprint_event.settings.meta?.image || {},
+    username: blueprint_event.settings.credentials?.user,
+    password: blueprint_event.settings.credentials?.password,
+    tags: [],
+    // categories: blueprint_event.categories, # TODO: this will be added later?
+  };
+
+  return {
+    assigns: {
+      event: blueprint_event,
+      translation: translation,
+      targetLocale: target_locale,
+      tags: target_locate_tags.list,
+      blueprint_tags: blueprint_event.tags,
+      errors: {},
+      visibilityOptions: ctx.client.events.visibilityOptions(),
+      _translations: [],
+    },
+  };
+};
+
+const create = async (ctx) => {
+  const { parent_id } = ctx.params;
+  const blueprint_event = await ctx.client.events.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.events.translate(
+    parent_id,
+    target_locale,
+    {
+      title: translation.title,
+      slug: translation.slug,
+      visibility: translation.visibility,
+      publishAt: toUTCISO8601String(translation.publish_at),
+      startsAt: toUTCISO8601String(translation.starts_at),
+      endshAt: toUTCISO8601String(translation.ends_at),
+      settings: {
+        ...blueprint_event.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_event.widgets,
+      tags: translation.tags || [],
+      categories: blueprint_event.categories.map((category) => category.id),
+    }
+  );
+  if (errors) {
+    const tags = await ctx.client.tags.all(target_locale);
+    return {
+      assigns: {
+        event: blueprint_event,
+        translation: translation,
+        targetLocale: translation.target_locate,
+        tags: tags.list,
+        errors: {},
+        visibilityOptions: ctx.client.events.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+  return {
+    redirect: `/${ctx.locale}/events/${parent_id}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/events/URLsHandler.js

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

package/src/index.js

@@ -6,6 +6,7 @@ export { default as routeNestedMember } from "./routeNestedMember";
 export { default as setGlobalContext } from "./setGlobalContext";
 export { default as routePages } from "./routePages";
 export { default as routeArticles } from "./routeArticles";
+export { default as routeEvents } from "./routeEvents";
 export { default as routeSettings } from "./routeSettings";
 export { default as setupCloud } from "./setupCloud";
 export { default as routeStandard } from "./routeStandard";
@@ -19,6 +20,9 @@ export { default as Pages } from "./cloud/Pages";
 export { default as ArticleChanges } from "./cloud/ArticleChanges";
 export { default as ArticleRevisions } from "./cloud/ArticleRevisions";
 export { default as Articles } from "./cloud/Articles";
+export { default as EventChanges } from "./cloud/EventChanges";
+export { default as EventRevisions } from "./cloud/EventRevisions";
+export { default as Events } from "./cloud/Events";
 
 export { default as PageRevisionsHandler } from "./handlers/page_revisions/PageRevisionsHandler";
 export { default as PageRevisionsCodeHandler } from "./handlers/page_revisions/CodeHandler";
@@ -63,3 +67,21 @@ export { default as ArticleDeletesHandler } from "./handlers/articles/DeletesHan
 export { default as ArticleTranslationsHandler } from "./handlers/articles/TranslationsHandler";
 export { default as ArticleURLsHandler } from "./handlers/articles/URLsHandler";
 export { default as ArticlesHandler } from "./handlers/articles/ArticlesHandler";
+
+export { default as EventRevisionsHandler } from "./handlers/event_revisions/EventRevisionsHandler";
+export { default as EventRevisionsCodeHandler } from "./handlers/event_revisions/CodeHandler";
+export { default as EventRevisionsGeneralHandler } from "./handlers/event_revisions/GeneralHandler";
+export { default as EventRevisionsMetaHandler } from "./handlers/event_revisions/MetaHandler";
+export { default as EventRevisionsLocksHandler } from "./handlers/event_revisions/LocksHandler";
+export { default as EventRevisionsUnlocksHandler } from "./handlers/event_revisions/UnlocksHandler";
+export { default as EventRevisionsVisualHandler } from "./handlers/event_revisions/VisualHandler";
+export { default as EventRevisionsTagHandler } from "./handlers/event_revisions/TagHandler";
+export { default as EventRevisionsWidgetHandler } from "./handlers/event_revisions/WidgetHandler";
+export { default as EventRevisionsPublishesHandler } from "./handlers/event_revisions/PublishesHandler";
+export { default as EventRevisionsRevertsHandler } from "./handlers/event_revisions/RevertsHandler";
+
+export { default as EventClonesHandler } from "./handlers/events/ClonesHandler";
+export { default as EventDeletesHandler } from "./handlers/events/DeletesHandler";
+export { default as EventTranslationsHandler } from "./handlers/events/TranslationsHandler";
+export { default as EventURLsHandler } from "./handlers/events/URLsHandler";
+export { default as EventsHandler } from "./handlers/events/EventsHandler";

package/src/routeEvents.js

@@ -0,0 +1,55 @@
+import routeCollection from "./routeCollection";
+import routeNestedCollection from "./routeNestedCollection";
+import routeNestedMember from "./routeNestedMember";
+import TranslationsHandler from "./handlers/events/TranslationsHandler";
+import EventRevisionsHandler from "./handlers/event_revisions/EventRevisionsHandler";
+import GeneralHandler from "./handlers/event_revisions/GeneralHandler";
+import VisualHandler from "./handlers/event_revisions/VisualHandler";
+import CodeHandler from "./handlers/event_revisions/CodeHandler";
+import MetaHandler from "./handlers/event_revisions/MetaHandler";
+import TagHandler from "./handlers/event_revisions/TagHandler";
+import LocksHandler from "./handlers/event_revisions/LocksHandler";
+import UnlocksHandler from "./handlers/event_revisions/UnlocksHandler";
+import ClonesHandler from "./handlers/events/ClonesHandler";
+import URLsHandler from "./handlers/events/URLsHandler";
+import DeletesHandler from "./handlers/events/DeletesHandler";
+import RevertsHandler from "./handlers/event_revisions/RevertsHandler";
+import PublishesHandler from "./handlers/event_revisions/PublishesHandler";
+import WidgetHandler from "./handlers/event_revisions/WidgetHandler";
+import EventsHandler from "./handlers/events/EventsHandler";
+
+function routeEvents(adapter) {
+  routeCollection(adapter, "events", EventsHandler);
+  routeNestedCollection(adapter, "events", "translations", TranslationsHandler);
+  routeNestedCollection(
+    adapter,
+    "events",
+    "event_revisions",
+    EventRevisionsHandler
+  );
+  routeNestedMember(adapter, "event_revisions", "general", GeneralHandler);
+  routeNestedMember(adapter, "event_revisions", "visuals", VisualHandler);
+  routeNestedMember(adapter, "event_revisions", "codes", CodeHandler);
+  routeNestedMember(adapter, "event_revisions", "meta", MetaHandler);
+  routeNestedMember(adapter, "event_revisions", "tags", TagHandler);
+  routeNestedCollection(adapter, "event_revisions", "locks", LocksHandler);
+  routeNestedCollection(adapter, "event_revisions", "unlocks", UnlocksHandler);
+  routeNestedCollection(adapter, "events", "clones", ClonesHandler);
+  routeNestedCollection(adapter, "events", "urls", URLsHandler);
+  routeNestedCollection(adapter, "events", "deletes", DeletesHandler);
+  routeNestedCollection(
+    adapter,
+    "events",
+    "event_changes/reverts",
+    RevertsHandler
+  );
+  routeNestedCollection(
+    adapter,
+    "event_revisions",
+    "publishes",
+    PublishesHandler
+  );
+  routeNestedMember(adapter, "api/event_revisions", "widgets", WidgetHandler);
+}
+
+export default routeEvents;

package/src/routeStandard.js

@@ -2,6 +2,7 @@ import routeCollection from "./routeCollection";
 import routeSettings from "./routeSettings";
 import routePages from "./routePages";
 import routeArticles from "./routeArticles";
+import routeEvents from "./routeEvents";
 import RedirectsHandler from "./handlers/RedirectsHandler";
 import TagsHandler from "./handlers/TagsHandler";
 
@@ -11,6 +12,7 @@ function routeStandard(adapter) {
   routeSettings(adapter);
   routePages(adapter);
   routeArticles(adapter);
+  routeEvents(adapter);
 }
 
 export default routeStandard;

package/src/setupCloud.js

@@ -7,6 +7,9 @@ import PageChanges from "./cloud/PageChanges";
 import Articles from "./cloud/Articles";
 import ArticleRevisions from "./cloud/ArticleRevisions";
 import ArticleChanges from "./cloud/ArticleChanges";
+import Events from "./cloud/Events";
+import EventRevisions from "./cloud/EventRevisions";
+import EventChanges from "./cloud/EventChanges";
 
 function setupCloud(ctx, getConfig) {
   if (!ctx?.authentication?.token) return;
@@ -31,6 +34,15 @@ function setupCloud(ctx, getConfig) {
     getConfig,
     ctx.authentication.token
   );
+  ctx.client.events = new Events(getConfig, ctx.authentication.token);
+  ctx.client.eventRevisions = new EventRevisions(
+    getConfig,
+    ctx.authentication.token
+  );
+  ctx.client.eventChanges = new EventChanges(
+    getConfig,
+    ctx.authentication.token
+  );
 }
 
 export default setupCloud;

package/src/tests/handlers/article_revisions/CodesHandler.test/edit_form.test.js

@@ -0,0 +1,56 @@
+import CodeHandler from "../../../../handlers/article_revisions/CodeHandler";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import { testConfig } from "../../../../../test/handlersHelper";
+import Factory from "../../../../../test/factory";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      articleRevisions: new ArticleRevisions(testConfig, "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+  };
+}
+
+describe("Article revision code settings", () => {
+  test("edit_form when a revision exists", async () => {
+    const revision = Factory.build("article_revision");
+    const ctx = buildCtx(revision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const result = await CodeHandler.edit_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      assigns: {
+        code_settings: {
+          id: revision.id,
+          originalId: revision.originalId,
+          scripts: JSON.stringify([]),
+          structured_data: JSON.stringify({}),
+        },
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("edit_form when a revision does not exist", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await CodeHandler.edit_form(ctx);
+    }).rejects.toThrow("Missing revision #42");
+
+    expect(mockFind).toHaveBeenCalledWith("42", "en");
+  });
+});

package/src/tests/handlers/article_revisions/CodesHandler.test/update.test.js

@@ -0,0 +1,139 @@
+import CodeHandler from "../../../../handlers/article_revisions/CodeHandler";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import { testConfig } from "../../../../../test/handlersHelper";
+import Factory from "../../../../../test/factory";
+
+function buildCtx(revision, updateSettings) {
+  return {
+    client: {
+      articleRevisions: new ArticleRevisions(testConfig, "token"),
+    },
+    params: { parent_id: revision.id },
+    resourceParams: {
+      code_settings: updateSettings,
+    },
+    locale: "en",
+  };
+}
+
+describe("Article revision code settings", () => {
+  test("update successful", async () => {
+    const revision = Factory.build("article_revision");
+
+    const updateSettings = {
+      scripts: JSON.stringify([{ type: "bla" }]),
+      structured_data: JSON.stringify({ type: "article" }),
+    };
+
+    const ctx = buildCtx(revision, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.articleRevisions, "update")
+      .mockImplementation(() => ({
+        revision: {},
+        errors: null,
+      }));
+
+    const result = await CodeHandler.update(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockUpdate).toHaveBeenCalledWith(revision.id, "en", {
+      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,
+        codes: {
+          scripts: [{ type: "bla" }],
+          structured_data: { type: "article" },
+        },
+      }),
+    });
+
+    expect(result).toEqual({
+      redirect: `/en/article_revisions/${revision.id}/codes/edit`,
+    });
+  });
+
+  test("update failed", async () => {
+    const revision = Factory.build("article_revision");
+
+    const updateSettings = {
+      scripts: JSON.stringify([{ type: "bla" }]),
+      structured_data: JSON.stringify({ type: "article" }),
+    };
+
+    const ctx = buildCtx(revision, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.articleRevisions, "update")
+      .mockImplementation(() => ({
+        revision: {},
+        errors: [{ key: "generalError", message: "some error" }],
+      }));
+
+    const result = await CodeHandler.update(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+    expect(mockUpdate).toHaveBeenCalledWith(revision.id, "en", {
+      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,
+        codes: {
+          scripts: [{ type: "bla" }],
+          structured_data: { type: "article" },
+        },
+      }),
+    });
+
+    expect(result).toEqual({
+      assigns: {
+        code_settings: {
+          ...updateSettings,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          code_settings: { generalError: "some error" },
+        },
+        _translations: [],
+      },
+    });
+  });
+
+  test("update when a revision does not exist", async () => {
+    const revision = Factory.build("article_revision");
+
+    const updateSettings = {};
+
+    const ctx = buildCtx(revision, updateSettings);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await CodeHandler.update(ctx);
+    }).rejects.toThrow(`Missing revision #${revision.id}`);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+  });
+});

package/src/tests/handlers/article_revisions/GeneralHandler.test/edit_form.test.js

@@ -0,0 +1,65 @@
+import GeneralHandler from "../../../../handlers/article_revisions/GeneralHandler";
+import ArticleRevisions from "../../../../cloud/ArticleRevisions";
+import Articles from "../../../../cloud/Articles";
+import { testConfig } from "../../../../../test/handlersHelper";
+import Factory from "../../../../../test/factory";
+
+function buildCtx(revision) {
+  return {
+    client: {
+      articleRevisions: new ArticleRevisions(testConfig, "token"),
+      articles: new Articles(testConfig, "token"),
+    },
+    params: { parent_id: revision.id },
+    locale: "en",
+  };
+}
+
+describe("Article revision genereal settings", () => {
+  test("edit_form when a revision exists", async () => {
+    const revision = Factory.build("article_revision", {
+      publishAt: "2024-08-30T16:05:00Z",
+    });
+    const ctx = buildCtx(revision);
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => revision);
+
+    const result = await GeneralHandler.edit_form(ctx);
+
+    expect(mockFind).toHaveBeenCalledWith(revision.id, "en");
+
+    expect(result).toEqual({
+      assigns: {
+        general_settings: {
+          id: revision.id,
+          originalId: revision.originalId,
+          title: revision.title,
+          slug: revision.slug,
+          visibility: revision.visibility,
+          publish_at: "2024-08-30T19:05",
+          username: revision.settings?.credentials?.user || "",
+          password: revision.settings?.credentials?.password || "",
+        },
+        errors: {},
+        visibilityOptions: ctx.client.articles.visibilityOptions(),
+        _translations: [],
+      },
+    });
+  });
+
+  test("edit_form when a revision does not exist", async () => {
+    const ctx = buildCtx({ id: "42" });
+
+    const mockFind = jest
+      .spyOn(ctx.client.articleRevisions, "find")
+      .mockImplementation(() => null);
+
+    expect(async () => {
+      await GeneralHandler.edit_form(ctx);
+    }).rejects.toThrow("Missing revision #42");
+
+    expect(mockFind).toHaveBeenCalledWith("42", "en");
+  });
+});