@nkhang1902/strapi-plugin-export-import-clsx 1.1.153 → 1.2.1

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

@@ -1,8 +1,5 @@
 import { useState, useRef } from "react";
 import {
-  Modal,
-  Typography,
-  Box,
   Button,
 } from "@strapi/design-system";
 import { Download, Upload } from "@strapi/icons";
@@ -11,9 +8,6 @@ import { useNotification } from "@strapi/strapi/admin";
 const ExportImportButtons = (props) => {
   const [isExporting, setIsExporting] = useState(false);
   const [isImporting, setIsImporting] = useState(false);
-  const [showErrorModal, setShowErrorModal] = useState(false);
-  const [importErrors, setImportErrors] = useState([]);
-
   const { toggleNotification } = useNotification();
 
   // Get current content type from props or URL
@@ -105,26 +99,44 @@ const ExportImportButtons = (props) => {
     title,
     message,
     type = 'warning',
-    duration = 15000, // 15 seconds
+    duration = 15000,
+    maxLines = 8,
   }) {
+    const lines = String(message).split('\n');
+
+    let displayText = message;
+    let extraCount = 0;
+    if (lines.length > maxLines) {
+      extraCount = lines.length - maxLines;
+      displayText =
+        lines.slice(0, maxLines).join('\n') +
+        `\n... (+${extraCount} more errors)`;
+    }
+
+    displayText = '\n' + displayText;
+
     toggle({
       type,
       title,
       message: (
-        <div style={{
-          maxHeight: '260px',
-          overflowY: 'auto',
-          whiteSpace: 'pre-wrap',
-          fontSize: 13,
-          lineHeight: 1.5,
-          paddingRight: 4,
-        }}>
-          {message}
+        <div
+          style={{
+            maxHeight: 260,
+            overflowY: 'auto',
+            whiteSpace: 'pre-wrap',
+            fontSize: 13,
+            lineHeight: 1.5,
+            paddingTop: 4,
+            paddingRight: 4,
+          }}
+        >
+          {displayText}
         </div>
       ),
       timeout: duration,
     });
   }
+  const currentContentType = getContentType();
 
   const handleExport = async () => {
     const contentType = getContentType();
@@ -210,7 +222,7 @@ const ExportImportButtons = (props) => {
 
     const eventFilter = getEventFilter();
     try {
-      const response = await fetch(`/export-import-clsx/import?eventId=${eventFilter.eventId}`, {
+      const response = await fetch(`/export-import-clsx/import?eventId=${eventFilter?.eventId || ""}`, {
         method: "POST",
         body: formData,
       });
@@ -224,8 +236,6 @@ const ExportImportButtons = (props) => {
         const total = created + updated;
 
         if (errorList.length > 0) {
-          setImportErrors(errorList);
-          setShowErrorModal(true);
           showLongNotification(toggleNotification, {
             title: "Import errors",
             message: errorList.join("\n"),
@@ -265,8 +275,10 @@ const ExportImportButtons = (props) => {
   // Create ref for file input
   const fileInputRef = useRef(null);
 
+  if (["api::event.event", "api::event-content.event-content", "api::meeting-participation-status.meeting-participation-status"].includes(currentContentType)) {
+    return null
+  }
   return (
-    <>
     <div
       style={{
         display: "flex",
@@ -304,41 +316,6 @@ const ExportImportButtons = (props) => {
         Import
       </Button>
     </div>
-    {showErrorModal && (
-      <Modal.Root
-        onClose={() => setShowErrorModal(false)}
-        labelledBy="import-errors-title"
-      >
-        <Modal.Content>
-        <Modal.Header>
-          <Typography id="import-errors-title" fontWeight="bold">
-            Import Errors ({importErrors.length})
-          </Typography>
-        </Modal.Header>
-
-        <Modal.Body>
-          <Box padding={4}>
-            {importErrors.map((err, index) => (
-              <Box key={index} paddingBottom={2}>
-                <Typography textColor="danger600">
-                  {index + 1}. {err}
-                </Typography>
-              </Box>
-            ))}
-          </Box>
-        </Modal.Body>
-
-        <Modal.Footer
-          endActions={
-            <Button onClick={() => setShowErrorModal(false)}>
-              Close
-            </Button>
-          }
-        />
-        </Modal.Content>
-      </Modal.Root>
-    )}
-    </>
   );
 };
 

package/package.json

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

package/server/controllers/import-controller.js

@@ -14,7 +14,10 @@ module.exports = ({ strapi }) => ({
         .plugin("export-import-clsx")
         .service("import-service");
 
-      const { eventId } = ctx.request.query;
+      let { eventId } = ctx.request.query;
+      if (eventId == "") {
+        eventId = null;
+      }
 
       const result = await importService.importData(file, targetContentType, eventId);
 

package/server/services/export-service.js

@@ -298,7 +298,7 @@ module.exports = ({ strapi }) => ({
 
                 if (componentFields.includes(key)) {
                   for (const subKey in value) {
-                    if (["id", "createdAt", "updatedAt", "lastUpdate", "passcode"]) continue;
+                    if (["id", "createdAt", "updatedAt", "lastUpdate", "passcode"].includes(subKey)) continue;
                     result[`${key}_${subKey}`] = value[subKey];
                   }
                   continue;

package/server/services/import-service.js

@@ -87,6 +87,9 @@ module.exports = ({ strapi }) => ({
     };
 
     workbook.SheetNames.forEach((sheetName) => {
+      if (targetContentType && mapSheetNameToContentType(sheetName) !== targetContentType) {
+        throw new Error(`Sheet name "${sheetName}" does not match target content type "${targetContentType.split(".")[1]}"`);
+      }
       const worksheet = workbook.Sheets[sheetName];
       const rows = XLSX.utils.sheet_to_json(worksheet);
 
@@ -147,7 +150,7 @@ module.exports = ({ strapi }) => ({
       .map(([fieldName, attr]) => toCamel(fieldName));
   },
 
-  async handleRelations(entry, contentType, eventId) {
+  async handleRelations(entry, contentType) {
     const resolveRelationValue = async (field, value, target) => {
       const targetAttr = strapi.contentTypes[target].attributes;
       for (const field of SHORTCUT_FIELDS) {
@@ -156,7 +159,7 @@ module.exports = ({ strapi }) => ({
           filters: { [field]: { $eq: value } },
         });
         if (existing) return { id: existing.id };
-        throw new Error(`Data with ${field} ${value} not found. Cannot map to ${contentType}`);
+        throw new Error(`Not found.`);
       }
       return null;
     };
@@ -181,11 +184,7 @@ module.exports = ({ strapi }) => ({
         if (relation === "manyToMany" || relation === "oneToMany") {
           updatedEntry[field] = [];
         } else {
-          if (field === 'event') {
-            updatedEntry[field] = { documentId: eventId };
-          } else {
-            updatedEntry[field] = null;
-          }
+          updatedEntry[field] = null;
         }
         continue;
       }
@@ -215,7 +214,7 @@ module.exports = ({ strapi }) => ({
         updatedEntry[field] = Array.isArray(value) ? processed : processed[0];
       } catch (err) {
         throw new Error(
-          `Failed processing field ${field} with value ${JSON.stringify(value)}: ${err.message}`
+          `Error resolving field "${field}" with value "${value}": ${err.message}`
         );
       }
     }
@@ -394,76 +393,74 @@ module.exports = ({ strapi }) => ({
 
   async importEntries(entries, contentType, eventId) {
     const results = { created: 0, updated: 0, errors: [] };
-
-    await strapi.db.transaction(async ({ trx, rollback, onRollback }) => {
-      onRollback(() => {
-        strapi.log.error("Transaction rolled back due to an error!");
-        strapi.log.error(results.errors);
-      });
-
+  
+    await strapi.db.transaction(async ({ trx }) => {
+      let event = null;
+  
+      if (eventId) {
+        event = await strapi.documents("api::event.event").findFirst(
+          { filters: { documentId: eventId } },
+          { transaction: trx }
+        );
+      }
+  
+      let shouldRollback = false;
+  
       for (let i = 0; i < entries.length; i++) {
         const entry = entries[i];
         let existing = null;
-
+  
         try {
           let { id, ...data } = entry;
-
-          // Check if document exists
-          if (id && id !== "null" && id !== "undefined") {
+  
+          if (id) {
             existing = await strapi.documents(contentType).findFirst(
-              {
-                filters: { id },
-                populate: "*",
-              },
+              { filters: { id }, populate: "*" },
               { transaction: trx }
             );
-            if (!existing) {
-              throw new Error(`Document with id ${id} not found`);
-            }
+            if (!existing) throw new Error(`Document with id ${id} not found`);
           }
 
-          // Handle relations & components
-          data = await this.handleRelations(data, contentType, eventId);
+          if (event && !data.event) data.event = event.name;
+
+          data = await this.handleRelations(data, contentType);
           data = await this.handleComponents(data, existing, contentType);
+
           const sanitizeErrors = [];
           data = this.sanitizeEntryBeforeWrite(data, contentType, '', sanitizeErrors);
-
           if (sanitizeErrors.length) {
-            throw new Error(`Data validation failed:\n${sanitizeErrors.join('\n')}`);
+            throw new Error(sanitizeErrors.join('\n'));
           }
 
-          // Update
           if (existing) {
             await strapi.documents(contentType).update(
-              {
-                documentId: existing.documentId,
-                data,
-              },
+              { documentId: existing.documentId, data },
               { transaction: trx }
             );
             results.updated++;
           } else {
-          // Create
-            await strapi
-              .documents(contentType)
-              .create({ data }, { transaction: trx });
+            await strapi.documents(contentType).create(
+              { data },
+              { transaction: trx }
+            );
             results.created++;
           }
         } catch (err) {
-          results.errors.push(
-            `Failed ${existing ? "updating" : "creating"} on row ${
-              i + 2
-            }: ${err.message}`
-          );
-          results.created = 0;
-          results.updated = 0;
-
-          // IMPORTANT: force rollback
-          throw err;
+          shouldRollback = true;
+          results.errors.push(`Row ${i + 2}: ${err.message}`);
         }
       }
+
+      if (shouldRollback) {
+        await trx.rollback();
+      }
     });
 
+    if (results.errors.length) {
+      results.created = 0;
+      results.updated = 0;
+    }
+
     return results;
   },
 });