calculate daysWorked

Author: eisbilir

src/common/helper.js

@@ -953,8 +953,8 @@ async function postEvent (topic, payload, options = {}) {
     payload
   }
   if (options.key) {
-   message.key = options.key
-   }
+    message.key = options.key
+  }
   await client.postEvent(message)
   await eventDispatcher.handleEvent(topic, { value: payload, options })
 }

src/eventHandlers/ResourceBookingEventHandler.js

@@ -176,15 +176,45 @@ async function updateWorkPeriods (payload) {
   const workPeriodsToRemove = _.differenceBy(workPeriods, newWorkPeriods, 'startDate')
   // find which workperiods should be created
   const workPeriodsToAdd = _.differenceBy(newWorkPeriods, workPeriods, 'startDate')
-  // find which workperiods' daysWorked propery should be updated
-  let workPeriodsToUpdate = _.intersectionBy(newWorkPeriods, workPeriods, 'startDate')
-  // find which workperiods' daysWorked property is preset and exceeds the possible maximum
-  workPeriodsToUpdate = _.differenceWith(workPeriodsToUpdate, workPeriods, (a, b) => b.startDate === a.startDate && _.defaultTo(b.daysWorked, a.daysWorked) <= a.daysWorked)
-  // include id
-  workPeriodsToUpdate = _.map(workPeriodsToUpdate, wpu => {
-    wpu.id = _.filter(workPeriods, ['startDate', wpu.startDate])[0].id
-    return wpu
-  })
+  // find which workperiods' daysWorked property should be evaluated for changes
+  const IntersectedWorkPeriods = _.intersectionBy(newWorkPeriods, workPeriods, 'startDate')
+  let workPeriodsToUpdate = []
+  if (IntersectedWorkPeriods.length > 0) {
+    // We only need check for first and last ones of intersected workPeriods
+    // The ones at the middle won't be updated and their daysWorked value will stay the same
+    if (payload.options.oldValue.startDate !== payload.value.startDate) {
+      const firstWeek = _.minBy(IntersectedWorkPeriods, 'startDate')
+      const originalFirstWeek = _.find(workPeriods, ['startDate', firstWeek.startDate])
+      // recalculate daysWorked for the first week of existent workPeriods
+      if (firstWeek.startDate === _.minBy(workPeriods, 'startDate').startDate) {
+        workPeriodsToUpdate.push(_.assign(firstWeek, { id: originalFirstWeek.id }))
+        // if first of intersected workPeriods is not the first one of existent workPeriods
+        // we only check if it's daysWorked exceeds the possible maximum
+      } else if (originalFirstWeek.daysWorked > firstWeek.daysWorked) {
+        workPeriodsToUpdate.push(_.assign(firstWeek, { id: originalFirstWeek.id }))
+      }
+    }
+    if (payload.options.oldValue.endDate !== payload.value.endDate) {
+      const lastWeek = _.maxBy(IntersectedWorkPeriods, 'startDate')
+      const originalLastWeek = _.find(workPeriods, ['startDate', lastWeek.startDate])
+      // recalculate daysWorked for the last week of existent workPeriods
+      if (lastWeek.startDate === _.maxBy(workPeriods, 'startDate').startDate) {
+        workPeriodsToUpdate.push(_.assign(lastWeek, { id: originalLastWeek.id }))
+        // if last of intersected workPeriods is not the last one of existent workPeriods
+        // we only check if it's daysWorked exceeds the possible maximum
+      } else if (originalLastWeek.daysWorked > lastWeek.daysWorked) {
+        workPeriodsToUpdate.push(_.assign(lastWeek, { id: originalLastWeek.id }))
+      }
+    }
+  }
+  // if intersected WP count is 1, this can result to duplicated WorkPeriods.
+  // We should choose the one with higher daysWorked because, it's more likely
+  // the WP we applied "first/last one of existent WPs" logic above.
+  if (workPeriodsToUpdate.length === 2) {
+    if (workPeriodsToUpdate[0].startDate === workPeriodsToUpdate[1].startDate) {
+      workPeriodsToUpdate = [_.maxBy(workPeriodsToUpdate, 'daysWorked')]
+    }
+  }
   if (workPeriodsToRemove.length === 0 && workPeriodsToAdd.length === 0 && workPeriodsToUpdate.length === 0) {
     logger.debug({
       component: 'ResourceBookingEventHandler',
@@ -256,14 +286,16 @@ async function deleteWorkPeriods (payload) {
  * @returns {undefined}
  */
 async function _createWorkPeriods (periods, resourceBookingId) {
-  await Promise.all(_.map(periods, async period => await WorkPeriodService.createWorkPeriod(helper.getAuditM2Muser(),
-    {
-      resourceBookingId: resourceBookingId,
-      startDate: period.startDate,
-      endDate: period.endDate,
-      daysWorked: null,
-      paymentStatus: 'pending'
-    })))
+  for (const period of periods) {
+    await WorkPeriodService.createWorkPeriod(helper.getAuditM2Muser(),
+      {
+        resourceBookingId: resourceBookingId,
+        startDate: period.startDate,
+        endDate: period.endDate,
+        daysWorked: period.daysWorked,
+        paymentStatus: 'pending'
+      })
+  }
 }
 
 /**
@@ -272,11 +304,13 @@ async function _createWorkPeriods (periods, resourceBookingId) {
  * @returns {undefined}
  */
 async function _updateWorkPeriods (periods) {
-  await Promise.all(_.map(periods, async period => await WorkPeriodService.partiallyUpdateWorkPeriod(helper.getAuditM2Muser(),
-    period.id,
-    {
-      daysWorked: period.daysWorked
-    })))
+  for (const period of periods) {
+    await WorkPeriodService.partiallyUpdateWorkPeriod(helper.getAuditM2Muser(),
+      period.id,
+      {
+        daysWorked: period.daysWorked
+      })
+  }
 }
 
 /**
@@ -285,8 +319,9 @@ async function _updateWorkPeriods (periods) {
  * @returns {undefined}
  */
 async function _deleteWorkPeriods (workPeriods) {
-  await Promise.all(_.map(workPeriods,
-    async workPeriod => await WorkPeriodService.deleteWorkPeriod(helper.getAuditM2Muser(), workPeriod.id)))
+  for (const period of workPeriods) {
+    await WorkPeriodService.deleteWorkPeriod(helper.getAuditM2Muser(), period.id)
+  }
 }
 
 /**

src/services/ResourceBookingService.js

@@ -18,6 +18,7 @@ const moment = require('moment')
 
 const ResourceBooking = models.ResourceBooking
 const WorkPeriod = models.WorkPeriod
+const WorkPeriodPayment = models.WorkPeriodPayment
 const esClient = helper.getESClient()
 const cachedModelFields = _cacheModelFields()
 
@@ -168,27 +169,41 @@ async function _checkUserPermissionForGetResourceBooking (currentUser, projectId
  */
 async function _ensurePaidWorkPeriodsNotDeleted (resourceBookingId, oldValue, newValue) {
   function _checkForPaidWorkPeriods (workPeriods) {
-    const paidWorkPeriods = _.filter(workPeriods
-      , workPeriod => _.includes(['completed', 'partially-completed'], workPeriod.paymentStatus))
+    const paidWorkPeriods = _.filter(workPeriods, workPeriod => {
+      // filter by WP and WPP status
+      return (['completed', 'partially-completed', 'in-progress'].indexOf(workPeriod.paymentStatus) !== -1 ||
+      _.some(workPeriod.payments, payment => ['completed', 'in-progress'].indexOf(payment.status) !== -1))
+    })
     if (paidWorkPeriods.length > 0) {
       throw new errors.BadRequestError(`WorkPeriods with id of ${_.map(paidWorkPeriods, workPeriod => workPeriod.id)}
-        has completed or partially-completed payment status.`)
+        has completed, partially-completed or in-progress payment status.`)
     }
   }
   // find related workPeriods to evaluate the changes
-  const workPeriods = await WorkPeriod.findAll({
+  // We don't need to include WPP because WPP's status changes should
+  // update WP's status. In case of any bug, it's better to check both WP
+  // and WPP status for now.
+  let workPeriods = await WorkPeriod.findAll({
     where: {
       resourceBookingId: resourceBookingId
     },
-    raw: true
+    attributes: ['id', 'paymentStatus', 'startDate', 'endDate'],
+    include: [{
+      model: WorkPeriodPayment,
+      as: 'payments',
+      required: false,
+      attributes: ['status']
+    }]
   })
+  workPeriods = _.map(workPeriods, wp => wp.toJSON())
   // oldValue and newValue are not provided at deleteResourceBooking process
   if (_.isUndefined(oldValue) || _.isUndefined(newValue)) {
     _checkForPaidWorkPeriods(workPeriods)
     return
   }
   // We should not be able to change status of ResourceBooking to 'cancelled'
-  // if there is at least one associated Work Period with paymentStatus 'partially-completed' or 'completed'.
+  // if there is at least one associated Work Period with paymentStatus 'partially-completed', 'completed' or 'in-progress',
+  // or any of it's WorkPeriodsPayment has status 'completed' or 'in-progress'.
   if (oldValue.status !== 'cancelled' && newValue.status === 'cancelled') {
     _checkForPaidWorkPeriods(workPeriods)
     // we have already checked all existing workPeriods
@@ -200,7 +215,8 @@ async function _ensurePaidWorkPeriodsNotDeleted (resourceBookingId, oldValue, ne
     _.isUndefined(newValue.endDate) ? oldValue.endDate : newValue.endDate)
   // find which workPeriods should be removed
   const workPeriodsToRemove = _.differenceBy(workPeriods, newWorkPeriods, 'startDate')
-  // we can't delete workperiods with paymentStatus 'partially-completed' or 'completed'.
+  // we can't delete workperiods with paymentStatus 'partially-completed', 'completed' or 'in-progress',
+  // or any of it's WorkPeriodsPayment has status 'completed' or 'in-progress'.
   _checkForPaidWorkPeriods(workPeriodsToRemove)
 }
 

src/services/WorkPeriodService.js

@@ -235,7 +235,7 @@ async function createWorkPeriod (currentUser, workPeriod) {
     }
   }
 
-  await helper.postEvent(config.TAAS_WORK_PERIOD_CREATE_TOPIC, created.toJSON(),{"key":workPeriod.resourceBookingId})
+  await helper.postEvent(config.TAAS_WORK_PERIOD_CREATE_TOPIC, created.toJSON(), { key: workPeriod.resourceBookingId })
   return created.dataValues
 }
 
@@ -289,8 +289,8 @@ async function updateWorkPeriod (currentUser, id, data) {
     }
   }
 
-  //await helper.postEvent(config.TAAS_WORK_PERIOD_UPDATE_TOPIC, updated.toJSON(), { oldValue: oldValue })
-  await helper.postEvent(config.TAAS_WORK_PERIOD_UPDATE_TOPIC, updated.toJSON(), {oldValue: oldValue, "key":data.resourceBookingId})
+  // await helper.postEvent(config.TAAS_WORK_PERIOD_UPDATE_TOPIC, updated.toJSON(), { oldValue: oldValue })
+  await helper.postEvent(config.TAAS_WORK_PERIOD_UPDATE_TOPIC, updated.toJSON(), { oldValue: oldValue, key: data.resourceBookingId })
   return updated.dataValues
 }
 
@@ -356,8 +356,11 @@ async function deleteWorkPeriod (currentUser, id) {
   }
 
   const workPeriod = await WorkPeriod.findById(id, { withPayments: true })
-  if (_.includes(['completed', 'partially-completed'], workPeriod.paymentStatus)) {
-    throw new errors.BadRequestError("Can't delete WorkPeriod with paymentStatus completed or partially-completed")
+  if (_.includes(['completed', 'partially-completed', 'in-progress'], workPeriod.paymentStatus)) {
+    throw new errors.BadRequestError("Can't delete WorkPeriod with paymentStatus completed partially-completed, or in-progress")
+  }
+  if (_.some(workPeriod.payments, payment => ['completed', 'in-progress'].indexOf(payment.status) !== -1)) {
+    throw new errors.BadRequestError("Can't delete WorkPeriod if any associated WorkPeriodsPayment has status completed or in-progress")
   }
   await models.WorkPeriodPayment.destroy({
     where: {