Pro 6419 import pages

.gitignore

@@ -9,3 +9,10 @@ node_modules
 
 # vim swp files
 .*.sw*
+
+# Dont commit test generated css
+test/public/css/*.css
+test/public/css/master-*.less
+
+# Dont commit test uploads
+test/public/uploads

lib/methods/import-page.js

@@ -0,0 +1,94 @@
+const getTargetId = async ({
+  manager,
+  doc,
+  req,
+  duplicatedDocs = []
+}) => {
+  if (doc.archived) {
+    return '_archive';
+  }
+
+  const duplicatedDocsMapping = Object.fromEntries(
+    duplicatedDocs.map(duplicate => [ duplicate.aposDocId, duplicate.replaceId ])
+  );
+
+  const { path = '' } = doc;
+  const ancestorIds = path.split('/').reverse().slice(1);
+  for (const ancestorId of ancestorIds) {
+    try {
+      const { aposDocId } = await manager.getTarget(req, duplicatedDocsMapping[ancestorId] || ancestorId);
+
+      return aposDocId;
+    } catch (error) {
+      // continue search
+    }
+  }
+
+  return '_home';
+};
+
+const insert = async ({
+  manager,
+  doc,
+  req,
+  duplicatedDocs
+}) => {
+  const targetId = await getTargetId({
+    manager,
+    doc,
+    req,
+    duplicatedDocs
+  });
+  const position = 'lastChild';
+
+  return manager.insert(
+    req,
+    targetId,
+    position,
+    doc,
+    { setModified: false }
+  );
+};
+
+const update = async ({
+  manager,
+  doc,
+  req,
+  duplicatedDocs
+}) => {
+  const {
+    _id,
+    aposDocId,
+    path,
+    rank,
+    level,
+    ...patch
+  } = doc;
+
+  const move = doc.parkedId
+    ? {}
+    : {
+      _targetId: await getTargetId({
+        manager,
+        doc,
+        req,
+        duplicatedDocs
+      }),
+      _position: 'lastChild'
+    };
+
+  return manager.patch(
+    req.clone({
+      body: {
+        ...patch,
+        ...move
+      }
+    }),
+    _id
+  );
+};
+
+module.exports = {
+  insert,
+  update
+};

lib/methods/import.js

@@ -1,4 +1,5 @@
 const { cloneDeep } = require('lodash');
+const importPage = require('./import-page.js');
 
 module.exports = self => {
   return {
@@ -127,6 +128,7 @@
         docs,
         reporting,
         duplicatedIds,
+        duplicatedDocs,
         failedIds
       });
 
@@ -303,23 +305,33 @@
         // If the parked/singleton doc is not found, it should be processed as a
         // regular doc.
         if (isSingleton || parkedId) {
+          // TODO: what about singleton with localized = false, we don't have aposMode
+          // TODO: do I need that for parked page?
           if (aposMode !== 'draft' || !aposDocId) {
             continue;
           }
-          const singletonAposDocId = await self.findExistingSingletonId({
+        }
+        const replaceId = isSingleton
+          ? await self.findSingletonAposDocId({
             type,
             aposLocale
-          });
-          if (singletonAposDocId) {
-            replaceItems.push({
-              aposDocId,
-              title,
+          })
+          : parkedId
+            ? await self.findParkedAposDocId({
+              parkedId,
               type,
-              updatedAt,
-              replaceId: singletonAposDocId
-            });
-            continue;
-          }
+              aposLocale
+            })
+            : null;
+        if (replaceId) {
+          replaceItems.push({
+            aposDocId,
+            title,
+            type,
+            updatedAt,
+            replaceId
+          });
+          continue;
         }
         if (aposDocId && !docIds.includes(aposDocId)) {
           docIds.push(aposDocId);
@@ -366,7 +378,7 @@
     },
 
     async insertDocs(req, {
-      docs, reporting, duplicatedIds, failedIds
+      docs, reporting, duplicatedIds, duplicatedDocs, failedIds
     }) {
       for (const doc of docs) {
         if (duplicatedIds.has(doc.aposDocId) || failedIds.includes(doc.aposDocId)) {
@@ -382,7 +394,8 @@
             await self.insertOrUpdateDocWithKey(req, {
               doc,
               updateKey,
-              updateField
+              updateField,
+              duplicatedDocs
             });
             reporting.success();
           } catch (error) {
@@ -399,7 +412,8 @@
         try {
           const inserted = await self.insertOrUpdateDoc(req, {
             doc,
-            failedIds
+            failedIds,
+            duplicatedDocs
           });
           if (inserted) {
             reporting.success();
@@ -415,7 +429,8 @@
     async insertOrUpdateDocWithKey(req, {
       doc,
       updateKey,
-      updateField
+      updateField,
+      duplicatedDocs = []
     }) {
       const manager = self.apos.doc.getManager(doc.type);
       if (!self.canImport(req, doc.type)) {
@@ -470,11 +485,17 @@
         });
 
         if (self.isPage(manager)) {
+          // TODO: check if this is still true
           // `convert` sets the type to `@apostrophecms/home-page`,
           // let's set it back to the original type:
           docToInsert.type = type;
 
-          return self.apos.page.insert(_req, '_home', 'lastChild', docToInsert, { setModified: false });
+          return importPage.insert({
+            manager: self.apos.page,
+            doc: docToInsert,
+            req: _req,
+            duplicatedDocs
+          });
         }
 
         return manager.insert(_req, docToInsert, { setModified: false });
@@ -506,7 +527,14 @@
           const _req = req.clone({ mode: docToUpdate.aposMode });
 
           await manager.convert(_req, doc, docToUpdate, { presentFieldsOnly: true });
-          await manager.update(_req, docToUpdate);
+          self.isPage(manager)
+            ? await importPage.update({
+              manager: self.apos.page,
+              doc: docToUpdate,
+              req: _req,
+              duplicatedDocs
+            })
+            : await manager.update(_req, docToUpdate);
         }
 
         await self.setDocAsNotModified(matchingDraft);
@@ -561,7 +589,7 @@
     },
 
     async insertOrUpdateDoc(req, {
-      doc, method = 'insert', failedIds = [], existingAposDocId
+      doc, method = 'insert', failedIds = [], duplicatedDocs = [], existingAposDocId
     }) {
       const manager = self.apos.doc.getManager(doc.type);
       if (existingAposDocId) {
@@ -609,11 +637,17 @@
         });
 
         if (self.isPage(manager)) {
+          // TODO: check if this is still true
           // `convert` sets the type to `@apostrophecms/home-page`,
           // let's set it back to the original type:
           docToInsert.type = type;
 
-          return self.apos.page.insert(_req, '_home', 'lastChild', docToInsert, { setModified: false });
+          return importPage.insert({
+            manager: self.apos.page,
+            doc: docToInsert,
+            req: _req,
+            duplicatedDocs
+          });
         }
 
         return manager.insert(_req, docToInsert, { setModified: false });
@@ -628,10 +662,18 @@
           });
           if (existingDoc) {
             doc.lastPublishedAt = existingDoc.lastPublishedAt;
+
           }
         }
 
-        await manager.update(_req, doc);
+        self.isPage(manager)
+          ? await importPage.update({
+            manager: self.apos.page,
+            doc,
+            req: _req,
+            duplicatedDocs
+          })
+          : await manager.update(_req, doc);
 
         if (doc.aposMode === 'draft') {
           await self.setDocAsNotModified(doc);
@@ -646,7 +688,8 @@
     // `self.apos.page.isPage` does not work here since
     // the slug can be omitted in a CSV or Excel file.
     isPage(manager) {
-      return manager.__meta.chain.some(module => module.name === '@apostrophecms/page-type');
+      return self.apos.instanceOf(manager, '@apostrophecms/page-type') ||
+        self.apos.instanceOf(manager, '@apostrophecms/any-page-type');
     },
 
     // Manually set `modified: false` because `setModified`
@@ -704,15 +747,23 @@
     async overrideDuplicates(req) {
       const overrideLocale = self.apos.launder.boolean(req.body.overrideLocale);
       const exportPath = await self.getExportPathById(self.apos.launder.string(req.body.exportPathId));
-      const docIds = self.apos.launder.strings(req.body.docIds);
       // Import aposDocId/Existing aposDocId pairs
       const replaceAposDocIds = req.body.replaceDocIds?.map(arr => self.apos.launder.strings(arr)) ?? [];
+      const duplicatedDocs = req.body.duplicatedDocs?.map(duplicatedDoc => {
+        return {
+          aposDocId: self.apos.launder.string(duplicatedDoc.aposDocId),
+          title: self.apos.launder.string(duplicatedDoc.title),
+          type: self.apos.launder.string(duplicatedDoc.type),
+          updatedAt: self.apos.launder.date(duplicatedDoc.updatedAt)
+        };
+      }) ?? [];
       const jobId = self.apos.launder.string(req.body.jobId);
       const importedAttachments = self.apos.launder.strings(req.body.importedAttachments);
       const formatLabel = self.apos.launder.string(req.body.formatLabel);
       const failedIds = [];
       const replaceDocIdPairs = [];
 
+      const docIds = duplicatedDocs.map(duplicatedDoc => duplicatedDoc.aposDocId);
       const jobManager = self.apos.modules['@apostrophecms/job'];
       const job = await jobManager.db.findOne({ _id: jobId });
 
@@ -773,7 +824,8 @@
             doc,
             method: 'update',
             failedIds,
-            existingAposDocId: replaceAposDocId
+            existingAposDocId: replaceAposDocId,
+            duplicatedDocs
           });
 
           if (replaceAposDocId) {
@@ -849,7 +901,7 @@
     // make sure the singleton exists.
     // Singletons are parked pages (having parkedId property) and
     // pieces having option `singleton: true`.
-    async findExistingSingletonId({ type, aposLocale }) {
+    async findSingletonAposDocId({ type, aposLocale }) {
       const singleton = await self.apos.doc.db.findOne({
         $and: [
           { type },
@@ -870,6 +922,27 @@
 
       return null;
     },
+    async findParkedAposDocId({ parkedId, type, aposLocale }) {
+      const parked = await self.apos.doc.db.findOne({
+        $and: [
+          { parkedId, type },
+          {
+            $or: [
+              { aposLocale: { $exists: false } },
+              { aposLocale }
+            ]
+          }
+        ]
+      }, {
+        projection: { aposDocId: 1 }
+      });
+
+      if (parked && parked.aposDocId) {
+        return parked.aposDocId;
+      }
+
+      return null;
+    },
 
     // Replace ID fields of imported document with a new ID,
     // usually the ID of an existing document in the database.

package.json

@@ -18,14 +18,15 @@
   "author": "Apostrophe Technologies",
   "license": "UNLICENSED",
   "devDependencies": {
-    "apostrophe": "github:apostrophecms/apostrophe",
+    "apostrophe": "github:apostrophecms/apostrophe#pro-6425-batch-operation-page",
     "eslint": "^8.44.0",
     "eslint-config-apostrophe": "^4.2.0",
     "eslint-config-standard": "^17.1.0",
     "eslint-plugin-import": "^2.29.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^6.1.1",
     "eslint-plugin-vue": "^9.19.2",
+    "form-data": "^4.0.0",
     "mocha": "^10.2.0",
     "stylelint": "^16.0.0",
     "stylelint-config-apostrophe": "^4.1.0",