@tunghtml/strapi-plugin-export-import-clsx 1.1.0 → 1.2.0

package/admin/src/components/ExportImportButtons/index.jsx

@@ -93,80 +93,6 @@ const ExportImportButtons = (props) => {
     return filters;
   };
 
-  // Get selected entries from props
-  const getSelectedEntries = () => {
-    // Try to get selected entries from various possible props
-    if (props.selectedEntries && props.selectedEntries.length > 0) {
-      return props.selectedEntries;
-    }
-    if (props.selected && props.selected.length > 0) {
-      return props.selected;
-    }
-    if (props.selection && props.selection.length > 0) {
-      return props.selection;
-    }
-    const selectedIds = [];
-    let field = "";
-    const getHeaderKey = (i) => {
-      const el = document.querySelector(
-        `thead th:nth-child(${i}) button, thead th:nth-child(${i}) span`
-      );
-      if (!el) return "";
-      const parts = el.textContent.trim().split(/\s+/);
-      return parts.pop(); // last word
-    };
-
-    try {
-      const rows = document.querySelectorAll("tbody tr");
-      const allowedFields = [
-        "id",
-        "name",
-        "title",
-        "tickerCode",
-        "fullName",
-        "email",
-        "businessEmail",
-        "telephone",
-        "mobile",
-      ];
-
-      let foundIndex = null;
-
-      for (let i = 1; i <= 10; i++) {
-        const headerBtn = getHeaderKey(i);
-        if (headerBtn !== "" && allowedFields.includes(headerBtn)) {
-          field = headerBtn;
-          foundIndex = i;
-          break;
-        }
-      }
-
-      if (!foundIndex) {
-        console.warn("No valid header column found");
-        return [[], ""];
-      }
-
-      // gather values for selected rows
-      rows.forEach((row) => {
-        const checkbox = row.querySelector(
-          'td:nth-child(1) button[role="checkbox"]'
-        );
-        if (checkbox?.getAttribute("aria-checked") === "true") {
-          const cellSpan = row.querySelector(
-            `td:nth-child(${foundIndex}) span`
-          );
-          const text = cellSpan?.textContent.trim();
-          if (text) selectedIds.push(text);
-        }
-      });
-
-      return [selectedIds, field];
-    } catch (e) {
-      console.error(e);
-      return [[], ""];
-    }
-  };
-
   const handleExport = async () => {
     const contentType = getContentType();
     if (!contentType) {
@@ -180,8 +106,7 @@ const ExportImportButtons = (props) => {
     setIsExporting(true);
     try {
       const filters = getCurrentFilters();
-      const eventFilter = getEventFilter(); // Back to sync
-      const [selectedEntries, selectedField] = getSelectedEntries();
+      const eventFilter = getEventFilter();
 
       const queryParams = new URLSearchParams({
         format: "excel",
@@ -197,12 +122,6 @@ const ExportImportButtons = (props) => {
         );
       }
 
-      // Add selected IDs if any
-      if (selectedEntries.length > 0) {
-        queryParams.set("selectedIds", JSON.stringify(selectedEntries));
-        queryParams.set("selectedField", selectedField);
-      }
-
       const response = await fetch(`/export-import-clsx/export?${queryParams}`);
 
       if (response.ok) {
@@ -211,11 +130,9 @@ const ExportImportButtons = (props) => {
         const a = document.createElement("a");
         a.href = url;
 
-        // Set filename based on selection
-        const filename =
-          selectedEntries.length > 0
-            ? `${contentType.replace("api::", "")}-selected-${selectedEntries.length}-${new Date().toISOString().split("T")[0]}.xlsx`
-            : `${contentType.replace("api::", "")}-export-${new Date().toISOString().split("T")[0]}.xlsx`;
+        const filename = `${contentType.replace("api::", "")}-export-${
+          new Date().toISOString().split("T")[0]
+        }.xlsx`;
 
         a.download = filename;
         document.body.appendChild(a);
@@ -225,10 +142,7 @@ const ExportImportButtons = (props) => {
 
         toggleNotification({
           type: "success",
-          message:
-            selectedEntries.length > 0
-              ? `Successfully exported ${selectedEntries.length} selected entries`
-              : "Successfully exported data",
+          message: "Successfully exported data",
         });
       } else {
         throw new Error("Export failed");
@@ -323,19 +237,12 @@ const ExportImportButtons = (props) => {
   // Create ref for file input
   const fileInputRef = useRef(null);
 
-  const [selectedEntries, selectedField] = getSelectedEntries();
-  const exportButtonText =
-    selectedEntries.length > 0
-      ? `Export (${selectedEntries.length})`
-      : "Export";
-
   return (
     <div
       style={{
         display: "flex",
         gap: "8px",
         alignItems: "center",
-        marginRight: "16px",
         order: -1,
       }}
     >
@@ -346,7 +253,7 @@ const ExportImportButtons = (props) => {
         variant="secondary"
         size="S"
       >
-        {exportButtonText}
+        Export
       </Button>
 
       <input

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tunghtml/strapi-plugin-export-import-clsx",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A powerful Strapi plugin for exporting and importing data with Excel support and advanced filtering",
   "main": "./strapi-server.js",
   "scripts": {

package/server/controllers/export-controller.js

@@ -1,62 +1,75 @@
 module.exports = ({ strapi }) => ({
   async export(ctx) {
     try {
-      const { format = 'excel', contentType, selectedIds, selectedField, ...filters } = ctx.query;
-      const exportService = strapi.plugin('export-import-clsx').service('export-service');
-      
-      // Parse selectedIds if provided
-      let parsedSelectedIds = [];
-      if (selectedIds) {
-        try {
-          parsedSelectedIds = Array.isArray(selectedIds) ? selectedIds : JSON.parse(selectedIds);
-        } catch (error) {
-          strapi.log.warn('Failed to parse selectedIds:', error.message);
-        }
-      }
-      
-      if (format === 'excel') {
-        const buffer = await exportService.exportData('excel', contentType, filters, parsedSelectedIds, selectedField);
-        
-        const filename = parsedSelectedIds.length > 0 
-          ? `${contentType?.replace('api::', '') || 'strapi'}-selected-${parsedSelectedIds.length}-${new Date().toISOString().split('T')[0]}.xlsx`
-          : `${contentType?.replace('api::', '') || 'strapi'}-export-${new Date().toISOString().split('T')[0]}.xlsx`;
-        
-        ctx.set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
-        ctx.set('Content-Disposition', `attachment; filename="${filename}"`);
-        
+      const { format = "excel", contentType, ...filters } = ctx.query;
+      const exportService = strapi
+        .plugin("export-import-clsx")
+        .service("export-service");
+
+      if (format === "excel") {
+        const buffer = await exportService.exportData(
+          "excel",
+          contentType,
+          filters
+        );
+
+        const filename = `${
+          contentType?.replace("api::", "") || "strapi"
+        }-export-${new Date().toISOString().split("T")[0]}.xlsx`;
+
+        ctx.set(
+          "Content-Type",
+          "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+        );
+        ctx.set("Content-Disposition", `attachment; filename="${filename}"`);
+
         ctx.body = buffer;
       } else {
-        const data = await exportService.exportData('json', contentType, filters, parsedSelectedIds);
-        
-        const filename = parsedSelectedIds.length > 0 
-          ? `${contentType?.replace('api::', '') || 'strapi'}-selected-${parsedSelectedIds.length}-${new Date().toISOString().split('T')[0]}.json`
-          : `${contentType?.replace('api::', '') || 'strapi'}-export-${new Date().toISOString().split('T')[0]}.json`;
-        
-        ctx.set('Content-Type', 'application/json');
-        ctx.set('Content-Disposition', `attachment; filename="${filename}"`);
-        
+        const data = await exportService.exportData(
+          "json",
+          contentType,
+          filters
+        );
+
+        const filename = `${
+          contentType?.replace("api::", "") || "strapi"
+        }-export-${new Date().toISOString().split("T")[0]}.json`;
+
+        ctx.set("Content-Type", "application/json");
+        ctx.set("Content-Disposition", `attachment; filename="${filename}"`);
+
         ctx.body = JSON.stringify(data, null, 2);
       }
     } catch (error) {
-      strapi.log.error('Export error:', error);
-      ctx.throw(500, 'Export failed');
+      strapi.log.error("Export error:", error);
+      ctx.throw(500, "Export failed");
     }
   },
 
   async exportSingle(ctx) {
     try {
       const { contentType, id } = ctx.params;
-      const exportService = strapi.plugin('export-import-clsx').service('export-service');
-      
+      const exportService = strapi
+        .plugin("export-import-clsx")
+        .service("export-service");
+
       const buffer = await exportService.exportSingleEntry(contentType, id);
-      
-      ctx.set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
-      ctx.set('Content-Disposition', `attachment; filename="entry-${id}-${new Date().toISOString().split('T')[0]}.xlsx"`);
-      
+
+      ctx.set(
+        "Content-Type",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+      );
+      ctx.set(
+        "Content-Disposition",
+        `attachment; filename="entry-${id}-${
+          new Date().toISOString().split("T")[0]
+        }.xlsx"`
+      );
+
       ctx.body = buffer;
     } catch (error) {
-      strapi.log.error('Export single error:', error);
-      ctx.throw(500, 'Export failed');
+      strapi.log.error("Export single error:", error);
+      ctx.throw(500, "Export failed");
     }
   },
-});
+});

package/server/services/export-service.js

@@ -1,13 +1,7 @@
 const XLSX = require("xlsx");
 
 module.exports = ({ strapi }) => ({
-  async exportData(
-    format = "json",
-    contentType = null,
-    rawFilters = {},
-    selectedIds = [],
-    selectedField = null
-  ) {
+  async exportData(format = "json", contentType = null, rawFilters = {}) {
     // Normalize content type - handle both content-manager and event-manager formats
     if (contentType && !contentType.startsWith("api::")) {
       // If it's already in api:: format from event-manager, use as is
@@ -52,87 +46,67 @@ module.exports = ({ strapi }) => ({
           `Exporting ${ct} with raw filters: ${JSON.stringify(rawFilters)}`
         );
         strapi.log.info(`Parsed filters: ${JSON.stringify(parsedFilters)}`);
-        strapi.log.info(`Selected IDs: ${JSON.stringify(selectedIds)}`);
 
         let entries = [];
         let filters = parsedFilters.filters;
 
-        // If specific IDs are selected, export only those
-        if (selectedIds && selectedIds.length > 0) {
+        // Export all entries with filters
+        const searchable = this.getSearchableFields(strapi.contentTypes[ct]);
+        const numberSearchable = this.getNumberFields(strapi.contentTypes[ct]);
+
+        if (parsedFilters._q) {
           strapi.log.info(
-            `Exporting selected: ${JSON.stringify(selectedIds)}, field: ${selectedField}`
-          );
-          if (
-            selectedField === "id" ||
-            (strapi.contentTypes[ct].attributes[selectedField] &&
-              ["number", "integer", "biginteger", "float", "decimal"].includes(
-                strapi.contentTypes[ct].attributes[selectedField].type
-              ))
-          ) {
-            selectedIds = selectedIds.map((id) => Number(id));
-          }
-          try {
-            entries = await strapi.documents(ct).findMany({
-              filters: {
-                [selectedField]: { $in: selectedIds },
-              },
-              populate: "*",
-            });
-          } catch (error) {
-            strapi.log.error(`Failed to export selected entries:`, error);
-          }
-        } else {
-          // Export all entries with filters
-          const searchable = this.getSearchableFields(strapi.contentTypes[ct]);
-          const numberSearchable = this.getNumberFields(
-            strapi.contentTypes[ct]
+            `Applying search query: ${
+              parsedFilters._q
+            } for fields: ${JSON.stringify([
+              ...searchable,
+              ...numberSearchable,
+            ])}`
           );
+          const orConditions = [];
 
-          if (parsedFilters._q) {
-            strapi.log.info(
-              `Applying search query: ${parsedFilters._q} for fields: ${JSON.stringify([...searchable, ...numberSearchable])}`
+          if (searchable.length > 0) {
+            orConditions.push(
+              ...searchable.map((field) => ({
+                [field]: { $containsi: parsedFilters._q },
+              }))
             );
-            const orConditions = [];
-
-            if (searchable.length > 0) {
-              orConditions.push(
-                ...searchable.map((field) => ({
-                  [field]: { $containsi: parsedFilters._q },
-                }))
-              );
-            }
-
-            if (numberSearchable.length > 0 && !isNaN(parsedFilters._q)) {
-              orConditions.push(
-                ...numberSearchable.map((field) => ({
-                  [field]: { $eq: Number(parsedFilters._q) },
-                }))
-              );
-            }
-
-            if (orConditions.length > 0) {
-              filters = {
-                ...filters,
-                $and: [...(filters?.$and || []), { $or: orConditions }],
-              };
-            }
           }
-          strapi.log.info(`Parsed query filters: ${JSON.stringify(filters)}`);
-          try {
-            entries = await strapi.documents(ct).findMany({
-              filters: { ...filters },
-              populate: "*",
-            });
-            strapi.log.info(
-              `EntityService found ${entries?.length || 0} entries`
+
+          if (numberSearchable.length > 0 && !isNaN(parsedFilters._q)) {
+            orConditions.push(
+              ...numberSearchable.map((field) => ({
+                [field]: { $eq: Number(parsedFilters._q) },
+              }))
             );
-          } catch (error) {
-            strapi.log.error(`Failed to query entries:`, error);
           }
+
+          if (orConditions.length > 0) {
+            filters = {
+              ...filters,
+              $and: [...(filters?.$and || []), { $or: orConditions }],
+            };
+          }
+        }
+
+        strapi.log.info(`Parsed query filters: ${JSON.stringify(filters)}`);
+
+        try {
+          entries = await strapi.documents(ct).findMany({
+            filters: { ...filters },
+            populate: "*",
+          });
+          strapi.log.info(
+            `EntityService found ${entries?.length || 0} entries`
+          );
+        } catch (error) {
+          strapi.log.error(`Failed to query entries:`, error);
         }
 
         strapi.log.info(
-          `Final result: ${entries?.length || 0} entries for ${ct} (total found: ${entries?.length || 0})`
+          `Final result: ${
+            entries?.length || 0
+          } entries for ${ct} (total found: ${entries?.length || 0})`
         );
 
         if (entries && entries.length > 0) {

package/strapi-admin.js

@@ -1,4 +1,3 @@
-import React from "react";
 import pluginPkg from "./package.json";
 import pluginId from "./admin/src/pluginId";
 import Initializer from "./admin/src/components/Initializer";
@@ -19,73 +18,12 @@ export default {
   },
 
   bootstrap(app) {
-    // Try different injection methods for Strapi v5
-    try {
-      // Method 1: Direct injection
-      if (app.injectContentManagerComponent) {
-        app.injectContentManagerComponent("listView", "actions", {
-          name: "export-import-buttons",
-          Component: ExportImportButtons,
-        });
-      }
-      // Method 2: Plugin-based injection
-      else if (app.getPlugin) {
-        const contentManager = app.getPlugin("content-manager");
-        if (contentManager && contentManager.injectComponent) {
-          contentManager.injectComponent("listView", "actions", {
-            name: "export-import-buttons",
-            Component: ExportImportButtons,
-          });
-        }
-      }
-      // Method 3: Global injection
-      else if (app.addComponent) {
-        app.addComponent(
-          "content-manager.listView.actions",
-          ExportImportButtons
-        );
-      }
-    } catch (error) {
-      console.warn("Failed to inject export-import buttons:", error);
-
-      // Fallback: Add as menu item if injection fails
-      app.addMenuLink({
-        to: `/plugins/${pluginId}`,
-        icon: () => React.createElement("span", null, "📊"),
-        intlLabel: {
-          id: `${pluginId}.plugin.name`,
-          defaultMessage: "Export Import",
-        },
-        Component: async () => {
-          const component = await import("./admin/src/pages/App");
-          return component;
-        },
-        permissions: [],
+    const contentManager = app.getPlugin("content-manager");
+    if (contentManager && contentManager.injectComponent) {
+      contentManager.injectComponent("listView", "actions", {
+        name: "export-import-buttons",
+        Component: ExportImportButtons,
       });
     }
   },
-
-  async registerTrads(app) {
-    const { locales } = app;
-
-    const importedTrads = await Promise.all(
-      locales.map((locale) => {
-        return import(`./admin/src/translations/${locale}.json`)
-          .then(({ default: data }) => {
-            return {
-              data: data,
-              locale,
-            };
-          })
-          .catch(() => {
-            return {
-              data: {},
-              locale,
-            };
-          });
-      })
-    );
-
-    return Promise.resolve(importedTrads);
-  },
 };

package/admin/src/components/BulkActions/index.js

@@ -1,70 +0,0 @@
-import React from 'react';
-import ExportButton from '../ExportButton';
-import ImportButton from '../ImportButton';
-
-const BulkActions = ({ layout }) => {
-  const handleExportAll = async () => {
-    try {
-      const contentType = layout.uid;
-      
-      // Get current filters from URL if any
-      const urlParams = new URLSearchParams(window.location.search);
-      const filters = {};
-      
-      // Build filters from URL params
-      for (const [key, value] of urlParams.entries()) {
-        if (key.startsWith('filters[')) {
-          filters[key] = value;
-        }
-      }
-
-      const queryString = new URLSearchParams({
-        format: 'excel',
-        contentType: contentType,
-        ...filters
-      }).toString();
-
-      const response = await fetch(`/export-import-clsx/export?${queryString}`);
-      
-      if (response.ok) {
-        const blob = await response.blob();
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement('a');
-        a.href = url;
-        a.download = `${contentType.replace('api::', '')}-export-${new Date().toISOString().split('T')[0]}.xlsx`;
-        document.body.appendChild(a);
-        a.click();
-        window.URL.revokeObjectURL(url);
-        document.body.removeChild(a);
-      } else {
-        throw new Error('Export failed');
-      }
-    } catch (error) {
-      alert('Export failed: ' + error.message);
-    }
-  };
-
-  return React.createElement('div', { 
-    style: { 
-      display: 'flex', 
-      gap: '8px', 
-      alignItems: 'center',
-      marginLeft: '16px'
-    } 
-  },
-    React.createElement('button', {
-      onClick: handleExportAll,
-      style: {
-        padding: '8px 16px',
-        backgroundColor: '#4945ff',
-        color: 'white',
-        border: 'none',
-        borderRadius: '4px',
-        cursor: 'pointer'
-      }
-    }, 'Export All'),
-    React.createElement(ImportButton)
-  );
-};
-
-export default BulkActions;

package/admin/src/components/ExportButton/index.jsx

@@ -1,71 +0,0 @@
-import React, { useState } from "react";
-import { Button } from "@strapi/design-system";
-import { Download } from "@strapi/icons";
-import { useNotification } from "@strapi/strapi/admin";
-
-const ExportButton = ({ layout, modifiedData }) => {
-  const [isExporting, setIsExporting] = useState(false);
-  const { toggleNotification } = useNotification();
-
-  const handleExport = async () => {
-    try {
-      const contentType = layout.uid;
-      const entryId = modifiedData.id;
-
-      if (!entryId) {
-        toggleNotification({
-          type: "warning",
-          message: "Please save the entry first",
-        });
-        return;
-      }
-
-      setIsExporting(true);
-
-      const response = await fetch(
-        `/export-import-clsx/export/${contentType}/${entryId}`
-      );
-
-      if (response.ok) {
-        const blob = await response.blob();
-        const url = window.URL.createObjectURL(blob);
-        const a = document.createElement("a");
-        a.href = url;
-        a.download = `entry-${entryId}-${new Date().toISOString().split("T")[0]}.xlsx`;
-        document.body.appendChild(a);
-        a.click();
-        window.URL.revokeObjectURL(url);
-        document.body.removeChild(a);
-
-        toggleNotification({
-          type: "success",
-          message: "Entry exported successfully",
-        });
-      } else {
-        throw new Error("Export failed");
-      }
-    } catch (error) {
-      toggleNotification({
-        type: "danger",
-        message: `Export failed: ${error.message}`,
-      });
-    } finally {
-      setIsExporting(false);
-    }
-  };
-
-  return (
-    <Button
-      onClick={handleExport}
-      loading={isExporting}
-      startIcon={<Download />}
-      variant="secondary"
-      size="S"
-      style={{ marginLeft: "8px" }}
-    >
-      Export Entry
-    </Button>
-  );
-};
-
-export default ExportButton;

package/admin/src/components/ImportButton/index.jsx

@@ -1,81 +0,0 @@
-import React, { useState } from "react";
-import { Button } from "@strapi/design-system";
-import { Upload } from "@strapi/icons";
-import { useNotification } from "@strapi/strapi/admin";
-
-const ImportButton = () => {
-  const [isImporting, setIsImporting] = useState(false);
-  const { toggleNotification } = useNotification();
-
-  const handleImport = async (event) => {
-    const file = event.target.files[0];
-    if (!file) return;
-
-    setIsImporting(true);
-    const formData = new FormData();
-    formData.append("file", file);
-
-    try {
-      const response = await fetch("/export-import-clsx/import", {
-        method: "POST",
-        body: formData,
-      });
-
-      if (response.ok) {
-        const result = await response.json();
-        const imported = result.result.imported || 0;
-        const errors = result.result.errors?.length || 0;
-
-        if (errors > 0) {
-          toggleNotification({
-            type: "warning",
-            message: `Import completed with ${errors} error(s). Imported: ${imported} entries`,
-          });
-        } else {
-          toggleNotification({
-            type: "success",
-            message: `Import completed successfully! Imported: ${imported} entries`,
-          });
-        }
-
-        window.location.reload();
-      } else {
-        throw new Error("Import failed");
-      }
-    } catch (error) {
-      toggleNotification({
-        type: "danger",
-        message: `Import failed: ${error.message}`,
-      });
-    } finally {
-      setIsImporting(false);
-      event.target.value = "";
-    }
-  };
-
-  return (
-    <div style={{ display: "inline-block", marginLeft: "8px" }}>
-      <input
-        type="file"
-        accept=".xlsx,.xls,.json"
-        onChange={handleImport}
-        disabled={isImporting}
-        style={{ display: "none" }}
-        id="import-file-input"
-      />
-      <Button
-        as="label"
-        htmlFor="import-file-input"
-        loading={isImporting}
-        startIcon={<Upload />}
-        variant="secondary"
-        size="S"
-        style={{ cursor: isImporting ? "not-allowed" : "pointer" }}
-      >
-        Import Data
-      </Button>
-    </div>
-  );
-};
-
-export default ImportButton;

package/admin/src/translations/en.json

@@ -1,14 +0,0 @@
-{
-  "plugin.name": "Export Import CLSX",
-  "plugin.description": "Export and import data with enhanced functionality",
-  "export.title": "Export Data",
-  "export.description": "Export all your content types data to a JSON file",
-  "export.button": "Export Data",
-  "export.success": "Export completed successfully",
-  "export.error": "Export failed",
-  "import.title": "Import Data", 
-  "import.description": "Import data from a JSON file to your Strapi instance",
-  "import.button": "Import Data",
-  "import.success": "Import completed successfully",
-  "import.error": "Import failed"
-}