apostrophe 3.7.0 → 3.8.0

package/modules/@apostrophecms/notification/ui/apos/components/AposNotification.vue

@@ -15,27 +15,34 @@
       <button
         v-for="(button, i) in notification.buttons"
         :key="i"
-        :data-apos-bus-event="JSON.stringify({ name: button.name, data: button.data })"
+        :data-apos-bus-event="JSON.stringify({
+          name: button.name,
+          data: button.data
+        })"
       >
         {{ localize(button.label) }}
       </button>
     </span>
     <div
       class="apos-notification__progress"
-      v-if="notification.progress && notification.progress.current"
+      v-if="job && job.total"
     >
       <div class="apos-notification__progress-bar">
         <div
           class="apos-notification__progress-now" role="progressbar"
-          :aria-valuenow="notification.progress.current" :style="`width: ${progressPercent}`"
-          aria-valuemin="0" :aria-valuemax="100"
+          :aria-valuenow="job.processed || 0"
+          :style="`width: ${job.percentage + '%'}`"
+          aria-valuemin="0" :aria-valuemax="job.total"
         />
       </div>
       <span class="apos-notification__progress-value">
-        {{ progressPercent }}
+        {{ Math.floor(job.percentage) + '%' }}
       </span>
     </div>
-    <button @click="close" class="apos-notification__button">
+    <button
+      v-if="!job"
+      @click="close" class="apos-notification__button"
+    >
       <Close
         class="apos-notification__close-icon"
         title="Close Notification"
@@ -58,6 +65,16 @@ export default {
     }
   },
   emits: [ 'close' ],
+  data () {
+    return {
+      job: this.notification.job && this.notification.job._id ? {
+        route: `${apos.modules['@apostrophecms/job'].action}/${this.notification.job._id}`,
+        processed: 0,
+        total: 1,
+        action: this.notification.job.action
+      } : null
+    };
+  },
   computed: {
     classList() {
       const classes = [ 'apos-notification' ];
@@ -65,7 +82,7 @@ export default {
         classes.push(`apos-notification--${this.notification.type}`);
       }
 
-      if (this.notification.progress && this.notification.progress.notification.current) {
+      if (this.job) {
         classes.push('apos-notification--progress');
       }
 
@@ -86,9 +103,6 @@ export default {
       } else {
         return 'circle-icon';
       }
-    },
-    progressPercent () {
-      return `${Math.floor((this.notification.progress.current / 100) * 100)}%`;
     }
   },
   async mounted() {
@@ -102,6 +116,40 @@ export default {
         this.close();
       }
     });
+
+    if (this.job) {
+      try {
+        const {
+          total,
+          processed,
+          percentage
+        } = await apos.http.get(this.job.route, {});
+
+        this.job.total = total;
+        this.job.processed = processed || 0;
+        this.job.percentage = percentage;
+        this.job.ids = this.notification.job.ids || [];
+
+        await this.pollJob();
+      } catch (error) {
+        console.error('Unable to find notification job:', this.notification.job._id);
+        this.job = null;
+      }
+    }
+    // Notifications may include events to emit.
+    if (this.notification.event?.name) {
+      try {
+        // Clear the event to make sure it's only emitted once across browsers.
+        const safe = await this.clearEvent(this.notification._id);
+
+        if (safe) {
+          // The notification doc will only still have the event in one instance.
+          apos.bus.$emit(this.notification.event.name, this.notification.event.data);
+        }
+      } catch (error) {
+        console.error(this.$t('apostrophe:notificationClearEventError'));
+      }
+    }
   },
   methods: {
     close() {
@@ -116,6 +164,36 @@ export default {
         result = s;
       }
       return result;
+    },
+    async pollJob () {
+      if (!this.job?.total) {
+        return;
+      }
+      const job = await apos.http.get(this.job.route, {});
+      this.job.processed = job.processed;
+      this.job.percentage = job.percentage;
+
+      if (this.job.processed < this.job.total) {
+        await new Promise(resolve => {
+          setTimeout(resolve, 500);
+        });
+
+        await this.pollJob();
+      } else {
+        if (this.job.ids) {
+          apos.bus.$emit('content-changed', {
+            docIds: this.job.ids,
+            action: this.job.action || 'batch-update'
+          });
+        }
+      }
+    },
+    // `clearEvent` returns true if the event was found and cleared. Otherwise
+    // returns `false`
+    async clearEvent(id) {
+      return await apos.http.post(`${apos.notification.action}/${id}/clear-event`, {
+        body: {}
+      });
     }
   }
 };
@@ -228,7 +306,7 @@ export default {
     height: 100%;
     background-color: var(--a-brand-green);
     background-image: linear-gradient(46deg, var(--a-brand-gold) 0%, var(--a-brand-red) 26%, var(--a-brand-magenta) 47%, var(--a-brand-blue) 76%, var(--a-brand-green) 100%);
-    transition: width 0.2s ease-out;
+    transition: width 0.5s ease-out;
   }
 
   .apos-notification__progress-value {

package/modules/@apostrophecms/notification/ui/apos/components/TheAposNotifications.vue

@@ -25,7 +25,7 @@ export default {
     };
   },
   async mounted() {
-    apos.notify = async function(message, options) {
+    apos.notify = async function(message, options = {}) {
 
       if (options.dismiss === true) {
         options.dismiss = 5;

package/modules/@apostrophecms/page/index.js

@@ -1996,35 +1996,38 @@ database.`);
       //
       // To avoid RAM issues with very large selections, the current
       // implementation processes the pages in series.
-      async batchSimpleRoute(req, name, change) {
-        const batchOperation = _.find(self.options.batchOperations, { name: name });
-        const schema = batchOperation.schema || [];
-        const data = self.apos.schema.newInstance(schema);
-        await self.apos.schema.convert(req, schema, 'form', req.body, data);
-        let ids = self.apos.launder.ids(req.body.ids);
-        if (!ids) {
-          if (req.body._id) {
-            ids = self.apos.launder.id(req.body._id);
-          }
-        }
-        if (req.body.job) {
-          return runJob();
-        } else {
-          for (const id of ids) {
-            await one(req, id);
-          }
-        }
-        async function runJob() {
-          return self.apos.modules['@apostrophecms/job'].run(req, ids, one, { labels: { title: batchOperation.progressLabel || batchOperation.buttonLabel || batchOperation.label } });
-        }
-        async function one(req, id) {
-          const page = await self.findForBatch(req, { _id: id }).toObject();
-          if (!page) {
-            throw new Error('notfound');
-          }
-          await change(req, page, data);
-        }
-      },
+      // TODO: restore this method when fully implemented.
+      // async batchSimpleRoute(req, name, change) {
+      //   const batchOperation = _.find(self.options.batchOperations, { name: name });
+      //   const schema = batchOperation.schema || [];
+      //   const data = self.apos.schema.newInstance(schema);
+      //   await self.apos.schema.convert(req, schema, 'form', req.body, data);
+      //   let ids = self.apos.launder.ids(req.body.ids);
+      //   if (!ids) {
+      //     if (req.body._id) {
+      //       ids = self.apos.launder.id(req.body._id);
+      //     }
+      //   }
+      //   if (req.body.job) {
+      //     return runJob();
+      //   } else {
+      //     for (const id of ids) {
+      //       await one(req, id);
+      //     }
+      //   }
+      //   async function runJob() {
+      //     return self.apos.modules['@apostrophecms/job'].runBatch(req, ids, one, {
+      //       // TODO: Update with new progress notification config
+      //     });
+      //   }
+      //   async function one(req, id) {
+      //     const page = await self.findForBatch(req, { _id: id }).toObject();
+      //     if (!page) {
+      //       throw new Error('notfound');
+      //     }
+      //     await change(req, page, data);
+      //   }
+      // },
       // Backward compatible method following moving this to page-type module.
       // This page module method may be deprecated in the next major version.
       allowedSchema(req, page, parentPage) {
@@ -2032,7 +2035,11 @@ database.`);
           .allowedSchema(req, page, parentPage);
       },
       getRestQuery(req) {
-        const query = self.find(req).ancestors(true).children(true).applyBuildersSafely(req.query);
+        const query = self.find(req)
+          .ancestors(true)
+          .children(true)
+          .attachments(true)
+          .applyBuildersSafely(req.query);
         // Minimum standard for a REST query without a public projection
         // is being allowed to view drafts on the site
         if (!self.apos.permission.can(req, 'view-draft')) {

package/modules/@apostrophecms/piece-type/index.js

@@ -2,7 +2,12 @@ const _ = require('lodash');
 
 module.exports = {
   extend: '@apostrophecms/doc-type',
-  cascades: [ 'filters', 'columns', 'batchOperations' ],
+  cascades: [
+    'filters',
+    'columns',
+    'batchOperations',
+    'utilityOperations'
+  ],
   options: {
     perPage: 10,
     quickCreate: true,
@@ -74,7 +79,7 @@ module.exports = {
         ],
         // TODO: Delete `allowedInChooser` if not used.
         allowedInChooser: false,
-        def: true
+        def: null
       },
       archived: {
         label: 'apostrophe:archive',
@@ -96,44 +101,47 @@ module.exports = {
       }
     }
   },
+  utilityOperations: {},
   batchOperations: {
     add: {
       archive: {
         label: 'apostrophe:archive',
-        inputType: 'radio',
-        unlessFilter: {
-          archived: true
+        messages: {
+          progress: 'Archiving {{ type }}...',
+          completed: 'Archived {{ count }} {{ type }}.'
+        },
+        icon: 'archive-arrow-down-icon',
+        if: {
+          archived: false
+        },
+        modalOptions: {
+          title: 'apostrophe:archiveType',
+          description: 'apostrophe:archivingBatchConfirmation',
+          confirmationButton: 'apostrophe:archivingBatchConfirmationButton'
         }
       },
       restore: {
         label: 'apostrophe:restore',
-        unlessFilter: {
-          archived: false
-        }
-      },
-      visibility: {
-        label: 'apostrophe:visibility',
-        requiredField: 'visibility',
-        fields: {
-          add: {
-            visibility: {
-              type: 'select',
-              label: 'apostrophe:visibilityLabel',
-              def: 'public',
-              choices: [
-                {
-                  value: 'public',
-                  label: 'apostrophe:public'
-                },
-                {
-                  value: 'loginRequired',
-                  label: 'apostrophe:loginRequired'
-                }
-              ]
-            }
-          }
+        messages: {
+          progress: 'Restoring {{ type }}...',
+          completed: 'Restoring {{ count }} {{ type }}.'
+        },
+        icon: 'archive-arrow-up-icon',
+        if: {
+          archived: true
+        },
+        modalOptions: {
+          title: 'apostrophe:restoreType',
+          description: 'apostrophe:restoreBatchConfirmation',
+          confirmationButton: 'apostrophe:restoreBatchConfirmationButton'
         }
       }
+    },
+    group: {
+      more: {
+        icon: 'dots-vertical-icon',
+        operations: []
+      }
     }
   },
   init(self) {
@@ -179,7 +187,6 @@ module.exports = {
       if (self.apos.launder.boolean(req.query['render-areas']) === true) {
         await self.apos.area.renderDocsAreas(req, result.results);
       }
-      self.apos.attachment.all(result.results, { annotate: true });
       if (query.get('choicesResults')) {
         result.choices = query.get('choicesResults');
       }
@@ -259,6 +266,58 @@ module.exports = {
           }
           return self.publish(req, draft);
         },
+        async archive (req) {
+          if (!Array.isArray(req.body._ids)) {
+            throw self.apos.error('invalid');
+          }
+
+          req.body._ids = req.body._ids.map(_id => {
+            return self.inferIdLocaleAndMode(req, _id);
+          });
+
+          return self.apos.modules['@apostrophecms/job'].runBatch(
+            req,
+            req.body._ids,
+            async function(req, id) {
+              const piece = await self.findOneForEditing(req, { _id: id });
+
+              if (!piece) {
+                throw self.apos.error('notfound');
+              }
+
+              piece.archived = true;
+              await self.update(req, piece);
+            }, {
+              action: 'archive'
+            }
+          );
+        },
+        async restore (req) {
+          if (!Array.isArray(req.body._ids)) {
+            throw self.apos.error('invalid');
+          }
+
+          req.body._ids = req.body._ids.map(_id => {
+            return self.inferIdLocaleAndMode(req, _id);
+          });
+
+          return self.apos.modules['@apostrophecms/job'].runBatch(
+            req,
+            req.body._ids,
+            async function(req, id) {
+              const piece = await self.findOneForEditing(req, { _id: id });
+
+              if (!piece) {
+                throw self.apos.error('notfound');
+              }
+
+              piece.archived = false;
+              await self.update(req, piece);
+            }, {
+              action: 'restore'
+            }
+          );
+        },
         ':_id/localize': async (req) => {
           const _id = self.inferIdLocaleAndMode(req, req.params._id);
           const draft = await self.findOneForEditing(req.clone({
@@ -388,20 +447,72 @@ module.exports = {
       },
       'apostrophe:modulesRegistered': {
         composeBatchOperations() {
-          self.batchOperations = Object.keys(self.batchOperations).map(key => ({
-            name: key,
-            ...self.batchOperations[key]
-          })).filter(batchOperation => {
-            if (batchOperation.requiredField && !_.find(self.schema, { name: batchOperation.requiredField })) {
-              return false;
-            }
-            if (batchOperation.onlyIf) {
-              if (!batchOperation.onlyIf(self.name)) {
-                return false;
+          const groupedOperations = Object.entries(self.batchOperations)
+            .reduce((acc, [ opName, properties ]) => {
+              // Check if there is a required schema field for this batch operation.
+              const requiredFieldNotFound = properties.requiredField && !self.schema
+                .some((field) => field.name === properties.requiredField);
+
+              if (requiredFieldNotFound) {
+                return acc;
               }
+              // Find a group for the operation, if there is one.
+              const associatedGroup = getAssociatedGroup(opName);
+              const currentOperation = {
+                action: opName,
+                ...properties
+              };
+              const { action, ...props } = getOperationOrGroup(
+                currentOperation,
+                associatedGroup,
+                acc
+              );
+
+              return {
+                ...acc,
+                [action]: {
+                  ...props
+                }
+              };
+            }, {});
+
+          self.batchOperations = Object.entries(groupedOperations)
+            .map(([ action, properties ]) => ({
+              action,
+              ...properties
+            }));
+
+          function getOperationOrGroup (currentOp, [ groupName, groupProperties ], acc) {
+            if (!groupName) {
+              // Operation is not grouped. Return it as it is.
+              return currentOp;
             }
-            return true;
-          });
+
+            // Return the operation group with the new operation added.
+            return {
+              name: groupName,
+              ...groupProperties,
+              operations: [
+                ...(acc[groupName] && acc[groupName].operations) || [],
+                currentOp
+              ]
+            };
+          }
+
+          // Returns the object entry, e.g., `[groupName, { ...groupProperties }]`
+          function getAssociatedGroup (operation) {
+            return Object.entries(self.batchOperationsGroups)
+              .find(([ _key, { operations } ]) => {
+                return operations.includes(operation);
+              }) || [];
+          }
+        },
+        composeUtilityOperations() {
+          self.utilityOperations = Object.entries(self.utilityOperations || {})
+            .map(([ action, properties ]) => ({
+              action,
+              ...properties
+            }));
         }
       }
     };
@@ -538,33 +649,37 @@ module.exports = {
       // Pass `req`, the `name` of a configured batch operation, and
       // and a function that accepts (req, piece, data),
       // and returns a promise to perform the modification on that
-      // one piece (including calling`update` if appropriate).
+      // one piece (including calling `update` if appropriate).
       //
       // `data` is an object containing any schema fields specified
       // for the batch operation. If there is no schema it will be
       // an empty object.
       //
-      // Replies immediately to the request with `{ jobId: 'cxxxx' }`.
+      // Replies immediately to the request with `{ jobId: 'xxxxx' }`.
       // This can then be passed to appropriate browser-side APIs
       // to monitor progress.
       //
       // To avoid RAM issues with very large selections while ensuring
       // that all lifecycle events are fired correctly, the current
       // implementation processes the pieces in series.
-      async batchSimpleRoute(req, name, change) {
-        const batchOperation = _.find(self.batchOperations, { name: name });
-        const schema = batchOperation.schema || [];
-        const data = self.apos.schema.newInstance(schema);
-        await self.apos.schema.convert(req, schema, req.body, data);
-        await self.apos.modules['@apostrophecms/job'].run(req, one, { labels: { title: batchOperation.progressLabel || batchOperation.buttonLabel || batchOperation.label } });
-        async function one(req, id) {
-          const piece = self.findForEditing(req, { _id: id }).toObject();
-          if (!piece) {
-            throw self.apos.error('notfound');
-          }
-          await change(req, piece, data);
-        }
-      },
+      // TODO: restore this method when fully implemented.
+      // async batchSimpleRoute(req, name, change) {
+      //   const batchOperation = _.find(self.batchOperations, { name: name });
+      //   const schema = batchOperation.schema || [];
+      //   const data = self.apos.schema.newInstance(schema);
+
+      //   await self.apos.schema.convert(req, schema, req.body, data);
+      //   await self.apos.modules['@apostrophecms/job'].runBatch(req, one, {
+      //     // TODO: Update with new progress notification config
+      //   });
+      //   async function one(req, id) {
+      //     const piece = self.findForEditing(req, { _id: id }).toObject();
+      //     if (!piece) {
+      //       throw self.apos.error('notfound');
+      //     }
+      //     await change(req, piece, data);
+      //   }
+      // },
 
       // Accept a piece as untrusted input potentially
       // found in `input` (hint: you can pass `req.body`
@@ -765,7 +880,7 @@ module.exports = {
         return piece;
       },
       getRestQuery(req) {
-        const query = self.find(req);
+        const query = self.find(req).attachments(true);
         query.applyBuildersSafely(req.query);
         if (!self.apos.permission.can(req, 'view-draft')) {
           if (!self.options.publicApiProjection) {
@@ -773,7 +888,7 @@ module.exports = {
             query.and({
               _id: null
             });
-          } else {
+          } else if (!query.state.project) {
             query.project(self.options.publicApiProjection);
           }
         }
@@ -812,6 +927,7 @@ module.exports = {
         browserOptions.filters = self.filters;
         browserOptions.columns = self.columns;
         browserOptions.batchOperations = self.batchOperations;
+        browserOptions.utilityOperations = self.utilityOperations;
         browserOptions.insertViaUpload = self.options.insertViaUpload;
         browserOptions.quickCreate = !self.options.singleton && self.options.quickCreate && self.apos.permission.can(req, 'edit', self.name, 'draft');
         browserOptions.singleton = self.options.singleton;
@@ -828,6 +944,7 @@ module.exports = {
           editorModal: 'AposDocEditor',
           managerModal: 'AposDocsManager'
         });
+
         return browserOptions;
       },
       find(_super, req, criteria, projection) {