Improve handling of overlapping activities

* Active activities can be transformed to timesheet entries if not
overlapping
* Show a warning if trying to transform overlapping activities
* Do not split overlapping activities if they overlap more than one day
* Show an info message if stopping >1 day overlapping activities

Author: Jonas Metzener

app/index/activities/route.js

@@ -121,12 +121,16 @@ export default Route.extend(RouteAutostartTourMixin, {
         'task.id',
         undefined
       )
-      let hasActive = !!this.get('controller.activities').findBy('active')
+      let hasOverlapping = !!this.get('controller.activities').find(a => {
+        return (
+          a.get('active') && !a.get('activeBlock.from').isSame(moment(), 'day')
+        )
+      })
 
       this.set('controller.showUnknownWarning', hasUnknown)
-      this.set('controller.showActiveWarning', hasActive)
+      this.set('controller.showOverlappingWarning', hasOverlapping)
 
-      if (!hasUnknown && !hasActive) {
+      if (!hasUnknown && !hasOverlapping) {
         this.send('generateReports')
       }
     },
@@ -139,15 +143,26 @@ export default Route.extend(RouteAutostartTourMixin, {
      */
     async generateReports() {
       this.set('controller.showUnknownWarning', false)
-      this.set('controller.showActiveWarning', false)
+      this.set('controller.showOverlappingWarning', false)
 
       try {
         await RSVP.all(
           this.get('controller.activities')
-            .filter(a => a.get('task.id') && !a.get('active'))
+            .filter(
+              a =>
+                a.get('task.id') &&
+                !(
+                  a.get('active') &&
+                  !a.get('activeBlock.from').isSame(moment(), 'day')
+                )
+            )
             .map(async activity => {
               let duration = moment.duration(activity.get('duration'))
 
+              if (activity.get('active')) {
+                duration.add(moment().diff(activity.get('activeBlock.from')))
+              }
+
               let data = {
                 activity,
                 duration,

app/index/activities/template.hbs

@@ -65,16 +65,16 @@
   </div>
 </div>
 
-{{#sy-modal visible=showActiveWarning as |modal|}}
+{{#sy-modal visible=showOverlappingWarning as |modal|}}
   {{#modal.header}}
-    Active activity
+    Activities overlap
   {{/modal.header}}
   {{#modal.body}}
-    Active activities will not be taken into account for the timesheet.
+    Overlapping activities will not be taken into account for the timesheet.
   {{/modal.body}}
-  {{#modal.footer data-test-active-warning}}
-   <button class="btn btn-primary" {{action (if showUnknownWarning (action (mut showActiveWarning) false) 'generateReports')}}>That's fine</button>
-   <button class="btn btn-default" {{action (queue (action (mut showActiveWarning) false) (action (mut showUnknownWarning) false))}}>Cancel</button>
+  {{#modal.footer data-test-overlapping-warning}}
+   <button class="btn btn-primary" {{action (if showUnknownWarning (action (mut showOverlappingWarning) false) 'generateReports')}}>That's fine</button>
+   <button class="btn btn-default" {{action (queue (action (mut showOverlappingWarning) false) (action (mut showUnknownWarning) false))}}>Cancel</button>
   {{/modal.footer}}
 {{/sy-modal}}
 
@@ -86,7 +86,7 @@
     Unknown tasks will not be taken into account for the timesheet.
   {{/modal.body}}
   {{#modal.footer data-test-unknown-warning}}
-   <button class="btn btn-primary" {{action (if showActiveWarning (action (mut showUnknownWarning) false) 'generateReports')}}>That's fine</button>
-   <button class="btn btn-default" {{action (queue (action (mut showUnknownWarning) false) (action (mut showActiveWarning) false))}}>Cancel</button>
+   <button class="btn btn-primary" {{action (if showOverlappingWarning (action (mut showUnknownWarning) false) 'generateReports')}}>That's fine</button>
+   <button class="btn btn-default" {{action (queue (action (mut showUnknownWarning) false) (action (mut showOverlappingWarning) false))}}>Cancel</button>
   {{/modal.footer}}
 {{/sy-modal}}

app/models/activity.js

@@ -8,6 +8,7 @@ import attr from 'ember-data/attr'
 import moment from 'moment'
 import computed from 'ember-computed-decorators'
 import RSVP from 'rsvp'
+import { inject as service } from '@ember/service'
 
 import { belongsTo, hasMany } from 'ember-data/relationships'
 
@@ -74,6 +75,14 @@ export default Model.extend({
    */
   blocks: hasMany('activity-block'),
 
+  /**
+   * The notify service
+   *
+   * @property {EmberNotify.NotifyService} notify
+   * @public
+   */
+  notify: service('notify'),
+
   /**
    * The currently active block
    *
@@ -132,7 +141,11 @@ export default Model.extend({
   /**
    * Stop the activity
    *
-   * When stopping an activity of a past day, we need to split it
+   * If the activity was started yesterday, we create a new identical
+   * activity today so we handle working over midnight
+   *
+   * If the activity was started even before, we ignore it since it must be
+   * a mistake, so we end the activity a second before midnight that day
    *
    * @method stop
    * @public
@@ -143,22 +156,21 @@ export default Model.extend({
       return
     }
 
-    let daysBetween = moment().diff(this.get('date'), 'days')
+    let activities = [this]
+
+    if (moment().diff(this.get('date'), 'days') === 1) {
+      activities.push(
+        this.get('store').createRecord('activity', {
+          task: this.get('task'),
+          comment: this.get('comment'),
+          user: this.get('user'),
+          date: moment(this.get('date')).add(1, 'days')
+        })
+      )
+    }
 
     await RSVP.all(
-      [
-        this,
-        ...Object.keys(Array(daysBetween).fill())
-          .map(Number)
-          .map(n => {
-            return this.get('store').createRecord('activity', {
-              task: this.get('task'),
-              comment: this.get('comment'),
-              user: this.get('user'),
-              date: moment(this.get('date')).add(n + 1, 'days')
-            })
-          })
-      ].map(async activity => {
+      activities.map(async activity => {
         if (activity.get('isNew')) {
           await activity.save()
         }
@@ -187,5 +199,11 @@ export default Model.extend({
         await block.save({ adapterOptions: { include: 'activity' } })
       })
     )
+
+    if (moment().diff(this.get('date'), 'days') > 1) {
+      this.get('notify').info(
+        'The activity overlapped multiple days, which is not possible. The activity was stopped at midnight of the day it was started.'
+      )
+    }
   }
 })

mirage/scenarios/default.js

@@ -1,7 +1,7 @@
 import moment from 'moment'
 
 export default function(server) {
-  // server.logging = false
+  server.logging = false
 
   server.loadFixtures('absence-types')
 

tests/acceptance/index-activities-test.js

@@ -7,6 +7,7 @@ import destroyApp from '../helpers/destroy-app'
 import { expect } from 'chai'
 import startApp from '../helpers/start-app'
 import moment from 'moment'
+import formatDuration from 'timed/utils/format-duration'
 
 describe('Acceptance | index activities', function() {
   let application
@@ -204,39 +205,43 @@ describe('Acceptance | index activities', function() {
     expect(currentURL()).to.equal('/reports')
   })
 
-  it('shows a warning when generating reports from active activities', async function() {
-    server.create('activity', 'active', { userId: this.user.id })
+  it('shows a warning when generating reports from overlapping activities', async function() {
+    let date = moment().subtract(1, 'days')
 
-    await visit('/')
+    server.create('activity', 'active', { userId: this.user.id, date })
+
+    await visit(`/?day=${date.format('YYYY-MM-DD')}`)
 
     await click('button:contains(Generate timesheet)')
-    await click('[data-test-active-warning] button:contains(Cancel)')
+    await click('[data-test-overlapping-warning] button:contains(Cancel)')
 
-    expect(currentURL()).to.equal('/')
+    expect(currentURL()).to.not.contain('reports')
 
     await click('button:contains(Generate timesheet)')
-    await click('[data-test-active-warning] button:contains(fine)')
+    await click('[data-test-overlapping-warning] button:contains(fine)')
 
-    expect(currentURL()).to.equal('/reports')
+    expect(currentURL()).to.contain('reports')
   })
 
   it('can handle both warnings', async function() {
-    server.create('activity', 'unknown', { userId: this.user.id })
-    server.create('activity', 'active', { userId: this.user.id })
+    let date = moment().subtract(1, 'days')
 
-    await visit('/')
+    server.create('activity', 'unknown', { userId: this.user.id, date })
+    server.create('activity', 'active', { userId: this.user.id, date })
+
+    await visit(`/?day=${date.format('YYYY-MM-DD')}`)
 
     // both close if one clicks cancel
     await click('button:contains(Generate timesheet)')
     expect(find('.modal--visible')).to.have.length(2)
-    await click('[data-test-active-warning] button:contains(Cancel)')
+    await click('[data-test-overlapping-warning] button:contains(Cancel)')
     expect(find('.modal--visible')).to.have.length(0)
-    expect(currentURL()).to.equal('/')
+    expect(currentURL()).to.not.contain('reports')
 
     // both must be fine if it should continue
     await click('button:contains(Generate timesheet)')
     expect(find('.modal--visible')).to.have.length(2)
-    await click('[data-test-active-warning] button:contains(fine)')
+    await click('[data-test-overlapping-warning] button:contains(fine)')
     expect(find('.modal--visible')).to.have.length(1)
     await click('[data-test-unknown-warning] button:contains(Cancel)')
     expect(find('.modal--visible')).to.have.length(0)
@@ -245,69 +250,120 @@ describe('Acceptance | index activities', function() {
     expect(find('.modal--visible')).to.have.length(2)
     await click('[data-test-unknown-warning] button:contains(fine)')
     expect(find('.modal--visible')).to.have.length(1)
-    await click('[data-test-active-warning] button:contains(Cancel)')
+    await click('[data-test-overlapping-warning] button:contains(Cancel)')
     expect(find('.modal--visible')).to.have.length(0)
-    expect(currentURL()).to.equal('/')
+    expect(currentURL()).to.not.contain('reports')
 
     // if both are fine continue
     await click('button:contains(Generate timesheet)')
     expect(find('.modal--visible')).to.have.length(2)
-    await click('[data-test-active-warning] button:contains(fine)')
+    await click('[data-test-overlapping-warning] button:contains(fine)')
     expect(find('.modal--visible')).to.have.length(1)
     await click('[data-test-unknown-warning] button:contains(fine)')
     expect(find('.modal--visible')).to.have.length(0)
-    expect(currentURL()).to.equal('/reports')
+    expect(currentURL()).to.contain('reports')
   })
 
-  it('splits overlapping activities when stopping', async function() {
+  it('splits 1 day overlapping activities when stopping', async function() {
     let activity = server.create('activity', 'active', {
       userId: this.user.id,
-      date: moment().subtract(2, 'days')
+      date: moment().subtract(1, 'days')
     })
 
     await visit('/')
 
     await click('[data-test-record-stop]')
 
-    // todayday block should be from 00:00 to now
-    expect(find(`[data-test-activity-row] td:contains(${activity.comment})`)).to
-      .be.ok
+    // today block should be from 00:00 to now
+    expect(
+      find(`[data-test-activity-row] td:contains(${activity.comment})`)
+    ).to.have.length(1)
 
     await click(`[data-test-activity-row] td:contains(${activity.comment})`)
 
     expect(
       find('[data-test-activity-block-row] td:eq(1) input').val()
     ).to.equal('00:00')
 
-    // yesterday block should be from 00:00 to now
+    // yesterday block should be from old start time to 23:59
     await visit('/')
     await click('[data-test-previous]')
 
-    expect(find(`[data-test-activity-row] td:contains(${activity.comment})`)).to
-      .be.ok
+    expect(
+      find(`[data-test-activity-row] td:contains(${activity.comment})`)
+    ).to.have.length(1)
 
     await click(`[data-test-activity-row] td:contains(${activity.comment})`)
 
     expect(
-      find('[data-test-activity-block-row] td:eq(1) input').val()
-    ).to.equal('00:00')
+      find('[data-test-activity-block-row]:last td:eq(3) input').val()
+    ).to.equal('23:59')
+  })
 
+  it("doesn't split >1 days overlapping activities when stopping", async function() {
+    let activity = server.create('activity', 'active', {
+      userId: this.user.id,
+      date: moment().subtract(2, 'days')
+    })
+
+    await visit('/')
+
+    await click('[data-test-record-stop]')
+
+    // today block should not exist
     expect(
-      find('[data-test-activity-block-row] td:eq(3) input').val()
-    ).to.equal('23:59')
+      find(`[data-test-activity-row] td:contains(${activity.comment})`)
+    ).to.have.length(0)
+
+    // yesterday block should not exist
+    await visit('/')
+    await click('[data-test-previous]')
+
+    expect(
+      find(`[data-test-activity-row] td:contains(${activity.comment})`)
+    ).to.have.length(0)
 
     // day before yesterday block should be from old start time to 23:59
     await visit('/')
     await click('[data-test-previous]')
     await click('[data-test-previous]')
 
-    expect(find(`[data-test-activity-row] td:contains(${activity.comment})`)).to
-      .be.ok
+    expect(
+      find(`[data-test-activity-row] td:contains(${activity.comment})`)
+    ).to.have.length(1)
 
     await click(`[data-test-activity-row] td:contains(${activity.comment})`)
 
     expect(
       find('[data-test-activity-block-row]:last td:eq(3) input').val()
     ).to.equal('23:59')
   })
+
+  it('can generate active reports which do not overlap', async function() {
+    let activity = server.create('activity', 'active', { userId: this.user.id })
+    let { id, duration } = activity
+
+    duration = moment.duration(duration, 'HH:mm:ss').add(
+      moment().diff(
+        moment(
+          activity.blocks.models.find(b => {
+            return !b.toTime
+          }).fromTime,
+          'HH:mm:ss'
+        )
+      )
+    )
+
+    await visit('/')
+
+    await click(find('button:contains(Generate timesheet)'))
+
+    expect(currentURL()).to.equal('/reports')
+
+    expect(find('[data-test-report-row]')).to.have.length(7)
+
+    expect(
+      find(`${`[data-test-report-row-id="${id}"]`} [name=duration]`).val()
+    ).to.equal(formatDuration(duration, false))
+  })
 })

tests/unit/models/activity-test.js

@@ -4,7 +4,12 @@ import { expect } from 'chai'
 
 describe('Unit | Model | activity', function() {
   setupModelTest('activity', {
-    needs: ['model:activity-block', 'model:task', 'model:user']
+    needs: [
+      'model:activity-block',
+      'model:task',
+      'model:user',
+      'service:notify'
+    ]
   })
 
   it('exists', function() {