@raketa-cloud/admin 1.8.3 → 1.8.6

package/src/cloud/ArticleRevisions.js

@@ -1,239 +0,0 @@
-import { dateToUTCISO8601String } from "../utils";
-import RaketaClient from "./RaketaClient";
-import {
-  ArticleRevisionDocument,
-  ArticleRevisionsDocument,
-  CancelArticleRevisionScheduleDocument,
-  buildBatchStartArticleRevisionDocument,
-  DeleteArticleDocument,
-  LockArticleRevisionDocument,
-  MergeArticleRevisionDocument,
-  ReopenArticleChangeDocument,
-  ScheduleArticleRevisionDocument,
-  StartArticleRevisionDocument,
-  UnlockArticleRevisionDocument,
-  UpdateArticleDocument,
-  UpdateArticleWidgetsDocument,
-} from "./documents/articlesDocuments";
-
-export default class ArticleRevisions extends RaketaClient {
-  selectUpdateParams(revision) {
-    return {
-      title: revision.title,
-      slug: revision.slug,
-      publishAt: revision.publishAt,
-      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);
-    }
-
-    return { ...params };
-  }
-
-  async all(articleId, locale) {
-    const { articleRevisions: items } = await this.query(
-      ArticleRevisionsDocument,
-      {
-        input: {
-          id: articleId,
-          locale,
-        },
-      }
-    );
-
-    return items;
-  }
-
-  async find(id, locale) {
-    const { articleRevision } = await this.query(ArticleRevisionDocument, {
-      input: {
-        id,
-        locale,
-      },
-    });
-
-    return articleRevision;
-  }
-
-  async publish(id, locale, params, articleParams) {
-    const {
-      mergeArticleRevision: { article, errors },
-    } = await this.query(MergeArticleRevisionDocument, {
-      input: {
-        id,
-        locale,
-        ...params,
-        article: { ...articleParams },
-      },
-    });
-
-    return { article, errors };
-  }
-
-  async schedule(id, locale, params, articleParams) {
-    const {
-      scheduleArticleRevision: { revision, errors, articleErrors },
-    } = await this.query(ScheduleArticleRevisionDocument, {
-      input: {
-        id,
-        locale,
-        ...params,
-        article: { ...articleParams },
-      },
-    });
-
-    return { revision, errors, articleErrors };
-  }
-
-  async cancelSchedule(id, locale) {
-    const {
-      cancelArticleRevisionSchedule: { revision, errors, articleErrors },
-    } = await this.query(CancelArticleRevisionScheduleDocument, {
-      input: {
-        revisionId: id,
-        locale: locale,
-      },
-    });
-
-    return { revision, errors, articleErrors };
-  }
-
-  async create(articleId, locale) {
-    const {
-      startArticleRevision: { revision, errors, articleErrors },
-    } = await this.query(StartArticleRevisionDocument, {
-      input: {
-        id: articleId,
-        locale,
-        title: "New revision",
-        description: "",
-      },
-    });
-
-    return { revision, errors, articleErrors };
-  }
-
-  async createBatch(revisionInputs) {
-    const BatchDocument = buildBatchStartArticleRevisionDocument(
-      revisionInputs.length
-    );
-
-    const variables = {};
-    revisionInputs.forEach((input, i) => {
-      variables[`input${i}`] = {
-        id: input.articleId,
-        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,
-        articleErrors: result.articleErrors,
-      };
-    });
-  }
-
-  async update(id, locale, params) {
-    const copyParams = { ...params };
-
-    copyParams.widgets = JSON.stringify(params.widgets || []);
-    copyParams.settings = JSON.stringify(params.settings || {});
-
-    const {
-      updateArticle: { errors, article },
-    } = await this.query(UpdateArticleDocument, {
-      input: {
-        id,
-        locale,
-        article: copyParams,
-      },
-    });
-
-    return { article, errors };
-  }
-
-  async updateWidgets(id, locale, widgets) {
-    const {
-      updateArticleWidgets: { errors, article },
-    } = await this.query(UpdateArticleWidgetsDocument, {
-      input: {
-        id,
-        locale,
-        widgets: JSON.stringify(widgets),
-      },
-    });
-
-    return { article, errors };
-  }
-
-  async delete(revisionId, locale) {
-    const {
-      deleteArticle: { article, errors },
-    } = await this.query(DeleteArticleDocument, {
-      input: {
-        id: revisionId,
-        locale,
-      },
-    });
-
-    return { revision: article, errors };
-  }
-
-  async lock(revisionId, locale, message) {
-    const {
-      lockArticleRevision: { revision, errors },
-    } = await this.query(LockArticleRevisionDocument, {
-      input: {
-        revisionId,
-        message,
-        locale,
-      },
-    });
-
-    return { revision, errors };
-  }
-
-  async unlock(revisionId, locale) {
-    const {
-      unlockArticleRevision: { revision, errors },
-    } = await this.query(UnlockArticleRevisionDocument, {
-      input: {
-        revisionId,
-        locale,
-      },
-    });
-
-    return { revision, errors };
-  }
-
-  async revert(articleId, version, locale) {
-    const {
-      reopenArticleChange: { revision, errors, articleErrors },
-    } = await this.query(ReopenArticleChangeDocument, {
-      input: {
-        articleId,
-        locale,
-        version,
-      },
-    });
-
-    return { revision, errors, articleErrors };
-  }
-}

package/src/cloud/Articles.js

@@ -1,216 +0,0 @@
-import { dateToUTCISO8601String, toDateInput } from "../utils";
-import RaketaClient from "./RaketaClient";
-import {
-  ArticleByIdDocument,
-  ArticleChangePreviewDocument,
-  ArticlesDocument,
-  ChangeArticleSlugDocument,
-  CloneArticleDocument,
-  CreateArticleDocument,
-  DeleteArticleDocument,
-  MiniArticlesDocument,
-  TranslateArticleDocument,
-  buildBatchTranslateArticleDocument,
-} from "./documents/articlesDocuments";
-
-export default class Articles extends RaketaClient {
-  defaults() {
-    return {
-      visibility: "private",
-      publishAt: toDateInput(new Date()),
-      settings: {
-        layout: "default",
-      },
-      widgets: [],
-      tags: [],
-      categories: [],
-    };
-  }
-
-  formatDates(params) {
-    if (params.publishAt) {
-      params.publishAt = dateToUTCISO8601String(params.publishAt);
-    }
-
-    return { ...params };
-  }
-
-  visibilityOptions() {
-    return [
-      ["private", "Private"],
-      ["public", "Public"],
-      ["unlisted", "Unlisted"],
-      ["protected", "Password protected"],
-    ];
-  }
-
-  async find(id, locale) {
-    const { article: item } = await this.query(ArticleByIdDocument, {
-      input: {
-        id,
-        locale,
-      },
-    });
-
-    return item;
-  }
-
-  async listAll(query, locale, articleTypeSlug) {
-    const vars = this.buildAllInput(query, locale);
-
-    vars.input.filters = this.formatDateFilters(vars.input.filters);
-
-    const { miniArticles: items } = await this.query(MiniArticlesDocument, {
-      input: {
-        ...vars.input,
-        filters: { ...vars.input.filters, articleTypeSlug },
-      },
-    });
-
-    return items;
-  }
-
-  async list(query, locale, articleTypeSlug) {
-    const vars = this.buildListInput(query, locale);
-
-    vars.input.filters = this.formatDateFilters(vars.input.filters);
-
-    const { articles: items } = await this.query(ArticlesDocument, {
-      input: {
-        ...vars.input,
-        filters: { ...vars.input.filters, articleTypeSlug },
-      },
-    });
-
-    return items;
-  }
-
-  async create(params, locale, articleTypeSlug) {
-    const paramsCopy = { ...params };
-    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
-    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
-
-    const {
-      createArticle: { errors, article },
-    } = await this.query(CreateArticleDocument, {
-      input: {
-        locale,
-        article: paramsCopy,
-        articleTypeSlug,
-      },
-    });
-
-    return { article, errors };
-  }
-
-  async clone(id, locale) {
-    const {
-      cloneArticle: { errors, article },
-    } = await this.query(CloneArticleDocument, {
-      input: { id: id, locale: locale },
-    });
-
-    return { article, errors };
-  }
-
-  async delete(id, locale, redirect) {
-    const input = {
-      id,
-      locale,
-    };
-
-    if (redirect) {
-      input.redirect = redirect;
-    }
-
-    const {
-      deleteArticle: { errors, article },
-    } = await this.query(DeleteArticleDocument, { input });
-
-    return { article, errors };
-  }
-
-  async translate(id, locale, params) {
-    const paramsCopy = { ...params };
-    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
-    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
-
-    const {
-      translateArticle: { errors, article },
-    } = await this.query(TranslateArticleDocument, {
-      input: {
-        locale,
-        sourceArticleId: id,
-        article: paramsCopy,
-      },
-    });
-
-    return { article, errors };
-  }
-
-  async translateBatch(sourceArticleId, locales, params) {
-    const paramsCopy = { ...params };
-    paramsCopy.widgets = JSON.stringify(paramsCopy.widgets);
-    paramsCopy.settings = JSON.stringify(paramsCopy.settings);
-
-    const BatchTranslateDocument = buildBatchTranslateArticleDocument(
-      locales.length,
-    );
-
-    const variables = {};
-    locales.forEach((locale, i) => {
-      variables[`input${i}`] = {
-        locale,
-        sourceArticleId,
-        article: paramsCopy,
-      };
-    });
-
-    const response = await this.query(BatchTranslateDocument, variables);
-
-    return locales.map((_, i) => {
-      const result = response[`translate${i}`];
-      return {
-        article: result.article,
-        errors: result.errors,
-      };
-    });
-  }
-
-  async updateSlug(id, slug, locale, redirect) {
-    const input = {
-      id,
-      slug,
-      locale,
-    };
-
-    if (redirect) {
-      input.redirect = redirect;
-    }
-
-    const {
-      changeArticleSlug: { errors, article },
-    } = await this.query(ChangeArticleSlugDocument, {
-      input,
-    });
-
-    return { article, errors };
-  }
-
-  async getChangePreview(articleId, version, locale) {
-    const input = {
-      articleId,
-      version: Number.parseInt(version, 10),
-      locale,
-    };
-
-    const { articleChangePreview } = await this.query(
-      ArticleChangePreviewDocument,
-      {
-        input,
-      },
-    );
-
-    return articleChangePreview;
-  }
-}

package/src/cloud/EventChanges.js

@@ -1,36 +0,0 @@
-import RaketaClient from "./RaketaClient";
-import {
-  EventHistoryDocument,
-  EventEditorsDocument,
-} from "./documents/eventsDocuments";
-
-export default class EventChanges extends RaketaClient {
-  async list(query, eventId, locale) {
-    const vars = this.buildListInput(query, locale);
-
-    const { eventHistory: items } = await this.query(EventHistoryDocument, {
-      input: {
-        ...vars.input,
-        id: eventId,
-        locale,
-        pagination: {
-          ...(vars.input.pagination || {}),
-          page_size: 50,
-        },
-      },
-    });
-
-    return items;
-  }
-
-  async all_editors(eventId, locale) {
-    const { eventEditors } = await this.query(EventEditorsDocument, {
-      input: {
-        id: eventId,
-        locale,
-      },
-    });
-
-    return eventEditors?.list;
-  }
-}