ptechcore_ui 1.0.24 → 1.0.27

package/dist/index.js

@@ -712,7 +712,7 @@ import { createContext as createContext2, useContext as useContext2, useEffect a
 
 // src/services/api.ts
 var chooseEnv = localStorage.getItem("env") ?? "prod";
-var ADDRESS_IP = chooseEnv === "prod" ? "back.rewise.praeduim-tech.com" : "localhost:8000";
+var ADDRESS_IP = chooseEnv === "prod" ? "core.backend-rewise.praedium-tech.com" : "localhost:8000";
 var ADDRESS_IP_URL = chooseEnv === "prod" ? `https://${ADDRESS_IP}/` : `http://${ADDRESS_IP}/`;
 var API_URL = `${ADDRESS_IP_URL}api`;
 var FetchApi = class {
@@ -942,6 +942,7 @@ var SessionProvider = ({ children }) => {
     activeBusinessEntity,
     setActiveBusinessEntity,
     token,
+    setToken,
     login,
     logout,
     showAuthModal,
@@ -974,9 +975,8 @@ var UserServices = {
   deleteUser: (id, token) => FetchApi.delete(`${USERS_API_URL}${id}/`, token),
   // Obtenir les utilisateurs d'une entité
   getEntityUsers: (entityId, token) => FetchApi.get(`${API_URL}/core/entities/${entityId}/users/`, token),
-  // Obtenir les utilisateurs d'une entité
-  getuserEntitiesAccess: (id, token) => FetchApi.get(`${API_URL}/core/entities/`, token),
-  // !!! ce n'est pas la bonne url
+  // Obtenir les entités auxquelles un utilisateur a accès
+  getuserEntitiesAccess: (id, token) => FetchApi.get(`${API_URL}/core/users/${id}/entities/`, token),
   // Ajouter un utilisateur à une entité
   addUserToEntity: (entityId, userId, token) => FetchApi.post(`${API_URL}/core/entities/${entityId}/users/`, { user_id: userId }, token),
   // === Nouvelles méthodes pour le profil utilisateur ===
@@ -1843,7 +1843,7 @@ var RewiseLayout = ({ children, module_name = "Rewise", module_description = "De
         "organizations": "organizations",
         "entities": "entities"
       };
-      setSelectedModule(routeMapping[moduleId] || "dashboard");
+      setSelectedModule(routeMapping[moduleId] || moduleId);
     }
   }, [location]);
   const handleThemeChange = (type) => {
@@ -7721,6 +7721,495 @@ var FileManagerContent = ({ className }) => {
 var FileManager = (props) => {
   return /* @__PURE__ */ jsx28(FileManagerProvider, { ...props, children: /* @__PURE__ */ jsx28(FileManagerContent, { className: props.className }) });
 };
+
+// src/components/common/FileManager/components/EntityFileManager.tsx
+import React19 from "react";
+import { Loader2 as Loader22, FolderX, AlertCircle as AlertCircle4, RefreshCw as RefreshCw3 } from "lucide-react";
+
+// src/components/common/FileManager/hooks/useFileManagerApi.ts
+import { useState as useState19, useEffect as useEffect13, useCallback as useCallback4 } from "react";
+
+// src/components/common/FileManager/services/fileManagerApi.ts
+var API_BASE = "/api/files_manager";
+var ENTITY_MODEL_MAP = {
+  CLIENT: "accounting.Client",
+  VENDOR: "accounting.Vendor",
+  RFQ: "procurement.RFQ",
+  DEPT: "core.Departments",
+  PROJECT: "core.Project"
+};
+async function apiRequest(endpoint, options = {}) {
+  const url = `${API_BASE}${endpoint}`;
+  const headers = {
+    ...options.headers
+  };
+  if (!(options.body instanceof FormData)) {
+    headers["Content-Type"] = "application/json";
+  }
+  const csrfToken = getCsrfToken();
+  if (csrfToken) {
+    headers["X-CSRFToken"] = csrfToken;
+  }
+  const response = await fetch(url, {
+    ...options,
+    headers,
+    credentials: "include"
+    // Inclure les cookies pour l'auth
+  });
+  if (!response.ok) {
+    let errorMessage = `Erreur HTTP ${response.status}`;
+    try {
+      const errorData = await response.json();
+      errorMessage = errorData.detail || errorData.message || errorMessage;
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  if (response.status === 204) {
+    return {};
+  }
+  return response.json();
+}
+function getCsrfToken() {
+  const name = "csrftoken";
+  const cookies = document.cookie.split(";");
+  for (const cookie of cookies) {
+    const trimmed = cookie.trim();
+    if (trimmed.startsWith(`${name}=`)) {
+      return trimmed.substring(name.length + 1);
+    }
+  }
+  return null;
+}
+function buildQueryString(params) {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  }
+  const queryString = searchParams.toString();
+  return queryString ? `?${queryString}` : "";
+}
+async function getEntityFolders(entityType, entityId, folderType) {
+  const model = ENTITY_MODEL_MAP[entityType];
+  if (!model) {
+    throw new Error(`Type d'entit\xE9 non support\xE9: ${entityType}`);
+  }
+  const params = buildQueryString({
+    model,
+    id: entityId,
+    type: folderType
+  });
+  return apiRequest(`/folders/for_entity/${params}`);
+}
+async function getFolderTree(folderCode) {
+  return apiRequest(`/folders/${folderCode}/tree/`);
+}
+async function getFolder(folderCode) {
+  return apiRequest(`/folders/${folderCode}/`);
+}
+async function createFolder(name, parentCode, businessEntityId) {
+  return apiRequest("/folders/", {
+    method: "POST",
+    body: JSON.stringify({
+      name,
+      parent: parentCode,
+      business_entity: businessEntityId,
+      folder_type: "MISC",
+      // Type par défaut pour les dossiers créés manuellement
+      is_system_folder: false
+    })
+  });
+}
+async function renameFolder(folderCode, newName) {
+  return apiRequest(`/folders/${folderCode}/`, {
+    method: "PATCH",
+    body: JSON.stringify({ name: newName })
+  });
+}
+async function deleteFolder(folderCode) {
+  await apiRequest(`/folders/${folderCode}/`, {
+    method: "DELETE"
+  });
+}
+async function getFolderFiles(folderId) {
+  const params = buildQueryString({ folder: folderId });
+  return apiRequest(`/files/${params}`);
+}
+async function uploadFile(file, folderCode, options = {}) {
+  const formData = new FormData();
+  formData.append("file", file);
+  formData.append("folder_id", folderCode);
+  if (options.name) {
+    formData.append("name", options.name);
+  }
+  if (options.description) {
+    formData.append("description", options.description);
+  }
+  if (options.tags && options.tags.length > 0) {
+    formData.append("tags", JSON.stringify(options.tags));
+  }
+  return apiRequest("/files/", {
+    method: "POST",
+    body: formData
+  });
+}
+async function uploadFiles(files, folderCode) {
+  const results = [];
+  for (const file of files) {
+    const uploaded = await uploadFile(file, folderCode);
+    results.push(uploaded);
+  }
+  return results;
+}
+async function renameFile(fileCode, newName) {
+  return apiRequest(`/files/${fileCode}/`, {
+    method: "PATCH",
+    body: JSON.stringify({ name: newName })
+  });
+}
+async function deleteFile(fileCode) {
+  await apiRequest(`/files/${fileCode}/`, {
+    method: "DELETE"
+  });
+}
+function getDownloadUrl(fileCode) {
+  return `${API_BASE}/files/${fileCode}/download/`;
+}
+function getFileUrl(fileUrl) {
+  if (fileUrl.startsWith("http://") || fileUrl.startsWith("https://")) {
+    return fileUrl;
+  }
+  return fileUrl.startsWith("/") ? fileUrl : `/${fileUrl}`;
+}
+var fileManagerApi = {
+  // Dossiers
+  getEntityFolders,
+  getFolderTree,
+  getFolder,
+  createFolder,
+  renameFolder,
+  deleteFolder,
+  // Fichiers
+  getFolderFiles,
+  uploadFile,
+  uploadFiles,
+  renameFile,
+  deleteFile,
+  // URLs
+  getDownloadUrl,
+  getFileUrl,
+  // Helpers exposés
+  ENTITY_MODEL_MAP
+};
+
+// src/components/common/FileManager/hooks/useFileManagerApi.ts
+function transformFile(backendFile, parentPath, parentId) {
+  return {
+    id: backendFile.code,
+    name: backendFile.name,
+    type: "file",
+    mimeType: backendFile.mime_type,
+    size: backendFile.size,
+    path: `${parentPath}/${backendFile.name}`,
+    parentId,
+    url: fileManagerApi.getFileUrl(backendFile.file_url),
+    createdAt: backendFile.created_at,
+    updatedAt: backendFile.updated_at,
+    metadata: {
+      extension: backendFile.extension,
+      folderId: backendFile.folder
+    }
+  };
+}
+function transformFolder(backendFolder, parentPath = "", parentId = null) {
+  const currentPath = parentPath ? `${parentPath}/${backendFolder.name}` : `/${backendFolder.name}`;
+  const childFolders = (backendFolder.children || []).map(
+    (child) => transformFolder(child, currentPath, backendFolder.code)
+  );
+  const childFiles = (backendFolder.files || []).map(
+    (file) => transformFile(file, currentPath, backendFolder.code)
+  );
+  return {
+    id: backendFolder.code,
+    name: backendFolder.name,
+    type: "folder",
+    path: currentPath,
+    parentId,
+    children: [...childFolders, ...childFiles],
+    metadata: {
+      folderType: backendFolder.folder_type,
+      folderTypeDisplay: backendFolder.folder_type_display,
+      categoryType: backendFolder.category_type,
+      isSystemFolder: backendFolder.is_system_folder,
+      fileCount: backendFolder.file_count,
+      totalSize: backendFolder.total_size
+    }
+  };
+}
+function extractRootChildren(entityFolder) {
+  return entityFolder.children || [];
+}
+function useFileManagerApi(entityType, entityId, businessEntityId) {
+  const [data, setData] = useState19([]);
+  const [loading, setLoading] = useState19(true);
+  const [error, setError] = useState19(null);
+  const [rootFolderCode, setRootFolderCode] = useState19(null);
+  const loadEntityFolders = useCallback4(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const folders = await fileManagerApi.getEntityFolders(entityType, entityId);
+      if (!folders || folders.length === 0) {
+        setData([]);
+        setRootFolderCode(null);
+        setLoading(false);
+        return;
+      }
+      const entityFolder = folders.find((f) => f.folder_type === "ENTITY");
+      if (!entityFolder) {
+        console.warn("Dossier ENTITY non trouv\xE9, utilisation du premier dossier");
+        const firstFolder = folders[0];
+        setRootFolderCode(firstFolder.code);
+        const tree = await fileManagerApi.getFolderTree(firstFolder.code);
+        const transformed = transformFolder(tree);
+        setData(extractRootChildren(transformed));
+      } else {
+        setRootFolderCode(entityFolder.code);
+        const tree = await fileManagerApi.getFolderTree(entityFolder.code);
+        const transformed = transformFolder(tree);
+        setData(extractRootChildren(transformed));
+      }
+    } catch (err) {
+      console.error("Erreur lors du chargement des dossiers:", err);
+      setError(err instanceof Error ? err : new Error(String(err)));
+      setData([]);
+    } finally {
+      setLoading(false);
+    }
+  }, [entityType, entityId]);
+  const refresh = useCallback4(async () => {
+    await loadEntityFolders();
+  }, [loadEntityFolders]);
+  useEffect13(() => {
+    loadEntityFolders();
+  }, [loadEntityFolders]);
+  const handleCreateFolder = useCallback4(
+    async (name, parentId) => {
+      try {
+        const created = await fileManagerApi.createFolder(
+          name,
+          parentId,
+          businessEntityId
+        );
+        await refresh();
+        return transformFolder(created, "", parentId);
+      } catch (err) {
+        console.error("Erreur lors de la cr\xE9ation du dossier:", err);
+        setError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      }
+    },
+    [businessEntityId, refresh]
+  );
+  const handleUploadFiles = useCallback4(
+    async (files, parentId) => {
+      try {
+        const uploaded = await fileManagerApi.uploadFiles(files, parentId);
+        await refresh();
+        return uploaded.map((file) => transformFile(file, "", parentId));
+      } catch (err) {
+        console.error("Erreur lors de l'upload:", err);
+        setError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      }
+    },
+    [refresh]
+  );
+  const handleRename = useCallback4(
+    async (item, newName) => {
+      try {
+        if (item.type === "folder") {
+          await fileManagerApi.renameFolder(item.id, newName);
+        } else {
+          await fileManagerApi.renameFile(item.id, newName);
+        }
+        await refresh();
+      } catch (err) {
+        console.error("Erreur lors du renommage:", err);
+        setError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      }
+    },
+    [refresh]
+  );
+  const handleDelete = useCallback4(
+    async (item) => {
+      try {
+        if (item.metadata?.isSystemFolder) {
+          throw new Error("Les dossiers syst\xE8me ne peuvent pas \xEAtre supprim\xE9s");
+        }
+        if (item.type === "folder") {
+          await fileManagerApi.deleteFolder(item.id);
+        } else {
+          await fileManagerApi.deleteFile(item.id);
+        }
+        await refresh();
+      } catch (err) {
+        console.error("Erreur lors de la suppression:", err);
+        setError(err instanceof Error ? err : new Error(String(err)));
+        throw err;
+      }
+    },
+    [refresh]
+  );
+  const handleDownload = useCallback4((item) => {
+    if (item.type === "file") {
+      const url = item.url || fileManagerApi.getDownloadUrl(item.id);
+      window.open(url, "_blank");
+    }
+  }, []);
+  return {
+    data,
+    loading,
+    error,
+    rootFolderCode,
+    refresh,
+    handlers: {
+      onCreateFolder: handleCreateFolder,
+      onUploadFiles: handleUploadFiles,
+      onRename: handleRename,
+      onDelete: handleDelete,
+      onDownload: handleDownload
+    }
+  };
+}
+
+// src/components/common/FileManager/components/EntityFileManager.tsx
+import { jsx as jsx29, jsxs as jsxs24 } from "react/jsx-runtime";
+function getRootName(entityType) {
+  const names = {
+    CLIENT: "Documents Client",
+    VENDOR: "Documents Fournisseur",
+    RFQ: "Documents RFQ",
+    DEPT: "Documents D\xE9partement",
+    PROJECT: "Documents Projet"
+  };
+  return names[entityType] || "Documents";
+}
+var LoadingState = ({ height = "400px" }) => /* @__PURE__ */ jsxs24(
+  "div",
+  {
+    className: "flex flex-col items-center justify-center bg-gray-50 dark:bg-gray-900 rounded-xl border border-gray-200 dark:border-gray-800",
+    style: { height },
+    children: [
+      /* @__PURE__ */ jsx29(Loader22, { className: "w-10 h-10 text-blue-500 animate-spin mb-4" }),
+      /* @__PURE__ */ jsx29("p", { className: "text-gray-600 dark:text-gray-400 text-sm", children: "Chargement des documents..." })
+    ]
+  }
+);
+var ErrorState = ({ error, onRetry, height = "400px" }) => /* @__PURE__ */ jsxs24(
+  "div",
+  {
+    className: "flex flex-col items-center justify-center bg-red-50 dark:bg-red-900/20 rounded-xl border border-red-200 dark:border-red-800",
+    style: { height },
+    children: [
+      /* @__PURE__ */ jsx29(AlertCircle4, { className: "w-10 h-10 text-red-500 mb-4" }),
+      /* @__PURE__ */ jsx29("p", { className: "text-red-600 dark:text-red-400 text-sm font-medium mb-2", children: "Erreur lors du chargement" }),
+      /* @__PURE__ */ jsx29("p", { className: "text-red-500 dark:text-red-400 text-xs mb-4 max-w-md text-center px-4", children: error.message }),
+      /* @__PURE__ */ jsxs24(
+        "button",
+        {
+          onClick: onRetry,
+          className: "flex items-center gap-2 px-4 py-2 bg-red-100 dark:bg-red-900/40 text-red-700 dark:text-red-300 rounded-lg hover:bg-red-200 dark:hover:bg-red-900/60 transition-colors text-sm",
+          children: [
+            /* @__PURE__ */ jsx29(RefreshCw3, { className: "w-4 h-4" }),
+            "R\xE9essayer"
+          ]
+        }
+      )
+    ]
+  }
+);
+var EmptyState = ({ height = "400px" }) => /* @__PURE__ */ jsxs24(
+  "div",
+  {
+    className: "flex flex-col items-center justify-center bg-gray-50 dark:bg-gray-900 rounded-xl border border-gray-200 dark:border-gray-800",
+    style: { height },
+    children: [
+      /* @__PURE__ */ jsx29(FolderX, { className: "w-10 h-10 text-gray-400 mb-4" }),
+      /* @__PURE__ */ jsx29("p", { className: "text-gray-600 dark:text-gray-400 text-sm font-medium mb-1", children: "Aucun document trouv\xE9" }),
+      /* @__PURE__ */ jsx29("p", { className: "text-gray-500 dark:text-gray-500 text-xs", children: "La structure de dossiers n'a pas encore \xE9t\xE9 cr\xE9\xE9e pour cette entit\xE9." })
+    ]
+  }
+);
+var EntityFileManager = ({
+  entityType,
+  entityId,
+  businessEntityId,
+  className,
+  height = "600px",
+  // Permissions (défaut: tout autorisé)
+  allowUpload = true,
+  allowCreateFolder = true,
+  allowRename = true,
+  allowDelete = true,
+  allowDownload = true,
+  // Callbacks
+  onFileSelect,
+  onFileOpen,
+  onUploadSuccess,
+  onError
+}) => {
+  const { data, loading, error, refresh, handlers } = useFileManagerApi(
+    entityType,
+    entityId,
+    businessEntityId
+  );
+  React19.useEffect(() => {
+    if (error && onError) {
+      onError(error);
+    }
+  }, [error, onError]);
+  if (loading) {
+    return /* @__PURE__ */ jsx29(LoadingState, { height });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx29(ErrorState, { error, onRetry: refresh, height });
+  }
+  if (!data || data.length === 0) {
+    return /* @__PURE__ */ jsx29(EmptyState, { height });
+  }
+  const handleUploadFiles = async (files, parentId) => {
+    const result = await handlers.onUploadFiles(files, parentId);
+    if (result && onUploadSuccess) {
+      onUploadSuccess(result);
+    }
+    return result;
+  };
+  return /* @__PURE__ */ jsx29("div", { className: cn("relative", className), style: { height }, children: /* @__PURE__ */ jsx29(
+    FileManager,
+    {
+      data,
+      rootName: getRootName(entityType),
+      onCreateFolder: handlers.onCreateFolder,
+      onUploadFiles: handleUploadFiles,
+      onRename: handlers.onRename,
+      onDelete: handlers.onDelete,
+      onDownload: handlers.onDownload,
+      onSelect: onFileSelect,
+      onOpen: onFileOpen,
+      allowUpload,
+      allowCreateFolder,
+      allowRename,
+      allowDelete,
+      allowDownload,
+      allowMultiSelect: true,
+      className: "h-full"
+    }
+  ) });
+};
 export {
   Alert_default as Alert,
   AlertProvider,
@@ -7733,6 +8222,7 @@ export {
   Choices_default as CHOICES,
   CountrySelector,
   DateInput,
+  EntityFileManager,
   FDrawer,
   FetchApi,
   FileInput,
@@ -7762,11 +8252,13 @@ export {
   Toast_default as ToastContainer,
   ToastProvider,
   UserServices,
+  fileManagerApi,
   formatDate,
   formatFileSize,
   getFileIcon,
   useAlert,
   useFileManager,
+  useFileManagerApi,
   useSession,
   useToast
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ptechcore_ui",
-  "version": "1.0.24",
+  "version": "1.0.27",
   "type": "module",
   "main": "./dist/index.cjs",       
   "module": "./dist/index.js",      
@@ -18,6 +18,8 @@
   "scripts": {
     "dev": "vite",
     "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build:app": "vite build",
+    "build:lib": "tsup src/index.ts --format cjs,esm --dts",
     "lint": "eslint .",
     "preview": "vite preview"
   },