@nkhang1902/strapi-plugin-export-import-clsx 1.0.3 → 1.0.4

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

@@ -21,7 +21,7 @@ const ExportImportButtons = (props) => {
     const filters = {};
     
     for (const [key, value] of urlParams.entries()) {
-      if (key.startsWith('filters[') || key === 'sort' || key === 'page' || key === 'pageSize' || key === 'locale') {
+      if (key.startsWith('filters[') || key === 'sort' || key === 'page' || key === 'pageSize' || key === 'locale' || key === '_q') {
         filters[key] = value;
       }
     }
@@ -41,21 +41,54 @@ const ExportImportButtons = (props) => {
     if (props.selection && props.selection.length > 0) {
       return props.selection;
     }
-    
-    // Try to get from global state or context
+    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 {
-      // Check if there's a selection in the page context
-      const checkboxes = document.querySelectorAll('input[type="checkbox"]:checked');
-      const selectedIds = [];
-      checkboxes.forEach(checkbox => {
-        const value = checkbox.value;
-        if (value && value !== 'on' && value !== 'all') {
-          selectedIds.push(value);
+      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;
-    } catch (error) {
-      return [];
+
+      return [selectedIds, field];
+
+    } catch (e) {
+      console.error(e);
+      return [[], ''];
     }
   };
 
@@ -69,8 +102,8 @@ const ExportImportButtons = (props) => {
     setIsExporting(true);
     try {
       const filters = getCurrentFilters();
-      const selectedEntries = getSelectedEntries();
-      
+      const [selectedEntries, selectedField] = getSelectedEntries();
+
       const queryParams = new URLSearchParams({
         format: 'excel',
         contentType: contentType,
@@ -80,10 +113,11 @@ 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) {
         const blob = await response.blob();
         const url = window.URL.createObjectURL(blob);
@@ -180,7 +214,7 @@ const ExportImportButtons = (props) => {
     }
   };
 
-  const selectedEntries = getSelectedEntries();
+  const [selectedEntries, selectedField] = getSelectedEntries();
   const exportButtonText = isExporting 
     ? 'Exporting...' 
     : selectedEntries.length > 0 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkhang1902/strapi-plugin-export-import-clsx",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "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,7 +1,7 @@
 module.exports = ({ strapi }) => ({
   async export(ctx) {
     try {
-      const { format = 'excel', contentType, selectedIds, ...filters } = ctx.query;
+      const { format = 'excel', contentType, selectedIds, selectedField, ...filters } = ctx.query;
       const exportService = strapi.plugin('export-import-clsx').service('export-service');
       
       // Parse selectedIds if provided
@@ -15,7 +15,7 @@ module.exports = ({ strapi }) => ({
       }
       
       if (format === 'excel') {
-        const buffer = await exportService.exportData('excel', contentType, filters, parsedSelectedIds);
+        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`

package/server/services/export-service.js

@@ -1,7 +1,7 @@
 const XLSX = require('xlsx');
 
 module.exports = ({ strapi }) => ({
-  async exportData(format = 'json', contentType = null, filters = {}, selectedIds = []) {
+  async exportData(format = 'json', contentType = null, rawFilters = {}, selectedIds = [], selectedField = null) {
     // Get only API content types (collections)
     let contentTypes;
     if (contentType) {
@@ -21,97 +21,77 @@ module.exports = ({ strapi }) => ({
     for (const ct of contentTypes) {
       try {
         // Parse filters from URL format
-        const parsedFilters = this.parseFilters(filters);
+        const parsedFilters = this.parseFilters(rawFilters);
 
-        strapi.log.info(`Exporting ${ct} with raw filters:`, filters);
-        strapi.log.info(`Parsed filters:`, parsedFilters);
-        strapi.log.info(`Selected IDs:`, selectedIds);
+        if (rawFilters['_q']) {
+          parsedFilters._q = rawFilters['_q'];
+        }
+
+        strapi.log.info(`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) {
+          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 {
-            if (strapi.documents) {
-              // Get entries by documentId for Strapi v5
-              for (const id of selectedIds) {
-                try {
-                  const entry = await strapi.documents(ct).findOne({
-                    documentId: id,
-                    populate: '*',
-                  });
-                  if (entry) {
-                    entries.push(entry);
-                  }
-                } catch (error) {
-                  strapi.log.warn(`Failed to find entry ${id}:`, error.message);
-                }
-              }
-            } else {
-              // Fallback for older Strapi versions
-              for (const id of selectedIds) {
-                try {
-                  const entry = await strapi.entityService.findOne(ct, id, {
-                    populate: '*',
-                  });
-                  if (entry) {
-                    entries.push(entry);
-                  }
-                } catch (error) {
-                  strapi.log.warn(`Failed to find entry ${id}:`, error.message);
-                }
-              }
-            }
+            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
-          try {
-            if (strapi.documents) {
-              // Get all entries (both published and draft) but avoid duplicates
-              const allEntries = await strapi.documents(ct).findMany({
-                populate: '*',
-                // Don't specify status to get all
-              });
-              // Group by documentId and keep only the best version (published > modified draft > draft)
-              const uniqueEntries = new Map();
-              for (const entry of allEntries) {
-                const docId = entry.documentId;
-                const isPublished = !!entry.publishedAt;
-                const isModified = entry.updatedAt !== entry.createdAt;
-                if (!uniqueEntries.has(docId)) {
-                  uniqueEntries.set(docId, entry);
-                } else {
-                  const existing = uniqueEntries.get(docId);
-                  const existingIsPublished = !!existing.publishedAt;
-                  const existingIsModified = existing.updatedAt !== existing.createdAt;
-                  // Priority: published > modified draft > draft
-                  if (isPublished && !existingIsPublished) {
-                    uniqueEntries.set(docId, entry);
-                  } else if (!isPublished && !existingIsPublished && isModified && !existingIsModified) {
-                    uniqueEntries.set(docId, entry);
-                  }
-                }
-              }
+          const searchable = this.getSearchableFields(strapi.contentTypes[ct]);
+          const numberSearchable = this.getNumberFields(strapi.contentTypes[ct]);
+
+          if (parsedFilters._q) {
+            strapi.log.info(`Applying search query: ${parsedFilters._q} for fields: ${JSON.stringify([...searchable, ...numberSearchable])}`);
+            const orConditions = [];
+
+            if (searchable.length > 0) {
+              orConditions.push(
+                ...searchable.map((field) => ({
+                  [field]: { $containsi: parsedFilters._q }
+                }))
+              );
+            }
 
-              entries = Array.from(uniqueEntries.values());
-              strapi.log.info(`Found ${allEntries.length} total entries, ${entries.length} unique entries after deduplication`);
+            if (numberSearchable.length > 0 && !isNaN(parsedFilters._q)) {
+              orConditions.push(
+                ...numberSearchable.map((field) => ({
+                  [field]: { $eq: Number(parsedFilters._q) }
+                }))
+              );
+            }
 
-              // Apply filters
-              if (parsedFilters && Object.keys(parsedFilters).length > 0) {
-                strapi.log.info('Applying filters:', parsedFilters);
-                entries = this.applyClientSideFilters(entries, parsedFilters);
-                strapi.log.info(`After filtering: ${entries.length} entries`);
-              }
-            } else {
-              // Fallback for older Strapi versions
-              entries = await strapi.entityService.findMany(ct, {
-                populate: '*',
-                filters: parsedFilters,
-              });
-              strapi.log.info(`EntityService found ${entries?.length || 0} entries`);
+            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);
           }
@@ -134,11 +114,37 @@ module.exports = ({ strapi }) => ({
     return exportData;
   },
 
+  getSearchableFields(contentTypeSchema) {
+    const searchable = [];
+
+    for (const [fieldName, field] of Object.entries(contentTypeSchema.attributes)) {
+      if (["string", "text", "richtext", "email", "uid", "enumeration"].includes(field.type) && fieldName !== 'locale') {
+        searchable.push(fieldName);
+      }
+    }
+
+    return searchable;
+  },
+
+  getNumberFields(contentTypeSchema) {
+    const numberFields = [];
+
+    for (const [fieldName, field] of Object.entries(contentTypeSchema.attributes)) {
+      if (["number", "integer", "biginteger", "float", "decimal"].includes(field.type)) {
+        numberFields.push(fieldName);
+      }
+    }
+
+    numberFields.push('id');
+
+    return numberFields;
+  },
+
   parseFilters(filters) {
     const parsed = {};
     for (const [key, value] of Object.entries(filters)) {
       // Skip pagination and sorting params
-      if (['page', 'pageSize', 'sort', 'locale', 'format', 'contentType', 'selectedIds'].includes(key)) {
+      if (['page', 'pageSize', 'sort', 'locale', 'format', 'contentType', '_q'].includes(key)) {
         continue;
       }
 
@@ -172,62 +178,6 @@ module.exports = ({ strapi }) => ({
     return parsed;
   },
 
-  applyClientSideFilters(entries, filters) {
-    if (!filters || Object.keys(filters).length === 0) {
-      return entries;
-    }
-
-    const filtered = entries.filter(entry => {
-      // Handle structured filters
-      if (filters.filters && filters.filters.$and) {
-        for (const condition of filters.filters.$and) {
-          for (const [field, criteria] of Object.entries(condition)) {
-            if (typeof criteria === 'object' && criteria.$contains) {
-              // Handle $contains filter
-              if (entry[field]) {
-                const fieldValue = String(entry[field]).toLowerCase();
-                const searchValue = String(criteria.$contains).toLowerCase();
-                if (!fieldValue.includes(searchValue)) {
-                  return false;
-                }
-              } else {
-                return false; // Field doesn't exist, exclude entry
-              }
-            } else {
-              // Handle exact match
-              if (entry[field] !== criteria) {
-                return false;
-              }
-            }
-          }
-        }
-      }
-      // Handle other filter formats
-      for (const [key, value] of Object.entries(filters)) {
-        if (key === 'filters') continue; // Already handled above
-
-        // Handle simple search (global search)
-        if (key === '_q' || key === 'search') {
-          // Global search across main fields
-          const searchFields = ['shortName', 'name', 'title'];
-          const searchValue = String(value).toLowerCase();
-          const found = searchFields.some(field => {
-            if (entry[field]) {
-              return String(entry[field]).toLowerCase().includes(searchValue);
-            }
-            return false;
-          });
-          if (!found) {
-            return false;
-          }
-        }
-      }
-      return true;
-    });
-
-    return filtered;
-  },
-
   convertToExcel(data) {
     const workbook = XLSX.utils.book_new();
     let hasData = false;