@raketa-cloud/admin 0.0.14 → 0.0.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/admin",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "main": "src/index.js",
   "scripts": {
     "dev": "npx tailwindcss -i ./src/styles/application.css -o ../../apps/admin/static/application.css --watch",

package/src/cloud/ArticleChanges.js

@@ -0,0 +1,15 @@
+import RaketaClient from "./RaketaClient";
+import { ArticleChangesDocument } from "./documents/articlesDocuments";
+
+export default class ArticleChanges extends RaketaClient {
+  async all(articleId, locale) {
+    const { articleChanges: items } = await this.query(ArticleChangesDocument, {
+      input: {
+        id: articleId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+}

package/src/cloud/ArticleRevisions.js

@@ -0,0 +1,152 @@
+import RaketaClient from "./RaketaClient";
+import {
+  DeleteArticleDocument,
+  LockArticleRevisionDocument,
+  MergeArticleRevisionDocument,
+  ArticleRevisionDocument,
+  ArticleRevisionsDocument,
+  StartArticleRevisionDocument,
+  UnlockArticleRevisionDocument,
+  UpdateArticleDocument,
+  UpdateArticleWidgetsDocument,
+  ReopenArticleChangeDocument,
+} from "./documents/articlesDocuments";
+
+export default class ArticleRevisions extends RaketaClient {
+  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 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 update(id, locale, params) {
+    const {
+      updateArticle: { errors, article },
+    } = await this.query(UpdateArticleDocument, {
+      input: {
+        id,
+        locale,
+        article: params,
+      },
+    });
+
+    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

@@ -0,0 +1,133 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CreateArticleDocument,
+  ArticleByIdDocument,
+  ArticlesDocument,
+  CloneArticleDocument,
+  DeleteArticleDocument,
+  TranslateArticleDocument,
+  ChangeArticleSlugDocument,
+} from "./documents/articlesDocuments";
+import { toDateTimeInput } from "../utils";
+
+export default class Articles extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      layout: "default",
+      publish_at: toDateTimeInput(new Date()),
+      tags: [],
+      categories: [],
+    };
+  }
+
+  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 list(query, locale) {
+    const { articles: items } = await this.query(
+      ArticlesDocument,
+      this.buildListInput(query, locale)
+    );
+
+    return items;
+  }
+
+  async create(params, locale, articleTypeSlug) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      createArticle: { errors, article },
+    } = await this.query(CreateArticleDocument, {
+      input: {
+        locale,
+        article: params,
+        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) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      translateArticle: { errors, article },
+    } = await this.query(TranslateArticleDocument, {
+      input: {
+        locale,
+        sourceArticleId: id,
+        article: params,
+      },
+    });
+
+    return { article, 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 };
+  }
+}

package/src/cloud/EventChanges.js

@@ -0,0 +1,15 @@
+import RaketaClient from "./RaketaClient";
+import { EventChangesDocument } from "./documents/eventsDocuments";
+
+export default class EventChanges extends RaketaClient {
+  async all(eventId, locale) {
+    const { eventChanges: items } = await this.query(EventChangesDocument, {
+      input: {
+        id: eventId,
+        locale,
+      },
+    });
+
+    return items;
+  }
+}

package/src/cloud/EventRevisions.js

@@ -0,0 +1,149 @@
+import RaketaClient from "./RaketaClient";
+import {
+  DeleteEventDocument,
+  LockEventRevisionDocument,
+  MergeEventRevisionDocument,
+  EventRevisionDocument,
+  EventRevisionsDocument,
+  StartEventRevisionDocument,
+  UnlockEventRevisionDocument,
+  UpdateEventDocument,
+  UpdateEventWidgetsDocument,
+  ReopenEventChangeDocument,
+} from "./documents/eventsDocuments";
+
+export default class EventRevisions extends RaketaClient {
+  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 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 update(id, locale, params) {
+    const {
+      updateEvent: { errors, event },
+    } = await this.query(UpdateEventDocument, {
+      input: {
+        id,
+        locale,
+        event: params,
+      },
+    });
+
+    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,135 @@
+import RaketaClient from "./RaketaClient";
+import {
+  CreateEventDocument,
+  EventByIdDocument,
+  EventsDocument,
+  CloneEventDocument,
+  DeleteEventDocument,
+  TranslateEventDocument,
+  ChangeEventSlugDocument,
+} from "./documents/eventsDocuments";
+import { toDateTimeInput } from "../utils";
+
+export default class Events extends RaketaClient {
+  defaults() {
+    return {
+      visibility: "private",
+      layout: "default",
+      publish_at: toDateTimeInput(new Date()),
+      starts_at: toDateTimeInput(new Date()),
+      ends_at: toDateTimeInput(new Date()),
+      tags: [],
+      categories: [],
+    };
+  }
+
+  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 list(query, locale) {
+    const { events: items } = await this.query(
+      EventsDocument,
+      this.buildListInput(query, locale)
+    );
+
+    return items;
+  }
+
+  async create(params, locale, eventTypeSlug) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      createEvent: { errors, event },
+    } = await this.query(CreateEventDocument, {
+      input: {
+        locale,
+        event: params,
+        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) {
+    params.widgets = JSON.stringify(params.widgets);
+    params.settings = JSON.stringify(params.settings);
+
+    const {
+      translateEvent: { errors, event },
+    } = await this.query(TranslateEventDocument, {
+      input: {
+        locale,
+        sourceEventId: id,
+        event: params,
+      },
+    });
+
+    return { event, 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 };
+  }
+}