@nkhang1902/strapi-plugin-export-import-clsx 1.1.16 → 1.1.18

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

@@ -95,6 +95,46 @@ const ExportImportButtons = (props) => {
     return filters;
   };
 
+  function showLongNotification(toggle, {
+    title,
+    message,
+    type = 'warning',
+    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)`;
+    }
+
+    toggle({
+      type,
+      title,
+      message: (
+        <div
+          style={{
+            maxHeight: 260,
+            overflowY: 'auto',
+            whiteSpace: 'pre-wrap',
+            fontSize: 13,
+            lineHeight: 1.5,
+            paddingRight: 4,
+          }}
+        >
+          {displayText}
+        </div>
+      ),
+      timeout: duration,
+    });
+  }
+
   const handleExport = async () => {
     const contentType = getContentType();
     if (!contentType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nkhang1902/strapi-plugin-export-import-clsx",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "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,7 @@ module.exports = ({ strapi }) => ({
         .plugin("export-import-clsx")
         .service("import-service");
 
-      const { eventId } = ctx.request.query;
+      let { eventId } = ctx.request.query;
       if (eventId == "") {
         eventId = null;
       }

package/server/services/import-service.js

@@ -147,7 +147,7 @@ module.exports = ({ strapi }) => ({
       .map(([fieldName, attr]) => toCamel(fieldName));
   },
 
-  async handleRelations(entry, contentType, row) {
+  async handleRelations(entry, contentType) {
     const resolveRelationValue = async (field, value, target) => {
       const targetAttr = strapi.contentTypes[target].attributes;
       for (const field of SHORTCUT_FIELDS) {
@@ -390,78 +390,74 @@ module.exports = ({ strapi }) => ({
 
   async importEntries(entries, contentType, eventId) {
     const results = { created: 0, updated: 0, errors: [] };
-    const event = eventId ? strapi.documents("api::event.event").findFirst({
-      filters: { documentId: eventId },
-    }) : null;
-
-    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`);
           }
-          data["event"] = event ? event.name : "";
 
-          // Handle relations & components
-          data = await this.handleRelations(data, contentType, row, eventName);
+          if (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(
-            `Row ${i + 2}: ${err.message || err.toString()}`
-          );
-          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;
   },
 });