apostrophe 3.5.0 → 3.8.1

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

@@ -1,22 +1,21 @@
-const _ = require('lodash');
+const { stripIndent } = require('common-tags');
 // The `@apostrophecms/job` module runs long-running jobs in response
 // to user actions. Batch operations on pieces are a good example.
 //
 // The `@apostrophecms/job` module makes it simple to implement
-// progress display, avoid server timeouts during long operations,
-// and implement a "stop" button.
+// progress display, and avoid server timeouts during long operations.
 //
 // See the `run` method for the easiest way to use this module.
 // The `run` method allows you to implement routes that are designed
 // to be paired with the `progress` method of this module on
 // the browser side. All you need to do is make sure the
-// ids are posted to your route and then write a function that
+// IDs are posted to your route and then write a function that
 // can carry out the operation on one id.
 //
 // If you just want to add a new batch operation for pieces,
-// see the examples already in `@apostrophecms/piece-type` and those added
-// by the `@apostrophecms/workflow` module. You don't need to go
-// directly to this module for that case.
+// see the examples already in `@apostrophecms/piece-type` (e.g.,
+// `batchSimpleRoute`). You don't need to go directly to this module for that
+// case.
 //
 // If your operation doesn't break down neatly into repeated operations
 // on single documents, look into calling the `start` method and friends
@@ -27,44 +26,55 @@ const _ = require('lodash');
 
 module.exports = {
   options: { collectionName: 'aposJobs' },
+  icons: {
+    'database-export-icon': 'DatabaseExport'
+  },
   async init(self) {
     await self.ensureCollection();
+
+    self.enableBrowserData();
   },
-  // TODO RESTify these
   apiRoutes(self) {
     return {
       post: {
-        async cancel(req) {
-          const _id = self.apos.launder.id(req.body._id);
-          const count = await self.db.updateOne({ _id: _id }, { $set: { canceling: true } });
-          if (!count) {
-            throw self.apos.error('notfound');
-          }
-        },
         async progress(req) {
-          const _id = self.apos.launder.id(req.body._id);
-          const job = await self.db.findOne({ _id: _id });
-          if (!job) {
-            throw self.apos.error('notfound');
-          }
-          // % of completion rounded off to 2 decimal places
-          if (!job.total) {
-            job.percentage = 0;
-          } else {
-            job.percentage = (job.processed / job.total * 100).toFixed(2);
-          }
-          return job;
+          self.apos.util.warnDev(stripIndent`
+            The @apostrophecms/job module's "/progress" route is deprecated.
+            Use the RESTful registered "action" route on the module instead.
+          `);
+
+          return {};
         }
       }
     };
   },
+  restApiRoutes (self) {
+    return {
+      async getOne(req, _id) {
+        if (!self.apos.permission.can(req, 'view-draft')) {
+          throw self.apos.error('notfound');
+        }
+
+        const jobId = self.apos.launder.id(_id);
+        const job = await self.db.findOne({ _id: jobId });
+
+        if (!job) {
+          throw self.apos.error('notfound');
+        }
+
+        job.percentage = !job.total ? 0 : (job.processed / job.total * 100).toFixed(2);
+
+        return job;
+      }
+    };
+  },
   methods(self) {
     return {
       // Starts and supervises a long-running job such as a
       // batch operation on pieces. Call it to implement an API route
       // that runs a job involving carrying out the same action
       // repetitively on many things. If your job doesn't look like
-      // that, check out `runNonBatch` instead.
+      // that, check out `run` instead.
       //
       // The `ids` to be processed should be provided via `req.body.ids`.
       //
@@ -73,9 +83,10 @@ module.exports = {
       // necessary; this is recorded as a bad item in the job, it does
       // not stop the job. `change` may optionally return a result object.
       //
-      // Returns an object with `{ jobId: 'cxxxx' }` before the work actually
-      // begins. This can then be used for progress monitoring via the
-      // ApostropheJobMonitor Vue component.
+      // This method will return an object with a `jobId` identifier as soon as
+      // the job is ready to start, and the actual job will continue in the
+      // background afterwards. You can pass `jobId` to the `progress` API route
+      // of this module as `_id` on the request body to get job status info.
       //
       // The actual work continues in background after this method returns.
       //
@@ -86,122 +97,117 @@ module.exports = {
       // simpler wrapper for this method if you are implementing a batch operation
       // on a single type of piece.
       //
-      // *Options*
-      //
-      // `options.label` should be passed as an object with
-      // a `title` property, to title the progress modal.
-      // A default is provided but it is not very informative.
-      //
-      // In addition, it may have `failed`, `completed` and
-      // `running` properties to label the progress modal when the job
-      // is in those states, and `good` and `bad` properties to label
-      // the count of items that were successful or had errors.
-      // All of these properties are optional and reasonable
-      // defaults are supplied.
-      async run(req, ids, change, options) {
+      // Notification messages should be included on a `req.body.messages` object. See `triggerNotification for details`.
+      async runBatch(req, ids, change, options = {}) {
         let job;
-        let stopping = false;
+        let notification;
+        const total = ids.length;
+
         const results = {};
         const res = req.res;
         try {
           // sends a response with a jobId to the browser
-          const job = await startJob();
+          job = await self.start(options);
+
+          self.setTotal(job, ids.length);
           // Runs after response is already sent
           run();
-          return job;
+
+          // Trigger the "in progress" notification.
+          notification = await self.triggerNotification(req, 'progress', {
+            // It's only relevant to pass a job ID to the notification if
+            // the notification will show progress. Without a total number we
+            // can't show progress.
+            jobId: total && job._id,
+            ids,
+            action: options.action
+          });
+
+          return {
+            jobId: job._id
+          };
         } catch (err) {
           self.apos.util.error(err);
           if (!job) {
             return res.status(500).send('error');
           }
           try {
-            await self.end(job, false);
+            return await self.end(job, false);
           } catch (err) {
             // Not a lot we can do about this since we already
             // stopped talking to the user
             self.apos.util.error(err);
           }
         }
-        async function startJob() {
-          job = await self.start(_.assign({}, options, {
-            stop: function (job) {
-              stopping = true;
-            }
-          }));
-          self.setTotal(job, ids.length);
-          return { jobId: job._id };
-        }
         async function run() {
           let good = false;
           try {
             for (const id of ids) {
-              if (stopping) {
-                return;
-              }
               try {
                 const result = await change(req, id);
-                self.good(job);
+                self.success(job);
                 results[id] = result;
               } catch (err) {
-                self.bad(job);
+                self.failure(job);
               }
             }
             good = true;
           } finally {
             await self.end(job, good, results);
+            // Trigger the completed notification.
+            await self.triggerNotification(req, 'completed', {
+              dismiss: true
+            });
+            // Dismiss the progress notification. It will delay 4 seconds
+            // because "completed" notification will dismiss in 5 and we want
+            // to maintain the feeling of process order for users.
+            await self.apos.notification.dismiss(req, notification.noteId, 4000);
           }
         }
       },
-      // Similar to `run`, this method Starts and supervises a long-running job,
-      // however unlike `run` the `doTheWork` function provided is invoked just
+      // Similar to `runBatch`, this method Starts and supervises a long-running job,
+      // however unlike `runBatch` the `doTheWork` function provided is invoked just
       // once, and when it completes the job is over. This is not the way to
       // implement a batch operation on pieces; see the `batchSimple` method
       // of that module.
       //
       // The `doTheWork` function receives `(req, reporting)` and may optionally invoke
-      // `reporting.good()` and `reporting.bad()` to update the progress and error
+      // `reporting.success()` and `reporting.failure()` to update the progress and error
       // counters, and `reporting.setTotal()` to indicate the total number of
-      // counts expected so a progress meter can be rendered. This is optional and
-      // an indication of progress is still displayed without it.
-      // `reporting.setResults(object)` may also be called to pass a
-      // `results` object, which is displayed as a table by the
-      // `ApostropheJobMonitor` Vue component on the browser side.
-      //
-      // This method will return `{ jobId: 'cxxxx' }` as soon as the job is
-      // ready to start, and the actual job will continue in the background
-      // afterwards. You should pass `jobId` as a prop to the
-      // `ApostropheJobMonitor` Vue component (TODO: write this component
-      // for 3.0).
-      //
-      // After the job status is `completed` that component will emit
-      // suitable events and the `results` object, if any.
+      // counts expected so a progress meter can be rendered. This is optional
+      // and an indication of progress is still displayed without it.
       //
-      // *Options*
-      //
-      // `options.label` should be passed as an object with
-      // a `title` property, to title the progress modal.
-      // A default is provided but it is not very informative.
+      // `reporting.setResults(object)` may also be called to pass a
+      // results object, which will be available on the finished job document.
       //
-      // In addition, it may have `failed`, `completed` and
-      // `running` properties to label the progress modal when the job
-      // is in those states, and `good` and `bad` properties to label
-      // the count of items that were successful or had errors.
-      // All of these properties are optional and reasonable
-      // defaults are supplied.
+      // This method will return an object with a `jobId` identifier as soon as
+      // the job is ready to start, and the actual job will continue in the
+      // background afterwards. You can pass `jobId` to the `progress` API route
+      // of this module as `_id` on the request body to get job status info.
       //
-      // You may optionally provide `options.stop` or `options.cancel`.
-      // These async functions will be invoked and awaited
-      // after the user requests to stop the operation. `stop` must cease
-      // all operations before resolving, while `cancel` must both cease
-      // operations and reverse all changes made before resolving.
-      async runNonBatch(req, doTheWork, options) {
+      // Notification messages should be included on a `req.body.messages` object. See `triggerNotification for details`.
+      async run(req, doTheWork, options = {}) {
         const res = req.res;
         let job;
-        const canceling = false;
+        let notification;
+        let total;
+
         try {
-          const info = await startJob();
+          job = await self.start(options);
           run();
-          return info;
+
+          // Trigger the "in progress" notification.
+          notification = await self.triggerNotification(req, 'progress', {
+            // It's only relevant to pass a job ID to the notification if
+            // the notification will show progress. Without a total number we
+            // can't show progress.
+            jobId: total && job._id,
+            count: total
+          });
+
+          return {
+            jobId: job._id
+          };
         } catch (err) {
           self.apos.util.error(err);
           if (job) {
@@ -213,44 +219,81 @@ module.exports = {
             return res.status(500).send('error');
           }
         }
-        async function startJob() {
-          job = await self.start(options);
-          return { jobId: job._id };
-        }
+
         async function run() {
           let results;
           let good = false;
           try {
             await doTheWork(req, {
-              good: function (n) {
+              success (n) {
                 n = n || 1;
-                return self.good(job, n);
+                return self.success(job, n);
               },
-              bad: function (n) {
+              failure (n) {
                 n = n || 1;
-                return self.bad(job, n);
+                return self.failure(job, n);
               },
-              setTotal: function (n) {
+              setTotal (n) {
+                total = n;
                 return self.setTotal(job, n);
               },
-              setResults: function (_results) {
+              setResults (_results) {
                 results = _results;
-              },
-              isCanceling: function () {
-                return canceling;
               }
             });
             good = true;
           } finally {
             await self.end(job, good, results);
+
+            // Trigger the completed notification.
+            await self.triggerNotification(req, 'completed', {
+              count: total,
+              dismiss: true
+            });
+            // Dismiss the progress notification. It will delay 4 seconds
+            // because "completed" notification will dismiss in 5 and we want
+            // to maintain the feeling of process order for users.
+            await self.apos.notification.dismiss(req, notification.noteId, 4000);
           }
         }
       },
+      // Job notification messages are passed to `triggerNotifications`
+      // through `req.body.messages` via `run` and `runBatch`. The
+      // `req.body.messages` object can include `progress` and `completed`
+      // properties, which will be used for notifications when the job starts
+      // (`progress`) and ends (`completed`). Those messages can include the
+      // following interpolation keys:
+      // - {{ type }}: The doc type, as passed to the job on req.body.type
+      // - {{ count }}: The count of total document IDs in the req.body._ids
+      //   array
+      // No messages are required, but they provide helpful information to
+      // end users.
+      async triggerNotification(req, stage, options = {}) {
+        if (!req.body || !req.body.messages || !req.body.messages[stage]) {
+          return {};
+        }
+
+        return self.apos.notification.trigger(req, req.body.messages[stage], {
+          interpolate: {
+            count: options.count || (req.body._ids && req.body._ids.length),
+            type: req.body.type || req.t('apostrophe:document')
+          },
+          dismiss: options.dismiss,
+          job: {
+            _id: options.jobId,
+            action: options.action,
+            ids: options.ids
+          },
+          icon: req.body.messages.icon || 'database-export-icon',
+          type: options.type || 'success',
+          return: true
+        });
+      },
       // Start tracking a long-running job. Called by routes
       // that require progress display and/or the ability to take longer
       // than the server might permit a single HTTP request to last.
       // *You usually won't call this yourself. The easy way is usually
-      // to call the `run` or `runNonBatch` methods.*
+      // to call the `runBatch` or `run` methods.*
       //
       // On success this method returns a `job` object.
       // You can then invoke the `setTotal`, `success`, `error`,
@@ -263,39 +306,6 @@ module.exports = {
       // to indicate the success or failure of one "row" or other item
       // processed, and you *may* call `setTotal(job, n)` to indicate
       // how many rows to expect for better progress display.
-      //
-      // *Canceling and stopping jobs*
-      //
-      // If `options.cancel` is passed, the user may cancel (undo) the job.
-      // If they do `options.cancel` will be invoked with `(job)` and
-      // it *must undo what was done*. `cancel` must be async and will
-      // be awaited. If it throws an error, the job will be stopped
-      // with no further progress in the undo operation.
-      //
-      // If `options.stop` is passed, the user may stop (halt) the operation.
-      // If they do `options.stop` will be invoked with `(job)` and
-      // it *must stop processing new items*. This function may be
-      // async and it must not resolve until it is guaranteed that
-      // *no more operations will run*.
-      //
-      // The difference between stop and cancel is the lack of undo with "stop".
-      // Implement the one that is practical for you. Users like to be able to
-      // undo things fully, of course.
-      //
-      // You should not offer both. If you do, only "Cancel" is presented
-      // to the user.
-      //
-      // *Labeling the progress modal: `options.label`*
-      //
-      // `options.label` should be passed as an object with
-      // a `title` property, to title the progress modal.
-      //
-      // In addition, it may have `failed`, `completed` and
-      // `running` properties to label the progress modal when the job
-      // is in those states, and `good` and `bad` properties to label
-      // the count of items that were successful or had errors.
-      // All of these properties are optional and reasonable
-      // defaults are supplied.
       async start(options) {
         const job = {
           _id: self.apos.util.generateId(),
@@ -304,21 +314,13 @@ module.exports = {
           processed: 0,
           status: 'running',
           ended: false,
-          canceling: false,
-          labels: options.labels || {},
-          when: new Date(),
-          canCancel: !!options.cancel,
-          canStop: !!options.stop
+          when: new Date()
         };
         const context = {
           _id: job._id,
           options: options
         };
-        if (options.cancel || options.stop) {
-          context.interval = setInterval(function () {
-            self.checkStop(context);
-          }, 250);
-        }
+
         await self.db.insertOne(job);
         return context;
       },
@@ -330,7 +332,7 @@ module.exports = {
       //
       // No promise is returned as this method just updates
       // the job tracking information in the background.
-      good(job, n) {
+      success(job, n) {
         n = n === undefined ? 1 : n;
         self.db.updateOne({ _id: job._id }, {
           $inc: {
@@ -351,7 +353,7 @@ module.exports = {
       //
       // No promise is returned as this method just updates
       // the job tracking information in the background.
-      bad(job, n) {
+      failure(job, n) {
         n = n === undefined ? 1 : n;
         self.db.updateOne({ _id: job._id }, {
           $inc: {
@@ -407,60 +409,10 @@ module.exports = {
       async ensureCollection() {
         self.db = await self.apos.db.collection(self.options.collectionName);
       },
-      // Periodically invoked to check whether
-      // a request to cancel or stop the job has been made.
-      // If it has we invoke options.cancel or options.stop to
-      // actually cancel it, preferably the former. This method is invoked
-      // by an interval timer installed by `self.start`.
-      // This allows a possibly different apostrophe process
-      // to request a cancellation by setting the `canceling` property;
-      // the original process actually running the job
-      // cancels and then acknowledges this by setting status to `canceled`
-      // or `stopped` according to which operation is
-      // actually supported by the job.
-      async checkStop(context) {
-        if (context.checkingStop || context.ended) {
-          return;
-        }
-        context.checkingStop = true;
-        let job;
-        try {
-          job = await self.db.findOne({ _id: context._id });
-          if (!job) {
-            self.apos.util.error('job never found');
-            return;
-          }
-          if (job.canceling) {
-            if (job.canCancel) {
-              return await halt('cancel', 'canceled');
-            } else if (job.canStop) {
-              return await halt('stop', 'stopped');
-            }
-          }
-        } catch (err) {
-          self.apos.util.error(err);
-          await self.db.updateOne({ _id: context._id }, {
-            $set: {
-              ended: true,
-              canceling: false,
-              status: 'failed'
-            }
-          });
-        } finally {
-          context.checkingStop = false;
-          if (job && job.ended) {
-            clearInterval(context.interval);
-          }
-        }
-        async function halt(verb, status) {
-          await context.options[verb](job);
-          const $set = {
-            ended: true,
-            canceling: false,
-            status: status
-          };
-          await self.db.updateOne({ _id: job._id }, { $set: $set });
-        }
+      getBrowserData(req) {
+        return {
+          action: self.action
+        };
       }
     };
   }

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

@@ -365,21 +365,6 @@ module.exports = {
         return 1000 * 60 * 60 * (self.options.passwordResetHours || 48);
       },
 
-      // Invoked by passport after an authentication strategy succeeds
-      // and the user has been logged in. Invokes `loginAfterLogin` on
-      // any modules that have one and redirects to `req.redirect` or,
-      // if it is not set, to `/`.
-
-      async afterLogin(req, res) {
-        try {
-          await self.emit('after', req);
-        } catch (e) {
-          self.apos.util.error(e);
-          return res.redirect('/');
-        }
-        return res.redirect(req.redirect || '/');
-      },
-
       getBrowserData(req) {
         return {
           action: self.action,
@@ -398,7 +383,7 @@ module.exports = {
         const adminReq = self.apos.task.getReq();
         const user = await self.apos.user.find(adminReq, {}).relationships(false).limit(1).toObject();
 
-        if (!user) {
+        if (!user && !self.apos.options.test) {
           self.apos.util.warnDev('There are no users created for this installation of ApostropheCMS yet.');
         }
       },

package/modules/@apostrophecms/login/ui/apos/components/TheAposLogin.vue

@@ -37,6 +37,7 @@
                   type="primary"
                   label="apostrophe:login"
                   button-type="submit"
+                  class="apos-login__submit"
                   :modifiers="['gradient-on-hover', 'block']"
                   @click="submit"
                 />
@@ -301,4 +302,8 @@ export default {
       margin-left: auto;
     }
   }
+
+  .apos-login__submit ::v-deep .apos-button {
+    height: 47px;
+  }
 </style>

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

@@ -260,7 +260,7 @@ module.exports = {
           // Intentionally emitted regardless of whether the site is new or not.
           //
           // This is the right time to park pages, for instance, because the
-          // database is guaranteed to be in a sane state, whether because the
+          // database is guaranteed to be in a stable state, whether because the
           // site is new or because migrations ran successfully.
           await self.emit('after');
         } finally {