@raketa-cloud/admin 1.8.3 → 1.8.6

package/src/cloud/EventRevisions.js

@@ -1,246 +0,0 @@
-import { toUTCISO8601String, dateToUTCISO8601String } 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 = dateToUTCISO8601String(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

@@ -1,231 +0,0 @@
-import {
-  dateToUTCISO8601String,
-  toDateInput,
-  toDateTimeInput,
-  toUTCISO8601String,
-} from "../utils";
-import RaketaClient from "./RaketaClient";
-import {
-  ChangeEventSlugDocument,
-  CloneEventDocument,
-  CreateEventDocument,
-  DeleteEventDocument,
-  EventByIdDocument,
-  EventChangePreviewDocument,
-  EventsDocument,
-  MiniEventsDocument,
-  TranslateEventDocument,
-  buildBatchTranslateEventDocument,
-} from "./documents/eventsDocuments";
-
-export default class Events extends RaketaClient {
-  defaults() {
-    return {
-      visibility: "private",
-      publishAt: toDateInput(new Date()),
-      startsAt: toDateTimeInput(),
-      endsAt: toDateTimeInput(),
-      settings: {
-        layout: "default",
-      },
-      widgets: [],
-      tags: [],
-      categories: [],
-    };
-  }
-
-  formatDates(params) {
-    if (params.publishAt) {
-      params.publishAt = dateToUTCISO8601String(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);
-
-    vars.input.filters = this.formatDateFilters(vars.input.filters);
-
-    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);
-
-    vars.input.filters = this.formatDateFilters(vars.input.filters);
-
-    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 };
-  }
-
-  async getChangePreview(eventId, version, locale) {
-    const input = {
-      eventId,
-      version: Number.parseInt(version, 10),
-      locale,
-    };
-
-    const { eventChangePreview } = await this.query(
-      EventChangePreviewDocument,
-      {
-        input,
-      },
-    );
-
-    return eventChangePreview;
-  }
-}

package/src/cloud/PageChanges.js

@@ -1,36 +0,0 @@
-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;
-  }
-}