@raketa-cloud/admin 0.0.14 → 0.0.16

package/src/cloud/documents/eventsDocuments.js

@@ -0,0 +1,254 @@
+import { gql } from "graphql-request";
+import {
+  categoryFragment,
+  errorsFragment,
+  eventTypeFragment,
+  paginationFragment,
+  revisionMetaFragment,
+  tagFragment,
+} from "./common";
+
+function eventFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      translations
+      revisionsCount
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+function eventRevisionFragment() {
+  return gql`
+    {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      insertedAt
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      meta ${revisionMetaFragment()}
+      categories ${categoryFragment()}
+    }
+  `;
+}
+
+const EventByIdDocument = gql`
+  query EventByID($input: IdInput!) {
+    event(input: $input) ${eventFragment()}
+  }
+`;
+
+const EventChangesDocument = gql`
+  query EventChanges($input: IdInput!) {
+    eventChanges(input: $input) {
+      list {
+        version
+        title
+        description
+        operator
+        operatorMeta
+        source
+        insertedAt
+      }
+    }
+  }
+`;
+
+const EventsDocument = gql`
+  query Events($input: EventsInput!) {
+    events(input: $input) {
+      list ${eventFragment()}
+      pagination ${paginationFragment()}
+    }
+  }
+`;
+
+const CreateEventDocument = gql`
+  mutation CreateEvent($input: CreateEventInput!) {
+    createEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateEventDocument = gql`
+  mutation UpdateEvent($input: UpdateEventInput!) {
+    updateEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const UpdateEventWidgetsDocument = gql`
+  mutation updateEventWidgets($input: UpdateEventWidgetsInput!) {
+    updateEventWidgets(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const CloneEventDocument = gql`
+  mutation CloneEvent($input: IdInput!) {
+    cloneEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const DeleteEventDocument = gql`
+  mutation DeleteEvent($input: EventDeleteInput!) {
+    deleteEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const EventAndSiteDocument = gql`
+  query EventAndSite($input: SlugInput!) {
+    eventAndSite(input: $input) {
+      id
+      slug
+      title
+      widgets
+      settings
+      visibility
+      publishAt
+      startsAt
+      endsAt
+      originalId
+      translations
+      tags ${tagFragment()}
+      eventType ${eventTypeFragment()}
+      categories ${categoryFragment()}
+      websiteSettings
+    }
+  }
+`;
+
+const TranslateEventDocument = gql`
+  mutation TranslateEvent($input: TranslateEventInput!) {
+    translateEvent(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const EventRevisionsDocument = gql`
+  query EventRevisions($input: IdInput!) {
+    eventRevisions(input: $input) {
+      list ${eventRevisionFragment()}
+    }
+  }
+`;
+
+const EventRevisionDocument = gql`
+  query EventRevision($input: IdInput!) {
+    eventRevision(input: $input) ${eventRevisionFragment()}
+  }
+`;
+
+const StartEventRevisionDocument = gql`
+  mutation StartEventRevision($input: StartEventRevisionInput!) {
+    startEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const MergeEventRevisionDocument = gql`
+  mutation MergeEventRevision($input: MergeEventRevisionInput!) {
+    mergeEventRevision(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ChangeEventSlugDocument = gql`
+  mutation ($input: ChangeEventSlugInput!) {
+    changeEventSlug(input: $input) {
+      event ${eventFragment()}
+      errors ${errorsFragment()}
+    }
+  }
+`;
+
+const ReopenEventChangeDocument = gql`
+  mutation($input: ReopenEventChangeInput!)
+    {
+      reopenEventChange(input: $input) {
+        revision ${eventRevisionFragment()}
+        errors ${errorsFragment()}
+        eventErrors ${errorsFragment()}
+      }
+    }
+`;
+
+const LockEventRevisionDocument = gql`
+  mutation LockEventRevision($input: LockEventRevisionInput!) {
+    lockEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+const UnlockEventRevisionDocument = gql`
+  mutation UnlockEventRevision($input: UnlockEventRevisionInput!) {
+    unlockEventRevision(input: $input) {
+      revision ${eventRevisionFragment()}
+      errors ${errorsFragment()}
+      eventErrors ${errorsFragment()}
+    }
+  }
+`;
+
+export {
+  EventByIdDocument,
+  EventsDocument,
+  CreateEventDocument,
+  UpdateEventDocument,
+  UpdateEventWidgetsDocument,
+  CloneEventDocument,
+  DeleteEventDocument,
+  EventAndSiteDocument,
+  TranslateEventDocument,
+  EventRevisionDocument,
+  EventRevisionsDocument,
+  StartEventRevisionDocument,
+  MergeEventRevisionDocument,
+  EventChangesDocument,
+  ChangeEventSlugDocument,
+  ReopenEventChangeDocument,
+  LockEventRevisionDocument,
+  UnlockEventRevisionDocument,
+};

package/src/handlers/article_revisions/ArticleRevisionsHandler.js

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

package/src/handlers/article_revisions/CodeHandler.js

@@ -0,0 +1,90 @@
+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 code_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    scripts: JSON.stringify(revision.settings.codes?.scripts || []),
+    structured_data: JSON.stringify(
+      revision.settings.codes?.structured_data || {}
+    ),
+  };
+
+  return {
+    assigns: {
+      code_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.code_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,
+        codes: {
+          scripts: JSON.parse(params.scripts),
+          structured_data: JSON.parse(params.structured_data),
+        },
+      }),
+    }
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        code_settings: {
+          ...params,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        errors: {
+          code_settings: ctx.client.articleRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/article_revisions/${revision.id}/codes/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/article_revisions/GeneralHandler.js

@@ -0,0 +1,95 @@
+import { toDateTimeInput, toUTCISO8601String } from "../../utils";
+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 general_settings = {
+    id: revision.id,
+    originalId: revision.originalId,
+    title: revision.title,
+    slug: revision.slug,
+    publish_at: toDateTimeInput(revision.publishAt),
+    visibility: revision.visibility,
+    username: revision.settings?.credentials?.user || "",
+    password: revision.settings?.credentials?.password || "",
+  };
+
+  return {
+    assigns: {
+      general_settings,
+      errors: {},
+      visibilityOptions: ctx.client.articles.visibilityOptions(),
+      _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.general_settings;
+
+  const { errors } = await ctx.client.articleRevisions.update(
+    revision.id,
+    ctx.locale,
+    {
+      slug: params.slug,
+      title: params.title,
+      visibility: params.visibility,
+      publishAt: toUTCISO8601String(params.publish_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.articleRevisions.formatErrors(errors),
+        },
+        visibilityOptions: ctx.client.articles.visibilityOptions(),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/article_revisions/${revision.id}/general/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/article_revisions/LocksHandler.js

@@ -0,0 +1,54 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.articleRevisions.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, articleErrors } =
+    await ctx.client.articleRevisions.lock(parent_id, ctx.locale, message);
+
+  if (errors) {
+    return {
+      assigns: {
+        lock_settings: { revision, message },
+        errors: {
+          lock_settings: ctx.client.articles.formatErrors(errors, "message"),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  if (articleErrors) {
+    throw `Failed to lock revisions: ${JSON.stringify(articleErrors)}`;
+  }
+
+  return {
+    redirect: `/${ctx.locale}/articles/${revision.originalId}`,
+  };
+};
+
+export default {
+  create_form,
+  create,
+};

package/src/handlers/article_revisions/MetaHandler.js

@@ -0,0 +1,90 @@
+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 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.articleRevisions.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.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,
+        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.articleRevisions.formatErrors(errors),
+        },
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/article_revisions/${revision.id}/meta/edit`,
+  };
+};
+
+export default {
+  edit_form,
+  update,
+};

package/src/handlers/article_revisions/PublishesHandler.js

@@ -0,0 +1,90 @@
+const create_form = async (ctx) => {
+  const { parent_id } = ctx.params;
+
+  const revision = await ctx.client.articleRevisions.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.articles.visibilityOptions(),
+      errors: {},
+      _translations: [],
+    },
+  };
+};
+
+function publishArticleParams(
+  { 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.articleRevisions.find(
+    parent_id,
+    ctx.locale
+  );
+  const { errors } = await ctx.client.articleRevisions.publish(
+    revision.id,
+    ctx.locale,
+    {
+      title: publishing.title || "",
+      description: publishing.description || "",
+    },
+    publishArticleParams(publishing, revision.settings)
+  );
+
+  if (errors) {
+    return {
+      assigns: {
+        publishing: {
+          ...publishing,
+          id: revision.id,
+          originalId: revision.originalId,
+        },
+        visibilityOptions: ctx.client.articles.visibilityOptions(),
+        errors: ctx.client.articleRevisions.formatErrors(errors),
+        _translations: [],
+      },
+    };
+  }
+
+  return {
+    redirect: `/${ctx.locale}/articles/${revision.originalId}`,
+  };
+};
+
+export default {
+  create,
+  create_form,
+};