@alpaca-editor/core 1.0.3762-mono

package/src/editor/services/editService.ts

@@ -0,0 +1,462 @@
+import Cookies from "universal-cookie";
+import {
+  EditOperation,
+  FieldDescriptor,
+  FieldHistoryItem,
+  InsertOption,
+  User,
+} from "../../types";
+import { ItemTreeNodeData } from "./contentService";
+import { ExecutionResult, get, post } from "./serviceHelper";
+import {
+  Field,
+  FieldButton,
+  ItemDescriptor,
+  ItemIdAndName,
+} from "../pageModel";
+import { PictureRawValue } from "../fieldTypes";
+
+export type PlaceholderInsertOptions = {
+  key: string;
+  insertOptions: InsertOption[];
+};
+
+export type { ExecutionResult } from "./serviceHelper";
+
+export function connectSocket(sessionId: string): WebSocket {
+  const host = window.location.hostname;
+  const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+  const port = window.location.port ? `:${window.location.port}` : "";
+
+  const socketUrl = `${protocol}//${host}${port}/alpaca/editor/socket?sessionId=${sessionId}`;
+
+  console.log("Connect to socket: " + socketUrl);
+
+  return new WebSocket(socketUrl);
+}
+export async function getPictureValue(
+  field: Field,
+  pictureRawValue: PictureRawValue,
+  site: string,
+  sessionId: string,
+) {
+  const fieldItem = field.descriptor.item;
+  if (!fieldItem) return;
+
+  const response = await fetch(
+    "/alpaca/editor/getPictureValue?sessionId=" + sessionId,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        site,
+        itemId: fieldItem.id,
+        itemLanguage: fieldItem.language,
+        itemVersion: fieldItem.version,
+        pictureFieldId: field.id,
+        pictureValue: JSON.stringify(pictureRawValue),
+      }),
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: new Cookies().getAll(),
+      },
+    },
+  );
+  return await response.json();
+}
+
+export async function executeEditOperation(
+  editOperation: EditOperation,
+  sessionId: string,
+): Promise<ExecutionResult<unknown>> {
+  editOperation.sessionId = sessionId;
+
+  return post("/alpaca/editor/edit", editOperation, sessionId);
+}
+
+export async function executeUndo(
+  sessionId: string,
+  editOperationIds: string[],
+): Promise<ExecutionResult<any>> {
+  return post("/alpaca/editor/undo", { editOperationIds }, sessionId);
+}
+
+export async function executeRedo(
+  sessionId: string,
+  editOperationId: string,
+): Promise<ExecutionResult<any>> {
+  return post(
+    "/alpaca/editor/redo",
+    { editOperationIds: [editOperationId] },
+    sessionId,
+  );
+}
+
+export async function executeDeleteItems(
+  items: ItemDescriptor[],
+): Promise<ExecutionResult<any>> {
+  return post("/alpaca/editor/deleteItems", items);
+}
+
+function getItemDescriptor(item: ItemDescriptor) {
+  return {
+    id: item.id,
+    language: item.language,
+    version: item.version,
+  };
+}
+
+export async function lockItems(
+  items: ItemDescriptor[],
+): Promise<ExecutionResult<any>> {
+  const response = await post(
+    "/alpaca/editor/lock",
+    items.map(getItemDescriptor),
+  );
+  return response;
+}
+
+export async function unlockItems(
+  items: ItemDescriptor[],
+): Promise<ExecutionResult<any>> {
+  const response = await post(
+    "/alpaca/editor/unlock",
+    items.map(getItemDescriptor),
+  );
+  return response;
+}
+
+export async function lockField(
+  item: ItemDescriptor,
+  fieldId: string,
+  sessionId: string,
+): Promise<ExecutionResult<any>> {
+  const response = await post("/alpaca/editor/lockField", {
+    item,
+    fieldId: fieldId,
+    sessionId: sessionId,
+  });
+
+  return response;
+}
+
+export async function releaseFieldLocks(
+  sessionId: string,
+): Promise<ExecutionResult<any>> {
+  const response = await post("/alpaca/editor/releaseFieldLocks", {
+    sessionId,
+  });
+  return response;
+}
+
+export async function validateItems(
+  items: ItemDescriptor[],
+  sessionId: string,
+): Promise<ExecutionResult<any>> {
+  const response = await post(
+    "/alpaca/editor/validate",
+    items.map(getItemDescriptor),
+    sessionId,
+  );
+  if (response.type !== "success") return response;
+
+  return await response;
+}
+
+export async function executeWorkflowCommand(
+  item: ItemDescriptor,
+  commandId: string,
+  comment: string,
+): Promise<ExecutionResult<any>> {
+  const response = await post("/alpaca/editor/executeWorkflowCommand", {
+    item,
+    commandId,
+    comment,
+  });
+  return response;
+}
+
+export async function executeFieldAction(
+  item: ItemDescriptor,
+  fieldId: string,
+  pageItem: ItemDescriptor,
+  action: string,
+  sessionId: string,
+  selectedText: string,
+  callback: (data: any) => void,
+): Promise<ExecutionResult<any>> {
+  const response = await fetch(
+    "/alpaca/editor/executeFieldAction?sessionId=" + sessionId,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        item,
+        pageItem,
+        fieldId,
+        action,
+        selectedText,
+        sessionId,
+      }),
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: new Cookies().getAll(),
+      },
+    },
+  );
+  if (response.status === 500 || response.redirected) {
+    return {
+      type: "error",
+      summary: "Error",
+      details: "An error occured executing the field action.",
+      response,
+    };
+  }
+
+  if (response.status === 401) {
+    return {
+      type: "error",
+      summary: "Unauthorized",
+      details: "Not logged in anymore?",
+      response,
+    };
+  }
+
+  if (!response?.body)
+    return {
+      type: "error",
+      summary: "Error",
+      details: "An error occured.",
+      response,
+    };
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  let result = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+
+    if (done) {
+      break;
+    }
+
+    buffer += decoder.decode(value, { stream: true }); // 'stream: true' ensures that any incomplete multi-byte characters aren't malformed.
+
+    // Split the buffer by newline and keep the last partial line for the next iteration.
+    const lines = buffer.split("\n");
+
+    if (lines.length > 0) {
+      buffer = lines.pop() || ""; // Incomplete line (if any) is kept for the next iteration.
+
+      for (let line of lines) {
+        if (line.trim() === "") continue; // Skip empty lines if any.
+
+        try {
+          const jsonData = JSON.parse(line);
+          callback(jsonData);
+          result = jsonData;
+        } catch (e) {
+          console.error("Error parsing line:" + line, e);
+        }
+      }
+    }
+  }
+
+  // If there's any remaining content in the buffer after processing all chunks, try to process it.
+  if (buffer.trim() !== "") {
+    try {
+      const jsonData = JSON.parse(buffer);
+      result = jsonData;
+    } catch (e) {
+      console.error("Error parsing the final buffer content:", e);
+    }
+  }
+  callback(result);
+  return result;
+}
+
+export async function createVersion(
+  page: ItemDescriptor,
+  sessionId: string,
+): Promise<ExecutionResult<any>> {
+  const response = await fetch(
+    // configuration.services.editorService.baseUrl +
+    "/alpaca/editor/createVersion?sessionId=" + sessionId,
+    {
+      method: "POST",
+      body: JSON.stringify({
+        item: page,
+      }),
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        Cookie: new Cookies().getAll(),
+      },
+    },
+  );
+
+  if (response.ok) return { type: "success", response };
+  else {
+    if (response.status === 401) {
+      return {
+        type: "error",
+        summary: "Unauthorized",
+        details: "Not logged in anymore?",
+        response,
+      };
+    }
+
+    return {
+      type: "error",
+      summary: "Error",
+      details: "An error occured while saving changes.",
+      response,
+    };
+  }
+}
+
+export async function deleteVersion(
+  page: ItemDescriptor,
+  sessionId: string,
+): Promise<ExecutionResult<any>> {
+  const url = "/alpaca/editor/deleteVersion?sessionId=" + sessionId;
+  return await post<any>(url, { item: getItemDescriptor(page) });
+}
+
+export async function loadInsertOptions(
+  item: ItemDescriptor,
+): Promise<ItemTreeNodeData[]> {
+  let url =
+    //configuration.services.editorService.baseUrl +
+    "/alpaca/editor/insertoptions";
+
+  const response = await fetch(url, {
+    method: "POST",
+    credentials: "include",
+    body: JSON.stringify(item),
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: new Cookies().getAll(),
+    },
+  });
+  return await response.json();
+}
+
+export async function loadPlaceholderInsertOptions(
+  pageItem: ItemDescriptor,
+  placeholderKeys: string[],
+): Promise<PlaceholderInsertOptions[]> {
+  let url = "/alpaca/editor/placeholderinsertoptions";
+
+  const response = await fetch(url, {
+    method: "POST",
+    credentials: "include",
+    body: JSON.stringify({ pageItem, placeholderKeys }),
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: new Cookies().getAll(),
+    },
+  });
+  return await response.json();
+}
+
+export async function loadFieldButtons(
+  field: FieldDescriptor,
+): Promise<FieldButton[]> {
+  let url =
+    //configuration.services.editorService.baseUrl +
+    "/alpaca/editor/fieldbuttons";
+
+  const response = await fetch(url, {
+    method: "POST",
+    credentials: "include",
+    body: JSON.stringify(field),
+    headers: {
+      "Content-Type": "application/json",
+      Cookie: new Cookies().getAll(),
+    },
+  });
+  return await response.json();
+}
+
+export async function getLookupSources(
+  field: Field,
+  sessionId: string,
+): Promise<ItemIdAndName[]> {
+  let url = "/alpaca/editor/getlookupsources";
+  const fieldItem = field.descriptor.item;
+
+  const response = await post<ItemIdAndName[]>(
+    url,
+    { item: fieldItem, fieldId: field.id },
+    sessionId,
+  );
+
+  return (await response.data) || [];
+}
+
+export async function executeCreateItem(
+  parent: ItemDescriptor,
+  templateId: string,
+  name: string,
+): Promise<ExecutionResult<any>> {
+  let url = "/alpaca/editor/createItem";
+
+  const resopnse = post<ItemDescriptor>(url, { parent, templateId, name });
+  return resopnse;
+}
+
+export async function getEditHistory(
+  item: ItemDescriptor,
+): Promise<ExecutionResult<EditOperation[]>> {
+  let url =
+    "/alpaca/editor/editHistory?itemId=" +
+    item.id +
+    "&language=" +
+    item.language +
+    "&version=" +
+    item.version;
+
+  const result = get<EditOperation[]>(url);
+
+  return result;
+}
+
+export async function getFieldHistory(
+  item: ItemDescriptor,
+  fieldId: string,
+): Promise<ExecutionResult<FieldHistoryItem[]>> {
+  let url =
+    "/alpaca/editor/fieldHistory?itemId=" +
+    item.id +
+    "&language=" +
+    item.language +
+    "&version=" +
+    item.version +
+    "&fieldId=" +
+    fieldId;
+
+  const result = get<FieldHistoryItem[]>(url);
+
+  return result;
+}
+
+export async function getUserInfo(): Promise<User> {
+  const response = await fetch("/alpaca/editor/userinfo");
+  return await response.json();
+}
+
+export async function executeMoveItems(
+  items: ItemDescriptor[],
+  target: ItemDescriptor,
+  index: number,
+): Promise<ExecutionResult<any>> {
+  return post("/alpaca/editor/moveItems", {
+    items: items.map(getItemDescriptor),
+    target: getItemDescriptor(target),
+    index,
+  });
+}

package/src/editor/services/indexService.ts

@@ -0,0 +1,24 @@
+import { IndexStatus } from "../../types";
+import { get, post } from "./serviceHelper";
+
+export async function getIndexStatus(index: string) {
+  var result = await get<IndexStatus>("/alpaca/headless/editor/index/status?name=" + index);
+  return result.data;
+}
+
+export async function setupIndex(index: string) {
+  await post("/alpaca/headless/editor/index/setup?name=" + index, {});
+}
+
+export async function setupRebuildJob(index: string) {
+  await post("/alpaca/headless/editor/index/setuprebuildjob?name=" + index, {});
+}
+
+export async function rebuildIndex(index: string) {
+  await post("/alpaca/headless/editor/index/rebuild?name=" + index, {});
+}
+
+export async function getIndexes(): Promise<string[]> {
+  var result = await get<string[]>("/alpaca/headless/editor/index/list");
+  return result.data || [];
+}

package/src/editor/services/reviewsService.ts

@@ -0,0 +1,45 @@
+
+import { get, post } from "./serviceHelper";
+import { Comment, Review, Reviewer } from "../../types";
+import { ItemDescriptor } from "../pageModel";
+
+export function createOrUpdateComment(comment: Comment) {
+  return post("/alpaca/editor/comments/save", comment);
+}
+
+export function getComments(itemId: string, language: string, version: number) {  
+  return get<Comment[]>(`/alpaca/editor/comments/index?mainItemId=${itemId}&language=${language}&version=${version}`);
+}
+
+export function resolveComment(comment: Comment) {
+  return post(`/alpaca/editor/comments/resolve?commentId=${comment.id}`, {});
+}
+
+export function deleteComment(comment: Comment) {
+  return post(`/alpaca/editor/comments/delete?commentId=${comment.id}`, {});
+}
+
+export function getReviewers(itemId: string, language: string) {
+  return get<Reviewer[]>(`/alpaca/editor/reviews/reviewers?itemId=${itemId}&language=${language}`);
+}
+
+export function getReviews(itemId: string, language: string, version: number) {
+  return get<Review[]>(`/alpaca/editor/reviews/index?itemId=${itemId}&language=${language}&version=${version}`);
+}
+
+export function inviteReviewer(review: Review) {  
+  return post(`/alpaca/editor/reviews/invite`, review);
+}
+
+export function addReview(review:Review) {
+  return post(`/alpaca/editor/reviews/add`, review);
+}
+
+export function approveReview(itemDescriptor: ItemDescriptor) {
+  return post(`/alpaca/editor/reviews/approve`, itemDescriptor);
+}
+
+export function rejectReview(itemDescriptor: ItemDescriptor) {
+  return post(`/alpaca/editor/reviews/reject`, itemDescriptor);
+}
+

package/src/editor/services/serviceHelper.ts

@@ -0,0 +1,95 @@
+export type ExecutionResult<T> = {
+  type: "success" | "error" | "unauthorized";
+  summary?: string;
+  details?: string;
+  response: Response;
+  data?: T;
+};
+
+export async function post<T>(
+  url: string,
+  body: any,
+  session?: string
+): Promise<ExecutionResult<T>> {
+  if (session) url += "?sessionId=" + session;
+
+  const response = await fetch(    
+    url,
+    {
+      method: "POST",
+      body: JSON.stringify(body),
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    }
+  );
+
+  return handleResponse<T>(response);
+}
+
+export async function get<T>(
+  url: string,
+  session?: string
+): Promise<ExecutionResult<T>> {
+  if (session) url += "?sessionId=" + session;
+  const response = await fetch(
+    url,
+    {
+      method: "GET",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    }
+  );
+
+  return handleResponse<T>(response);
+}
+
+async function handleResponse<T>(
+  response: Response,
+): Promise<ExecutionResult<T>> {
+  if (response.status === 400) {
+    const data = await response.json();
+    return {
+      type: "error",
+      summary: data.summary,
+      details: data.details,
+      response,
+    };
+  }
+
+  if (response.status === 500 || response.redirected) {
+    return {
+      type: "error",
+      summary: "Error",
+      details: await response.text(),
+      response,
+    };
+  }
+
+  if (response.status === 401) {
+    return {
+      type: "unauthorized",
+      summary: "Unauthorized",
+      details: "Not logged in anymore?",
+      response,
+    };
+  }
+  
+  if (response.status !== 200) {
+    return { type: "error", response, details: await response.text() };
+  }
+
+  if (!response.headers.get("content-type")?.includes("application/json")) {
+    return {
+      type: "success",
+      response,
+    };
+  }
+
+  const data = (await response.json()) as T;
+
+  return { type: "success", response, data };
+}

package/src/editor/services/systemService.ts

@@ -0,0 +1,5 @@
+import { get } from "./serviceHelper";
+import { SystemStatus } from "../../types";
+export function getSystemStatus() {
+  return get<SystemStatus>("/alpaca/editor/status");
+}

package/src/editor/services/translationService.ts

@@ -0,0 +1,21 @@
+import { TranslationStatus } from "../../config/types";
+import { LanguagesAndVersions } from "../../types";
+import { get, post } from "./serviceHelper";
+
+export async function requestTranslation({itemId, targetLanguage, sourceLanguage, sessionId, provider}: {itemId: string, targetLanguage: string, sourceLanguage: string, sessionId: string, provider: string} ) {
+  return await post<LanguagesAndVersions>(
+    "/alpaca/editor/translation/requestTranslation",
+    { itemId, targetLanguage, sourceLanguage, sessionId, provider  }
+  );
+}
+
+
+export async function getTranslationStatus(itemId: string) {
+  return await get<TranslationStatus[]>(
+    `/alpaca/editor/translation/getTranslations?itemId=${itemId}`
+  );
+}
+
+export async function getTranslationProviders() {
+  return await get<string[]>(`/alpaca/editor/translation/providers`);
+}