apostrophe 3.6.0 → 3.9.0

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,77 @@ 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
+            }));
+        }
+      },
+      '@apostrophecms/search:determineTypes': {
+        checkSearchable(types) {
+          self.searchDetermineTypes(types);
         }
       }
     };
@@ -538,33 +654,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 +885,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 +893,7 @@ module.exports = {
             query.and({
               _id: null
             });
-          } else {
+          } else if (!query.state.project) {
             query.project(self.options.publicApiProjection);
           }
         }
@@ -812,6 +932,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 +949,7 @@ module.exports = {
           editorModal: 'AposDocEditor',
           managerModal: 'AposDocsManager'
         });
+
         return browserOptions;
       },
       find(_super, req, criteria, projection) {

package/modules/@apostrophecms/piece-type/ui/apos/components/AposDocsManager.vue

@@ -19,10 +19,10 @@
     </template>
     <template #primaryControls>
       <AposContextMenu
-        v-if="moreMenu.menu.length"
-        :button="moreMenu.button"
-        :menu="moreMenu.menu"
-        @item-clicked="moreMenuHandler"
+        v-if="utilityOperations.menu.length"
+        :button="utilityOperations.button"
+        :menu="utilityOperations.menu"
+        @item-clicked="utilityOperationsHandler"
       />
       <AposButton
         v-if="relationshipField"
@@ -66,19 +66,33 @@
             :selected-state="selectAllState"
             :total-pages="totalPages"
             :current-page="currentPage"
-            :filters="moduleOptions.filters"
             :filter-choices="filterChoices"
             :filter-values="filterValues"
+            :filters="moduleOptions.filters"
             :labels="moduleLabels"
+            :displayed-items="items.length"
+            :is-relationship="!!relationshipField"
+            :checked-count="checked.length"
+            :batch-operations="moduleOptions.batchOperations"
             @select-click="selectAll"
             @search="search"
             @page-change="updatePage"
             @filter="filter"
+            @batch="handleBatchAction"
             :options="{
-              disableUnchecked: maxReached(),
-              hideSelectAll: !relationshipField
+              disableUnchecked: maxReached()
             }"
           />
+          <AposDocsManagerSelectBox
+            :selected-state="selectAllState"
+            :module-labels="moduleLabels"
+            :filter-values="filterValues"
+            :checked-ids="checked"
+            :all-pieces-selection="allPiecesSelection"
+            :displayed-items="items.length"
+            @select-all="selectAllPieces"
+            @set-all-pieces-selection="setAllPiecesSelection"
+          />
         </template>
         <template #bodyMain>
           <AposDocsManagerDisplay
@@ -90,7 +104,6 @@
             :options="{
               ...moduleOptions,
               disableUnchecked: maxReached(),
-              hideCheckboxes: !relationshipField,
               disableUnpublished: disableUnpublished,
               manuallyPublished: manuallyPublished
             }"
@@ -136,7 +149,7 @@ export default {
       filterValues: {},
       queryExtras: {},
       holdQueries: false,
-      moreMenu: {
+      utilityOperations: {
         button: {
           label: 'apostrophe:moreOperations',
           iconOnly: true,
@@ -145,7 +158,11 @@ export default {
         },
         menu: []
       },
-      filterChoices: {}
+      filterChoices: {},
+      allPiecesSelection: {
+        isSelected: false,
+        total: 0
+      }
     };
   },
   computed: {
@@ -190,6 +207,16 @@ export default {
     },
     disableUnpublished() {
       return this.relationshipField && apos.modules[this.relationshipField.withType].localized;
+    },
+    selectAllChoice() {
+      const checkCount = this.checked.length;
+      const pageNotFullyChecked = this.items
+        .some((item) => !this.checked.includes(item._id));
+
+      return {
+        value: 'checked',
+        indeterminate: checkCount && pageNotFullyChecked
+      };
     }
   },
   created() {
@@ -206,17 +233,10 @@ export default {
     this.headers = this.computeHeaders();
     // Get the data. This will be more complex in actuality.
     this.modal.active = true;
-    this.getPieces();
-    if (this.relationshipField && this.moduleOptions.canEdit) {
-      // Add computed singular label to context menu
-      this.moreMenu.menu.unshift({
-        action: 'new',
-        label: {
-          key: 'apostrophe:newDocType',
-          type: this.$t(this.moduleLabels.singular)
-        }
-      });
-    }
+    this.setUtilityOperations();
+    await this.getPieces();
+    await this.getAllPiecesTotal();
+
     apos.bus.$on('content-changed', this.getPieces);
   },
   destroyed() {
@@ -224,10 +244,13 @@ export default {
     apos.bus.$off('content-changed', this.getPieces);
   },
   methods: {
-    moreMenuHandler(action) {
+    utilityOperationsHandler(action) {
       if (action === 'new') {
         this.create();
+        return;
       }
+
+      this.handleUtilityOperation(action);
     },
     setCheckedDocs(checked) {
       this.checkedDocs = checked;
@@ -238,6 +261,29 @@ export default {
     async create() {
       await this.edit(null);
     },
+    async handleUtilityOperation(action) {
+      const operation = this.utilityOperations.menu
+        .find((op) => op.action === action);
+
+      if (!operation) {
+        return;
+      }
+
+      const {
+        modal, ...modalOptions
+      } = operation.modalOptions || {};
+
+      if (modal) {
+        await apos.modal.execute(modal, {
+          moduleAction: this.moduleOptions.action,
+          action,
+          labels: this.moduleLabels,
+          messages: operation.messages,
+          ...modalOptions
+        });
+      }
+    },
+
     // If pieceOrId is null, a new piece is created
     async edit(pieceOrId) {
       let piece;
@@ -271,42 +317,68 @@ export default {
     async finishSaved() {
       await this.getPieces();
     },
-    async getPieces () {
-      if (this.holdQueries) {
-        return;
-      }
-
-      this.holdQueries = true;
-
-      const qs = {
+    async request (mergeOptions) {
+      const options = {
         ...this.filterValues,
-        page: this.currentPage,
         ...this.queryExtras,
-        // Also fetch published docs as _publishedDoc subproperties
+        ...mergeOptions,
         withPublished: 1
       };
 
       // Avoid undefined properties.
-      for (const prop in qs) {
-        if (qs[prop] === undefined) {
-          delete qs[prop];
-        };
+      const qs = Object.entries(options)
+        .reduce((acc, [ key, val ]) => ({
+          ...acc,
+          ...val !== undefined && { [key]: val }
+        }), {});
+
+      return apos.http.get(this.moduleOptions.action, {
+        qs,
+        busy: true,
+        draft: true
+      });
+    },
+    async getPieces () {
+      if (this.holdQueries) {
+        return;
       }
 
-      const getResponse = await apos.http.get(
-        this.moduleOptions.action, {
-          busy: true,
-          qs,
-          draft: true
-        }
-      );
+      this.holdQueries = true;
 
-      this.currentPage = getResponse.currentPage;
-      this.totalPages = getResponse.pages;
-      this.items = getResponse.results;
-      this.filterChoices = getResponse.choices;
+      const {
+        currentPage, pages, results, choices
+      } = await this.request({
+        page: this.currentPage
+      });
+
+      this.currentPage = currentPage;
+      this.totalPages = pages;
+      this.items = results;
+      this.filterChoices = choices;
       this.holdQueries = false;
     },
+    async getAllPiecesTotal () {
+      const { count: total } = await this.request({ count: 1 });
+
+      this.setAllPiecesSelection({
+        isSelected: false,
+        total
+      });
+    },
+    async selectAllPieces () {
+      const { results: docs } = await this.request({
+        project: {
+          _id: 1
+        },
+        attachments: false,
+        perPage: this.allPiecesSelection.total
+      });
+
+      this.setAllPiecesSelection({
+        isSelected: true,
+        docs
+      });
+    },
     updatePage(num) {
       if (num) {
         this.currentPage = num;
@@ -325,6 +397,7 @@ export default {
       this.currentPage = 1;
 
       await this.getPieces();
+      await this.getAllPiecesTotal();
     },
     async filter(filter, value) {
       if (this.filterValues[filter] === value) {
@@ -334,10 +407,12 @@ export default {
       this.filterValues[filter] = value;
       this.currentPage = 1;
 
-      this.getPieces();
+      await this.getPieces();
+      await this.getAllPiecesTotal();
       this.headers = this.computeHeaders();
-    },
 
+      this.setCheckedDocs([]);
+    },
     shortcutNew(event) {
       const interesting = (event.keyCode === 78 || event.keyCode === 67); // C(reate) or N(ew)
       const topModal = apos.modal.stack[apos.modal.stack.length - 1] ? apos.modal.stack[apos.modal.stack.length - 1].id : null;
@@ -349,7 +424,6 @@ export default {
         this.create();
       }
     },
-
     bindShortcuts() {
       window.addEventListener('keydown', this.shortcutNew);
     },
@@ -376,6 +450,62 @@ export default {
           _fields: result
         });
       }
+    },
+    setAllPiecesSelection ({
+      isSelected, total, docs
+    }) {
+      if (typeof isSelected === 'boolean') {
+        this.allPiecesSelection.isSelected = isSelected;
+      }
+
+      if (typeof total === 'number') {
+        this.allPiecesSelection.total = total;
+      }
+
+      if (docs) {
+        this.setCheckedDocs(docs);
+      }
+    },
+    async handleBatchAction({
+      label, action, requestOptions = {}, messages
+    }) {
+      if (action) {
+        try {
+          await apos.http.post(`${this.moduleOptions.action}/${action}`, {
+            body: {
+              ...requestOptions,
+              _ids: this.checked,
+              messages: messages,
+              type: this.checked.length === 1 ? this.moduleLabels.singular
+                : this.moduleLabels.plural
+            }
+          });
+        } catch (error) {
+          apos.notify('apostrophe:errorBatchOperationNoti', {
+            interpolate: { operation: label },
+            type: 'danger'
+          });
+          console.error(error);
+        }
+      }
+    },
+    setUtilityOperations () {
+      const { utilityOperations } = this.moduleOptions;
+
+      const newPiece = {
+        action: 'new',
+        label: {
+          key: 'apostrophe:newDocType',
+          type: this.$t(this.moduleLabels.singular)
+        }
+      };
+
+      this.utilityOperations.menu = [
+        ...this.relationshipField && this.moduleOptions.canEdit
+          ? [ newPiece ] : [],
+        ...this.utilityOperations.menu,
+        ...(!this.relationshipField && Array.isArray(utilityOperations) && utilityOperations) || []
+      ];
     }
   }
 };