@tunghtml/strapi-plugin-export-import-clsx 1.0.0

package/server/services/export-service.js

@@ -0,0 +1,336 @@
+const XLSX = require('xlsx');
+
+module.exports = ({ strapi }) => ({
+  async exportData(format = 'json', contentType = null, filters = {}, selectedIds = []) {
+    // Get only API content types (collections)
+    let contentTypes;
+    if (contentType) {
+      contentTypes = [contentType];
+    } else {
+      contentTypes = Object.keys(strapi.contentTypes).filter(
+        (key) => key.startsWith('api::')
+      );
+    }
+
+    const exportData = {
+      version: strapi.config.get('info.strapi'),
+      timestamp: new Date().toISOString(),
+      data: {},
+    };
+
+    for (const ct of contentTypes) {
+      try {
+        // Parse filters from URL format
+        const parsedFilters = this.parseFilters(filters);
+        
+        strapi.log.info(`Exporting ${ct} with raw filters:`, filters);
+        strapi.log.info(`Parsed filters:`, parsedFilters);
+        strapi.log.info(`Selected IDs:`, selectedIds);
+
+        let entries = [];
+        
+        // If specific IDs are selected, export only those
+        if (selectedIds && selectedIds.length > 0) {
+          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);
+                }
+              }
+            }
+          } 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);
+                  }
+                }
+              }
+              
+              entries = Array.from(uniqueEntries.values());
+              strapi.log.info(`Found ${allEntries.length} total entries, ${entries.length} unique entries after deduplication`);
+              
+              // 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`);
+            }
+          } 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})`);
+        
+        if (entries && entries.length > 0) {
+          exportData.data[ct] = entries;
+        }
+      } catch (error) {
+        strapi.log.error(`Failed to export ${ct}:`, error);
+      }
+    }
+
+    if (format === 'excel') {
+      return this.convertToExcel(exportData.data);
+    }
+
+    return exportData;
+  },
+
+  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)) {
+        continue;
+      }
+      
+      // Handle URL encoded filter format like filters[$and][0][shortName][$contains]
+      if (key.startsWith('filters[')) {
+        // Extract the actual filter structure
+        const match = key.match(/filters\[([^\]]+)\](?:\[(\d+)\])?\[([^\]]+)\](?:\[([^\]]+)\])?/);
+        if (match) {
+          const [, operator, index, field, condition] = match;
+          
+          if (!parsed.filters) parsed.filters = {};
+          
+          if (operator === '$and') {
+            if (!parsed.filters.$and) parsed.filters.$and = [];
+            const idx = parseInt(index) || 0;
+            if (!parsed.filters.$and[idx]) parsed.filters.$and[idx] = {};
+            
+            if (condition) {
+              if (!parsed.filters.$and[idx][field]) parsed.filters.$and[idx][field] = {};
+              parsed.filters.$and[idx][field][condition] = value;
+            } else {
+              parsed.filters.$and[idx][field] = value;
+            }
+          }
+        }
+      } else {
+        parsed[key] = value;
+      }
+    }
+    
+    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;
+
+    for (const [contentType, entries] of Object.entries(data)) {
+      // Clean sheet name (Excel has restrictions)
+      const sheetName = contentType.replace(/[^\w\s]/gi, '_').substring(0, 31);
+      
+      if (entries && entries.length > 0) {
+        hasData = true;
+        
+        // Clean and flatten entries for Excel
+        const cleanedEntries = entries.map(entry => {
+          // Keep important system fields for import
+          const { 
+            createdBy, 
+            updatedBy, 
+            localizations,
+            ...entryWithSystemFields 
+          } = entry;
+
+          const flattened = {
+            // Always include these at the beginning for import reference
+            id: entry.id,
+            documentId: entry.documentId,
+            locale: entry.locale || 'en',
+          };
+          
+          const flatten = (obj, prefix = '') => {
+            for (const key in obj) {
+              // Skip already processed system fields and status fields
+              if (['id', 'documentId', 'createdBy', 'updatedBy', 'localizations', 'publishedAt', 'status'].includes(key)) {
+                continue;
+              }
+              
+              if (obj[key] !== null && typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+                // Skip nested objects that are system fields
+                if (key === 'createdBy' || key === 'updatedBy') {
+                  continue;
+                }
+                flatten(obj[key], prefix + key + '_');
+              } else if (Array.isArray(obj[key])) {
+                flattened[prefix + key] = JSON.stringify(obj[key]);
+              } else {
+                flattened[prefix + key] = obj[key];
+              }
+            }
+          };
+          
+          flatten(entryWithSystemFields);
+          return flattened;
+        });
+
+        const worksheet = XLSX.utils.json_to_sheet(cleanedEntries);
+        XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+      } else {
+        // Create empty sheet with headers if no data
+        const worksheet = XLSX.utils.json_to_sheet([{ message: 'No data found' }]);
+        XLSX.utils.book_append_sheet(workbook, worksheet, sheetName);
+        hasData = true; // Prevent empty workbook error
+      }
+    }
+
+    // If still no data, create a default sheet
+    if (!hasData) {
+      const worksheet = XLSX.utils.json_to_sheet([{ message: 'No data to export' }]);
+      XLSX.utils.book_append_sheet(workbook, worksheet, 'NoData');
+    }
+
+    return XLSX.write(workbook, { type: 'buffer', bookType: 'xlsx' });
+  },
+
+  async exportSingleEntry(contentType, entryId) {
+    try {
+      const entry = await strapi.entityService.findOne(contentType, entryId, {
+        populate: '*',
+      });
+
+      if (!entry) {
+        throw new Error('Entry not found');
+      }
+
+      const exportData = {
+        version: strapi.config.get('info.strapi'),
+        timestamp: new Date().toISOString(),
+        data: {
+          [contentType]: [entry]
+        },
+      };
+
+      return this.convertToExcel(exportData.data);
+    } catch (error) {
+      throw error;
+    }
+  },
+});

package/server/services/import-service.js

@@ -0,0 +1,306 @@
+const fs = require('fs');
+const XLSX = require('xlsx');
+
+module.exports = ({ strapi }) => ({
+  async importData(file, targetContentType = null) {
+    try {
+      let importData;
+      
+      // Check file extension
+      const fileName = file.name || file.originalFilename || 'unknown.json';
+      const fileExtension = fileName.split('.').pop().toLowerCase();
+      
+      const filePath = file.path || file.filepath;
+      
+      if (!filePath) {
+        throw new Error('File path not found');
+      }
+
+      if (fileExtension === 'json') {
+        const fileContent = fs.readFileSync(filePath, 'utf8');
+        importData = JSON.parse(fileContent);
+        strapi.log.info('Parsed JSON data:', Object.keys(importData));
+      } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
+        const workbook = XLSX.readFile(filePath);
+        importData = {};
+        
+        strapi.log.info('Excel sheet names:', workbook.SheetNames);
+        
+        // Convert each sheet to data
+        workbook.SheetNames.forEach(sheetName => {
+          const worksheet = workbook.Sheets[sheetName];
+          const jsonData = XLSX.utils.sheet_to_json(worksheet);
+          strapi.log.info(`Sheet ${sheetName} has ${jsonData.length} rows`);
+          if (jsonData.length > 0) {
+            // Map sheet name back to content type
+            let contentTypeName = sheetName;
+            if (sheetName.startsWith('api__')) {
+              // Convert api__corporate_corporate to api::corporate.corporate
+              contentTypeName = sheetName.replace(/^api__/, 'api::').replace(/_/g, '.');
+            }
+            
+            // Unflatten Excel data back to nested objects
+            const unflattened = jsonData.map((row, index) => {
+              const result = {};
+              
+              // Known component prefixes that should be unflattened
+              const componentPrefixes = ['corporateInfo', 'meetingRequirements', 'internalInfo'];
+              
+              for (const [key, value] of Object.entries(row)) {
+                // Skip completely empty values but keep 0, false, etc.
+                if (value === null || value === undefined || value === '') {
+                  continue;
+                }
+                
+                // Check if this key should be unflattened
+                const shouldUnflatten = key.includes('_') && 
+                  !['createdAt', 'updatedAt', 'publishedAt'].includes(key) &&
+                  componentPrefixes.some(prefix => key.startsWith(prefix + '_'));
+                
+                if (shouldUnflatten) {
+                  // Handle nested objects like corporateInfo_companyName
+                  const parts = key.split('_');
+                  let current = result;
+                  
+                  for (let i = 0; i < parts.length - 1; i++) {
+                    if (!current[parts[i]]) {
+                      current[parts[i]] = {};
+                    }
+                    current = current[parts[i]];
+                  }
+                  
+                  current[parts[parts.length - 1]] = value;
+                } else {
+                  // Handle arrays/JSON strings
+                  if (typeof value === 'string' && (value.startsWith('[') || value.startsWith('{'))) {
+                    try {
+                      result[key] = JSON.parse(value);
+                    } catch (error) {
+                      result[key] = value; // Keep as string if parsing fails
+                    }
+                  } else {
+                    result[key] = value;
+                  }
+                }
+              }
+              
+              // Debug info removed for cleaner logs
+              
+              return result;
+            });
+            
+            importData[contentTypeName] = unflattened;
+            strapi.log.info(`Mapped sheet ${sheetName} to ${contentTypeName}`);
+          }
+        });
+        
+        strapi.log.info('Final import data keys:', Object.keys(importData));
+      } else {
+        throw new Error('Unsupported file format. Please use JSON or Excel files.');
+      }
+
+      const results = {
+        created: 0,
+        updated: 0,
+        errors: [],
+      };
+
+      // Handle different data structures
+      const dataToProcess = importData.data || importData;
+
+      for (const [contentType, entries] of Object.entries(dataToProcess)) {
+        try {
+          // If targetContentType is specified, only process that content type
+          if (targetContentType && contentType !== targetContentType) {
+            continue;
+          }
+
+          // Skip if not an API content type
+          if (!contentType.startsWith('api::')) {
+            continue;
+          }
+
+          // Check if content type exists
+          if (!strapi.contentTypes[contentType]) {
+            results.errors.push(`Content type ${contentType} not found`);
+            continue;
+          }
+
+          if (!Array.isArray(entries)) {
+            results.errors.push(`Invalid data format for ${contentType}`);
+            continue;
+          }
+
+          for (const entry of entries) {
+            try {
+              // Extract system fields for update/create logic
+              const { 
+                id, 
+                documentId, 
+                status,
+                createdAt, 
+                updatedAt, 
+                publishedAt, 
+                createdBy, 
+                updatedBy, 
+                localizations,
+                locale,
+                ...cleanEntry 
+              } = entry;
+
+              // Skip empty entries
+              if (!cleanEntry || Object.keys(cleanEntry).length === 0) {
+                strapi.log.warn('Skipping empty entry');
+                continue;
+              }
+              
+              // Clean up empty string values and convert to null
+              for (const [key, value] of Object.entries(cleanEntry)) {
+                if (value === '' || value === 'null' || value === 'undefined') {
+                  cleanEntry[key] = null;
+                }
+              }
+              
+              let existingEntry = null;
+              let updateMode = false;
+              
+              // Only try to find existing entry if documentId is provided and valid
+              if (documentId && documentId !== '' && documentId !== 'null' && documentId !== 'undefined') {
+                try {
+                  if (strapi.documents) {
+                    existingEntry = await strapi.documents(contentType).findOne({
+                      documentId: documentId,
+                    });
+                    if (existingEntry) {
+                      updateMode = true;
+                      strapi.log.info(`Found existing entry for update: ${documentId}`);
+                    }
+                  }
+                } catch (error) {
+                  // Entry not found, will create new one
+                  strapi.log.info(`DocumentId ${documentId} not found, will create new entry`);
+                }
+              }
+              
+              // If no documentId provided or not found, this will be a new entry
+              if (!existingEntry) {
+                strapi.log.info(`Creating new entry for: ${cleanEntry.shortName || cleanEntry.name || cleanEntry.title || 'Unknown'}`);
+              }
+              
+              // Skip entries without basic required fields
+              if (!cleanEntry.shortName && !cleanEntry.name && !cleanEntry.title) {
+                continue;
+              }
+              
+              // Ensure required components exist for corporate
+              if (contentType === 'api::corporate.corporate') {
+                if (!cleanEntry.corporateInfo) cleanEntry.corporateInfo = {};
+                if (!cleanEntry.meetingRequirements) cleanEntry.meetingRequirements = {};
+                if (!cleanEntry.internalInfo) cleanEntry.internalInfo = {};
+              }
+              
+              if (existingEntry) {
+                // Check if there are actual changes before updating
+                const hasChanges = this.hasDataChanges(existingEntry, cleanEntry);
+                const statusChanged = (status === 'published') !== !!existingEntry.publishedAt;
+                
+                if (hasChanges || statusChanged) {
+                  try {
+                    if (strapi.documents) {
+                      const updateData = {
+                        documentId: existingEntry.documentId,
+                        data: cleanEntry,
+                      };
+                      
+                      // Handle status change
+                      if (statusChanged) {
+                        updateData.status = status === 'published' ? 'published' : 'draft';
+                      }
+                      
+                      await strapi.documents(contentType).update(updateData);
+                      results.updated++;
+                    } else {
+                      await strapi.entityService.update(contentType, existingEntry.id, {
+                        data: cleanEntry,
+                      });
+                      results.updated++;
+                    }
+                  } catch (updateError) {
+                    results.errors.push(`Failed to update entry: ${updateError.message}`);
+                  }
+                } else {
+                  // No changes, skip update
+                  strapi.log.info(`No changes detected for entry: ${cleanEntry.shortName || 'Unknown'}`);
+                }
+              } else {
+                // Create new entry
+                try {
+                  if (strapi.documents) {
+                    await strapi.documents(contentType).create({
+                      data: cleanEntry,
+                      status: status === 'published' ? 'published' : 'draft',
+                    });
+                    results.created++;
+                  } else {
+                    await strapi.entityService.create(contentType, {
+                      data: cleanEntry,
+                    });
+                    results.created++;
+                  }
+                } catch (createError) {
+                  results.errors.push(`Failed to create entry: ${createError.message}`);
+                }
+              }
+            } catch (error) {
+              results.errors.push(`Failed to import entry in ${contentType}: ${error.message}`);
+              strapi.log.error('Import entry error:', error);
+            }
+          }
+        } catch (error) {
+          results.errors.push(`Failed to process ${contentType}: ${error.message}`);
+          strapi.log.error('Import process error:', error);
+        }
+      }
+
+      // Clean up uploaded file
+      if (filePath && fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+
+      return results;
+    } catch (error) {
+      // Clean up uploaded file on error
+      const filePath = file && (file.path || file.filepath);
+      if (filePath && fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+      throw error;
+    }
+  },
+
+  hasDataChanges(existingEntry, newData) {
+    // Compare key fields to detect changes
+    const fieldsToCompare = ['shortName', 'name', 'title'];
+    
+    for (const field of fieldsToCompare) {
+      if (existingEntry[field] !== newData[field]) {
+        return true;
+      }
+    }
+    
+    // Compare nested objects (components)
+    const componentsToCompare = ['corporateInfo', 'meetingRequirements', 'internalInfo'];
+    
+    for (const component of componentsToCompare) {
+      if (existingEntry[component] && newData[component]) {
+        const existingStr = JSON.stringify(existingEntry[component]);
+        const newStr = JSON.stringify(newData[component]);
+        if (existingStr !== newStr) {
+          return true;
+        }
+      }
+    }
+    
+    return false;
+  },
+});

package/server/services/index.js

@@ -0,0 +1,7 @@
+const exportService = require('./export-service');
+const importService = require('./import-service');
+
+module.exports = {
+  'export-service': exportService,
+  'import-service': importService,
+};