@pristy/pristy-libvue 0.2.3

package/src/WorkspaceService.js

@@ -0,0 +1,338 @@
+/**
+ *  Copyright (C) 2022 - Jeci SARL - https://jeci.fr
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as
+ *  published by the Free Software Foundation, either version 3 of the
+ *  License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see https://www.gnu.org/licenses/agpl-3.0.html.
+ */
+
+import {
+  sitesApi,
+  peopleApi,
+  searchApi,
+  nodesApi,
+} from "./AlfrescoApi";
+
+export default class WorkspaceService {
+
+  getWorkspaces() {
+    const opts = {
+      skipCount: 0,
+      maxItems: 100,
+    };
+
+    return sitesApi()
+      .listSites(opts)
+      .then((data) => {
+        return data.list.entries.map((data) => data.entry);
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+
+  searchAllWorkspaces(extraQuery = "") {
+    const query = {
+      query: {
+        //language: "afts",
+        query: "TYPE: 'st:site' " + extraQuery,
+      },
+      include: ["properties"],
+      paging: {
+        maxItems: 100,
+        skipCount: 0,
+      },
+      localization: { locales: ["fr_FR"] },
+    };
+
+    return searchApi()
+      .search(query)
+      .then((data) => {
+        return data.list.entries.map((data) => {
+          let obj = data.entry;
+          // add some basic properties to match sitesApi.listSites output
+          obj.title = data.entry.properties["cm:title"];
+          obj.visibility = data.entry.properties["st:siteVisibility"];
+          obj.typeEspace = data.entry.properties["pm:typeEspace"];
+          return obj;
+        });
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+
+  getWorkspace(id) {
+    const opts = {};
+
+    return sitesApi()
+      .getSite(id, opts)
+      .then((data) => {
+        return data.entry;
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+
+  getWorkspaceMemberships(id) {
+    const opts = {};
+
+    return sitesApi()
+      .listSiteMemberships(id, opts)
+      .then((data) => {
+        return data.list.entries.map((data) => data.entry);
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+
+  createWorkspace(id, title, descr, visibility) {
+    const opts = {
+      id: id,
+      title: title,
+      description: descr,
+      visibility: visibility,
+    };
+
+    return sitesApi()
+      .createSite(opts)
+      .then((siteMemberEntry) => {
+        return siteMemberEntry;
+      })
+      .catch((err) => {
+        let message;
+        switch (err.status) {
+          case 400:
+            message = "L'identifiant choisi ne respecte pas le format requis.";
+            break;
+          case 409:
+            message = "L'identifiant choisi est déjà existant.";
+            break;
+          default:
+            message = err.message;
+        }
+        throw new Error(message);
+      });
+  }
+
+  async getWorskpaceUuid(id) {
+    const opts = {
+      skipCount: 0,
+      maxItems: 100,
+    };
+    var uuid = null;
+    const list = (await sitesApi.listSiteContainers(id, opts)).list.entries;
+    for (let element in list) {
+      if (list[element].entry.folderId == "documentLibrary") {
+        uuid = list[element].entry.id;
+      }
+    }
+    return uuid;
+  }
+
+  updateWorkspaceMemberRole(siteId, memberId, newRole) {
+    const siteMembershipBody = {
+      role: newRole,
+    };
+    const opts = {};
+
+    return sitesApi()
+      .updateSiteMembership(siteId, memberId, siteMembershipBody, opts)
+      .then((siteMemberShip) => {
+        return siteMemberShip;
+      })
+      .catch((err) => {
+        let message;
+        switch (err.status) {
+          case 404:
+            message = "L'identifiant entré ne correspond à aucun utilisateur.";
+            break;
+          case 422:
+            message =
+              "Au moins un utilisateur doit être Gestionnaire. Si ce n'est pas le cas, vous n'avez pas la permission de modifier le rôle de cet utilisateur.";
+            break;
+          default:
+            message = err.message;
+        }
+        throw new Error(message);
+      });
+  }
+
+  deleteWorkspaceMember(siteId, memberId) {
+    const opts = {};
+
+    return sitesApi()
+      .deleteSiteMembership(siteId, memberId, opts)
+      .then(() => {
+        return memberId;
+      })
+      .catch((err) => {
+        let message;
+        switch (err.status) {
+          case 400:
+            message =
+              "Impossible de supprimer le seul Gestionnaire de l'espace.";
+            break;
+          case 404:
+            message = "Vous ne pouvez pas supprimer un utilisateur inexistant.";
+            break;
+          case 422:
+            message =
+              "Vous n'avez pas la permission de supprimer l'accès à cet utilisateur.";
+            break;
+          default:
+            message = err.message;
+        }
+        throw new Error(message);
+      });
+  }
+
+  addWorkspaceMember(siteId, memberId, role) {
+    const memberShipBody = {
+      role: role,
+      id: memberId,
+    };
+    const opts = {};
+
+    return sitesApi()
+      .createSiteMembership(siteId, memberShipBody, opts)
+      .then((siteMemberShip) => {
+        return siteMemberShip;
+      })
+      .catch((err) => {
+        let message;
+        switch (err.status) {
+          case 403:
+            message = "Vous ne pouvez pas inviter sur ce site.";
+            break;
+          case 404:
+            message = "Vous ne pouvez pas ajouter un utilisateur inexistant.";
+            break;
+          case 409:
+            message = "L'utilisateur a déjà accès à cet espace.";
+            break;
+          default:
+            message = err.message;
+        }
+        throw new Error(message);
+      });
+  }
+
+  updateWorkspaceType(id, typeEspace) {
+    const opts = {
+      properties: {
+        "pm:typeEspace": typeEspace,
+      },
+    };
+
+    return nodesApi()
+      .updateNode(id, opts)
+      .then((data) => {
+        return data;
+      })
+      .catch((err) => {
+        let message;
+        switch (err.status) {
+          case 404:
+            message = "Vous ne pouvez pas mettre à jour un espace inexistant.";
+            break;
+          default:
+            message = err.message;
+        }
+        throw new Error(message);
+      });
+  }
+
+  async getAllUsers() {
+    let userObj = "[";
+    let response = await peopleApi().listPeople();
+    let usersObject = response.list.entries;
+    usersObject.forEach((item) => {
+      let firstname = item.entry.firstName;
+      let lastname = item.entry.lastName;
+      let email = item.entry.email;
+      if (email == null) {
+        email = "";
+      }
+      if (firstname == null) {
+        if (email == null) {
+          firstname = "";
+        }
+        firstname = email;
+      }
+      if (lastname == null) {
+        if (email == null) {
+          lastname = "";
+        }
+        lastname = email;
+      }
+      let user =
+        '{ "firstname":' +
+        '"' +
+        firstname +
+        '"' +
+        ', "lastname":' +
+        '"' +
+        lastname +
+        '"' +
+        ', "email":' +
+        '"' +
+        email +
+        '"' +
+        ', "id":' +
+        '"' +
+        item.entry.id +
+        '"' +
+        ', "label":"' +
+        firstname +
+        " " +
+        lastname +
+        '"' +
+        ', "label2":"' +
+        lastname +
+        " " +
+        firstname +
+        '"},';
+      userObj += user;
+    });
+    userObj = userObj.slice(0, -1);
+    userObj += "]";
+    let users = JSON.parse(userObj);
+    return users;
+  }
+
+  deleteWorkspace(siteId) {
+    const opts = {};
+
+    return sitesApi()
+      .deleteSite(siteId, opts)
+      .then(() => {
+        console.log("Site deletion successful.");
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+
+  updateWorkspace(id, opts) {
+    return sitesApi()
+      .updateSite(id, opts)
+      .then((data) => {
+        return data;
+      })
+      .catch((err) => {
+        throw new Error(err.message);
+      });
+  }
+}

package/src/index.js

@@ -0,0 +1,30 @@
+import AlfrescoFileService from "./AlfrescoFileService";
+import AlfrescoNodeService from "./AlfrescoNodeService";
+import AlfrescoPermissionService from "./AlfrescoPermissionService";
+import ErrorService from "./ErrorService";
+import WorkspaceService from "./WorkspaceService"
+import { alfrescoApi, uploadApi, renditionsApi, nodesApi, sitesApi, searchApi, peopleApi, favoritesApi, trashcanApi } from "./AlfrescoApi";
+import { useUserStore } from "./stores/user";
+
+export {
+  AlfrescoFileService,
+  AlfrescoNodeService,
+  AlfrescoPermissionService,
+  ErrorService,
+  uploadApi,
+  renditionsApi,
+  nodesApi,
+  sitesApi,
+  searchApi,
+  peopleApi,
+  alfrescoApi,
+  favoritesApi,
+  trashcanApi,
+  useUserStore,
+  WorkspaceService
+}
+
+export default class Index {
+  constructor() {
+  }
+}

package/src/stores/user.js

@@ -0,0 +1,169 @@
+/**
+ *  Copyright (C) 2022 - Jeci SARL - https://jeci.fr
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Affero General Public License as
+ *  published by the Free Software Foundation, either version 3 of the
+ *  License, or (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Affero General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Affero General Public License
+ *  along with this program.  If not, see https://www.gnu.org/licenses/agpl-3.0.html.
+ */
+
+// @ts-check
+import { defineStore, acceptHMRUpdate } from "pinia";
+import { alfrescoApi, peopleApi } from "../AlfrescoApi";
+import { loginError } from "../ErrorService";
+
+export const useUserStore = defineStore({
+  id: "user",
+  state: () => ({
+    displayName: "",
+    token: "",
+    isAdmin: false,
+    person: null,
+    apiAlfresco: null,
+  }),
+  getters: {
+    displayName(state) {
+      return state.person == null ? "" : state.person.displayName;
+    },
+  },
+  actions: {
+    logout() {
+      console.log("logout with " + this.email);
+
+      if (this.apiAlfresco) {
+        this.apiAlfresco.logout();
+      }
+
+      this.$patch({
+        token: "",
+        isAdmin: false,
+        person: null,
+        apiAlfresco: null,
+      });
+    },
+
+    isLoggedIn() {
+
+    var alfresco;
+
+    if (!this.apiAlfresco) {
+      alfresco = alfrescoApi();
+    } else {
+      alfresco = this.apiAlfresco;
+    }
+
+    return peopleApi()
+      .getPerson("-me-")
+      .then((personEntry) => {
+        this.$patch({
+          person: personEntry.entry,
+          apiAlfresco: alfresco,
+        });
+        return true;
+      })
+      .catch((data) => {
+        return catchLogin(data);
+      });
+    },
+    /**
+     * Attempt to login a user
+     * @param {string} user
+     * @param {string} password
+     */
+    async login(user, password) {
+      if (!user || !password) {
+        return false;
+      }
+
+      await this.apiLogin(user, password)
+        .then((personEntry) => {
+          this.$patch({
+            person: personEntry.entry,
+          });
+        })
+        .catch((error) => {
+          loginError(error);
+        });
+    },
+    /**
+     * Simulate a login
+     * @param {string} a
+     * @param {string} p
+     */
+    apiLogin(a, p) {
+
+      return alfrescoApi()
+        .login(a, p)
+        .then(() => {
+          this.$patch({
+            apiAlfresco: alfrescoApi(),
+          });
+          return peopleApi().getPerson("-me-");
+        })
+        .catch((err) => {
+          return Promise.reject(err);
+        });
+    },
+    async publiclogoff() {
+      var userProfile = localStorage.getItem("ACS_USERNAME");
+      if (userProfile && userProfile.startsWith("user_publication_")) {
+        localStorage.removeItem("ticket-ECM");
+        localStorage.removeItem("ACS_USERNAME");
+      }
+    },
+    async publiclogin(espace_id) {
+      let ticketECM = window.localStorage.getItem("ticket-ECM");
+
+      if (typeof ticketECM !== "undefined" && ticketECM != null) {
+        // TODO check ticket validity
+      } else {
+        await fetch(
+            window.config["ALFRESCO_HOST"] +
+            "/alfresco/s/fr/jeci/pristy/authentication/ticket/publication/site/" +
+            espace_id,
+            {
+              method: "GET",
+              headers: {
+                "Content-Type": "application/json",
+                Accept: "application/json",
+              },
+            }
+        )
+            .then((response) => response.json())
+            .then((specs) => {
+              window.localStorage.setItem("ticket-ECM", specs.ticket);
+              window.localStorage.setItem("ACS_USERNAME", specs.login);
+            });
+      }
+    },
+    alfrescoApi() {
+      return this.apiAlfresco;
+    },
+  },
+});
+
+if (import.meta.hot) {
+  import.meta.hot.accept(acceptHMRUpdate(useUserStore, import.meta.hot));
+}
+
+/**
+ * Traitement de l'erreur de connexion
+ */
+function catchLogin(data) {
+  let error = JSON.parse(data.message).error;
+  if (error.statusCode == 401) {
+    return false;
+  }
+  if (error.statusCode == 403) {
+    return false;
+  }
+  throw new Error(data);
+}