@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/cloud/EventRevisions.js

@@ -0,0 +1,246 @@
+import { toUTCISO8601String } from "../utils";
+import RaketaClient from "./RaketaClient";
+import {
+  CancelEventRevisionScheduleDocument,
+  buildBatchStartEventRevisionDocument,
+  DeleteEventDocument,
+  EventRevisionDocument,
+  EventRevisionsDocument,
+  LockEventRevisionDocument,
+  MergeEventRevisionDocument,
+  ReopenEventChangeDocument,
+  ScheduleEventRevisionDocument,
+  StartEventRevisionDocument,
+  UnlockEventRevisionDocument,
+  UpdateEventDocument,
+  UpdateEventWidgetsDocument,
+} from "./documents/eventsDocuments";
+
+export default class EventRevisions extends RaketaClient {
+  selectUpdateParams(revision) {
+    return {
+      title: revision.title,
+      slug: revision.slug,
+      publishAt: revision.publishAt,
+      startsAt: revision.startsAt,
+      endsAt: revision.endsAt,
+      widgets: [...revision.widgets],
+      settings: {
+        ...revision.settings,
+      },
+      visibility: revision.visibility,
+      tags: revision.tags.map((t) => (t.id ? t.id : t)),
+      categories: revision.categories.map((c) => (c.id ? c.id : c)),
+    };
+  }
+
+  formatDates(params) {
+    if (params.publishAt) {
+      params.publishAt = toUTCISO8601String(params.publishAt);
+    }
+
+    if (params.startsAt) {
+      params.startsAt = toUTCISO8601String(params.startsAt);
+    }
+
+    if (params.endsAt) {
+      params.endsAt = toUTCISO8601String(params.endsAt);
+    }
+
+    return { ...params };
+  }
+
+  async all(eventId, locale) {
+    const { eventRevisions: items } = await this.query(EventRevisionsDocument, {
+      input: {
+        id: eventId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { eventRevision } = await this.query(EventRevisionDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return eventRevision;
+  }
+
+  async publish(id, locale, params, eventParams) {
+    const {
+      mergeEventRevision: { event, errors },
+    } = await this.query(MergeEventRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        event: { ...eventParams },
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async schedule(id, locale, params, eventParams) {
+    const {
+      scheduleEventRevision: { revision, errors, eventErrors },
+    } = await this.query(ScheduleEventRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        event: { ...eventParams },
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+
+  async cancelSchedule(id, locale) {
+    const {
+      cancelEventRevisionSchedule: { revision, errors, eventErrors },
+    } = await this.query(CancelEventRevisionScheduleDocument, {
+      input: {
+        revisionId: id,
+        locale: locale,
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+
+  async create(eventId, locale) {
+    const {
+      startEventRevision: { revision, errors, eventErrors },
+    } = await this.query(StartEventRevisionDocument, {
+      input: {
+        id: eventId,
+        locale,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+
+  async createBatch(revisionInputs) {
+    const BatchDocument = buildBatchStartEventRevisionDocument(
+      revisionInputs.length
+    );
+
+    const variables = {};
+    revisionInputs.forEach((input, i) => {
+      variables[`input${i}`] = {
+        id: input.eventId,
+        locale: input.locale,
+        title: "New revision",
+        description: "",
+      };
+    });
+
+    const response = await this.query(BatchDocument, variables);
+
+    return revisionInputs.map((_, i) => {
+      const result = response[`startRevision${i}`];
+      return {
+        revision: result.revision,
+        errors: result.errors,
+        eventErrors: result.eventErrors,
+      };
+    });
+  }
+
+  async update(id, locale, params) {
+    const copyParams = { ...params };
+
+    copyParams.widgets = JSON.stringify(params.widgets || []);
+    copyParams.settings = JSON.stringify(params.settings || {});
+
+    const {
+      updateEvent: { errors, event },
+    } = await this.query(UpdateEventDocument, {
+      input: {
+        id,
+        locale,
+        event: copyParams,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async updateWidgets(id, locale, widgets) {
+    const {
+      updateEventWidgets: { errors, event },
+    } = await this.query(UpdateEventWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async delete(revisionId, locale) {
+    const {
+      deleteEvent: { event, errors },
+    } = await this.query(DeleteEventDocument, {
+      input: {
+        id: revisionId,
+        locale,
+      },
+    });
+
+    return { revision: event, errors };
+  }
+
+  async lock(revisionId, locale, message) {
+    const {
+      lockEventRevision: { revision, errors },
+    } = await this.query(LockEventRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale) {
+    const {
+      unlockEventRevision: { revision, errors },
+    } = await this.query(UnlockEventRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async revert(eventId, version, locale) {
+    const {
+      reopenEventChange: { revision, errors, eventErrors },
+    } = await this.query(ReopenEventChangeDocument, {
+      input: {
+        eventId,
+        locale,
+        version,
+      },
+    });
+
+    return { revision, errors, eventErrors };
+  }
+}

package/src/cloud/Events.js

@@ -0,0 +1,204 @@
+import { toDateTimeInput, toUTCISO8601String } from "../utils";
+import RaketaClient from "./RaketaClient";
+import {
+  ChangeEventSlugDocument,
+  CloneEventDocument,
+  buildBatchTranslateEventDocument,
+  CreateEventDocument,
+  DeleteEventDocument,
+  EventByIdDocument,
+  EventsDocument,
+  MiniEventsDocument,
+  TranslateEventDocument,
+} from "./documents/eventsDocuments";
+
+export default class Events extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      publishAt: toDateTimeInput(),
+      startsAt: toDateTimeInput(),
+      endsAt: toDateTimeInput(),
+      settings: {
+        layout: "default",
+      },
+      widgets: [],
+      tags: [],
+      categories: [],
+    };
+  }
+
+  formatDates(params) {
+    if (params.publishAt) {
+      params.publishAt = toUTCISO8601String(params.publishAt);
+    }
+
+    if (params.startsAt) {
+      params.startsAt = toUTCISO8601String(params.startsAt);
+    }
+
+    if (params.endsAt) {
+      params.endsAt = toUTCISO8601String(params.endsAt);
+    }
+
+    return { ...params };
+  }
+
+  visibilityOptions() {
+    return [
+      ["private", "Private"],
+      ["public", "Public"],
+      ["unlisted", "Unlisted"],
+      ["protected", "Password protected"],
+    ];
+  }
+
+  async find(id, locale) {
+    const { event: item } = await this.query(EventByIdDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return item;
+  }
+
+  async listAll(query, locale, eventTypeSlug) {
+    const vars = this.buildAllInput(query, locale);
+
+    const { miniEvents: items } = await this.query(MiniEventsDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, eventTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async list(query, locale, eventTypeSlug) {
+    const vars = this.buildListInput(query, locale);
+
+    const { events: items } = await this.query(EventsDocument, {
+      input: {
+        ...vars.input,
+        filters: { ...vars.input.filters, eventTypeSlug },
+      },
+    });
+
+    return items;
+  }
+
+  async create(params, locale, eventTypeSlug) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      createEvent: { errors, event },
+    } = await this.query(CreateEventDocument, {
+      input: {
+        locale,
+        event: paramsCopy,
+        eventTypeSlug,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async clone(id, locale) {
+    const {
+      cloneEvent: { errors, event },
+    } = await this.query(CloneEventDocument, {
+      input: { id: id, locale: locale },
+    });
+
+    return { event, errors };
+  }
+
+  async delete(id, locale, redirect) {
+    const input = {
+      id,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      deleteEvent: { errors, event },
+    } = await this.query(DeleteEventDocument, { input });
+
+    return { event, errors };
+  }
+
+  async translate(id, locale, params) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const {
+      translateEvent: { errors, event },
+    } = await this.query(TranslateEventDocument, {
+      input: {
+        locale,
+        sourceEventId: id,
+        event: paramsCopy,
+      },
+    });
+
+    return { event, errors };
+  }
+
+  async translateBatch(sourceEventId, locales, params) {
+    const paramsCopy = { ...params };
+    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
+    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
+
+    const BatchTranslateDocument = buildBatchTranslateEventDocument(
+      locales.length
+    );
+
+    const variables = {};
+    locales.forEach((locale, i) => {
+      variables[`input${i}`] = {
+        locale,
+        sourceEventId,
+        event: paramsCopy,
+      };
+    });
+
+    const response = await this.query(BatchTranslateDocument, variables);
+
+    return locales.map((_, i) => {
+      const result = response[`translate${i}`];
+      return {
+        event: result.event,
+        errors: result.errors,
+      };
+    });
+  }
+
+  async updateSlug(id, slug, locale, redirect) {
+    const input = {
+      id,
+      slug,
+      locale,
+    };
+
+    if (redirect) {
+      input.redirect = redirect;
+    }
+
+    const {
+      changeEventSlug: { errors, event },
+    } = await this.query(ChangeEventSlugDocument, {
+      input,
+    });
+
+    return { event, errors };
+  }
+}

package/src/cloud/PageChanges.js

@@ -0,0 +1,36 @@
+import RaketaClient from "./RaketaClient";
+import {
+  PageHistoryDocument,
+  PageEditorsDocument,
+} from "./documents/pagesDocuments";
+
+export default class PageChanges extends RaketaClient {
+  async list(query, pageId, locale) {
+    const vars = this.buildListInput(query, locale);
+
+    const { pageHistory: items } = await this.query(PageHistoryDocument, {
+      input: {
+        ...vars.input,
+        id: pageId,
+        locale,
+        pagination: {
+          ...(vars.input.pagination || {}),
+          page_size: 50,
+        },
+      },
+    });
+
+    return items;
+  }
+
+  async all_editors(pageId, locale) {
+    const { pageEditors } = await this.query(PageEditorsDocument, {
+      input: {
+        id: pageId,
+        locale,
+      },
+    });
+
+    return pageEditors?.list;
+  }
+}

package/src/cloud/PageRevisions.js

@@ -0,0 +1,226 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CancelPageRevisionScheduleDocument,
+  DeletePageDocument,
+  LockPageRevisionDocument,
+  MergePageRevisionDocument,
+  PageRevisionDocument,
+  PageRevisionsDocument,
+  ReopenPageChangeDocument,
+  SchedulePageRevisionDocument,
+  StartPageRevisionDocument,
+  UnlockPageRevisionDocument,
+  UpdatePageDocument,
+  UpdatePageWidgetsDocument,
+  buildBatchStartPageRevisionDocument,
+} from "./documents/pagesDocuments";
+
+export default class PageRevisions extends RaketaClient {
+  selectUpdateParams(revision) {
+    return {
+      title: revision.title,
+      slug: revision.slug,
+      widgets: [...revision.widgets],
+      settings: {
+        ...revision.settings,
+      },
+      visibility: revision.visibility,
+      tags: revision.tags.map((t) => (t.id ? t.id : t)),
+      categories: revision.categories.map((c) => (c.id ? c.id : c)),
+    };
+  }
+
+  async all(pageId, locale) {
+    const { pageRevisions: items } = await this.query(PageRevisionsDocument, {
+      input: {
+        id: pageId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+
+  async find(id, locale) {
+    const { pageRevision } = await this.query(PageRevisionDocument, {
+      input: {
+        id,
+        locale,
+      },
+    });
+
+    return pageRevision;
+  }
+
+  async publish(id, locale, params, pageParams) {
+    const {
+      mergePageRevision: { page, errors },
+    } = await this.query(MergePageRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        page: { ...pageParams },
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async schedule(id, locale, params, pageParams) {
+    const {
+      schedulePageRevision: { revision, errors, pageErrors },
+    } = await this.query(SchedulePageRevisionDocument, {
+      input: {
+        id,
+        locale,
+        ...params,
+        page: { ...pageParams },
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+
+  async cancelSchedule(id, locale) {
+    const {
+      cancelPageRevisionSchedule: { revision, errors, pageErrors },
+    } = await this.query(CancelPageRevisionScheduleDocument, {
+      input: {
+        revisionId: id,
+        locale: locale,
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+
+  async create(pageId, locale) {
+    const {
+      startPageRevision: { revision, errors, pageErrors },
+    } = await this.query(StartPageRevisionDocument, {
+      input: {
+        id: pageId,
+        locale,
+        title: "New revision",
+        description: "",
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+
+  async createBatch(revisionInputs) {
+    const BatchStartRevisionDocument = buildBatchStartPageRevisionDocument(
+      revisionInputs.length
+    );
+
+    const variables = {};
+    revisionInputs.forEach((input, i) => {
+      variables[`input${i}`] = {
+        id: input.pageId,
+        locale: input.locale,
+        title: "New revision",
+        description: "",
+      };
+    });
+
+    const response = await this.query(BatchStartRevisionDocument, variables);
+
+    return revisionInputs.map((_, i) => {
+      const result = response[`startRevision${i}`];
+      return {
+        revision: result.revision,
+        errors: result.errors,
+        pageErrors: result.pageErrors,
+      };
+    });
+  }
+
+  async update(id, locale, params) {
+    const copyParams = { ...params };
+
+    copyParams.widgets = JSON.stringify(params.widgets || []);
+    copyParams.settings = JSON.stringify(params.settings || {});
+
+    const {
+      updatePage: { errors, page },
+    } = await this.query(UpdatePageDocument, {
+      input: {
+        id,
+        locale,
+        page: copyParams,
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async updateWidgets(id, locale, widgets) {
+    const {
+      updatePageWidgets: { errors, page },
+    } = await this.query(UpdatePageWidgetsDocument, {
+      input: {
+        id,
+        locale,
+        widgets: JSON.stringify(widgets),
+      },
+    });
+
+    return { page, errors };
+  }
+
+  async delete(revisionId, locale) {
+    const {
+      deletePage: { page, errors },
+    } = await this.query(DeletePageDocument, {
+      input: {
+        id: revisionId,
+        locale,
+      },
+    });
+
+    return { revision: page, errors };
+  }
+
+  async lock(revisionId, locale, message) {
+    const {
+      lockPageRevision: { revision, errors },
+    } = await this.query(LockPageRevisionDocument, {
+      input: {
+        revisionId,
+        message,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async unlock(revisionId, locale) {
+    const {
+      unlockPageRevision: { revision, errors },
+    } = await this.query(UnlockPageRevisionDocument, {
+      input: {
+        revisionId,
+        locale,
+      },
+    });
+
+    return { revision, errors };
+  }
+
+  async revert(pageId, version, locale) {
+    const {
+      reopenPageChange: { revision, errors, pageErrors },
+    } = await this.query(ReopenPageChangeDocument, {
+      input: {
+        pageId,
+        locale,
+        version,
+      },
+    });
+
+    return { revision, errors, pageErrors };
+  }
+}