Merge pull request #22 from fielded/versioned-tp

Use versioned target population

Author: patriciagarcia

.babelrc

@@ -1,5 +1,5 @@
 {
   "presets": [
-    "es2015-rollup"
+    ["es2015", { "modules": false }]
   ]
 }

package.json

@@ -31,7 +31,7 @@
   "devDependencies": {
     "angular-mocks": "^1.5.5",
     "babel-core": "^6.8.0",
-    "babel-preset-es2015-rollup": "^1.1.1",
+    "babel-preset-es2015": "^6.18.0",
     "ghooks": "^1.3.2",
     "jasmine-core": "^2.4.1",
     "karma": "^0.13.22",

src/thresholds.service.js

@@ -13,10 +13,101 @@ const isVersion = (version, item) => item.version === version
 const isId = (id, item) => item._id === id
 
 // Zones config
-const zonesPlan = {
-  min: 0,
-  reOrder: 3,
-  max: 6
+const zonePlans = {
+  weeksOfStock: {
+    min: 0,
+    reOrder: 3,
+    max: 6
+  }
+}
+
+const getFactorVersion = (stockCount, factor, options) => {
+  if (options.version === 'last') {
+    return options.version
+  }
+  if (!(stockCount[factor] && stockCount[factor].version)) {
+    return 1
+  }
+  return stockCount[factor].version
+}
+
+const getFactor = (location, versions, version) => {
+  if (version === 'last') {
+    return versions[versions.length - 1]
+  }
+
+  return find(versions, isVersion.bind(null, version))
+}
+
+const getFactors = (stockCount, location, options) => {
+  // centralized for whenever we implement #16
+  const somethingIsWrong = () => undefined
+
+  const getWeeklyLevels = () => {
+    if (!(location.allocations && location.allocations.length)) {
+      somethingIsWrong()
+    }
+
+    const allocationsVersion = getFactorVersion(stockCount, 'allocations', options)
+
+    if (typeof allocationsVersion === 'undefined') {
+      somethingIsWrong()
+    }
+
+    const allocations = getFactor(location, location.allocations, allocationsVersion)
+    return allocations && allocations.weeklyLevels
+  }
+
+  const getWeeksOfStock = () => {
+    if (location.level !== 'zone' && !(location.plans && location.plans.length)) {
+      somethingIsWrong()
+    }
+
+    const plansVersion = getFactorVersion(stockCount, 'plans', options)
+
+    if (typeof plansVersion === 'undefined') {
+      somethingIsWrong()
+    }
+
+    let plans = zonePlans
+    if (location.level !== 'zone') {
+      plans = getFactor(location, location.plans, plansVersion)
+    }
+
+    return plans && plans.weeksOfStock
+  }
+
+  const getMonthlyTargetPopulations = () => {
+    let monthlyTargetPopulations
+    if (location.targetPopulations) {
+      if (!location.targetPopulations.length) {
+        somethingIsWrong()
+      }
+      const targetPopulationVersion = getFactorVersion(stockCount, 'targetPopulations', options)
+
+      if (typeof targetPopulationVersion === 'undefined') {
+        somethingIsWrong()
+      }
+
+      const targetPopulations = getFactor(location, location.targetPopulations, targetPopulationVersion)
+      monthlyTargetPopulations = targetPopulations && targetPopulations.monthlyTargetPopulations
+    } else {
+      // For backwards compatibility with the old style location docs,
+      // since we have no control about when the dashboards are going
+      // to replicate the new location docs
+      if (!(location.targetPopulation && location.targetPopulation.length)) {
+        somethingIsWrong()
+      }
+      monthlyTargetPopulations = location.targetPopulation
+    }
+    return monthlyTargetPopulations
+  }
+
+  return {
+    weeksOfStock: getWeeksOfStock(),
+    weeklyLevels: getWeeklyLevels(),
+    targetPopulations: getMonthlyTargetPopulations()
+  }
 }
 
 class ThresholdsService {
@@ -31,55 +122,25 @@ class ThresholdsService {
   // the week, that information is passed as an optional param (`requiredStateStoresAllocation`).
   // That param is only used for zones.
   calculateThresholds (location, stockCount, products, requiredStateStoresAllocation = {}, options = {}) {
-    if (!location || !location.allocations || !location.allocations.length ||
-      !location.plans || !location.plans.length || !location.level) {
-      return
-    }
-
     if (!stockCount) {
       return
     }
 
-    if (options.version !== 'last' &&
-        !(stockCount.allocations && typeof stockCount.allocations.version !== undefined &&
-          stockCount.plans && typeof stockCount.plans.version !== undefined)) {
+    if (!location && location.level) {
       return
     }
 
     if (!products || !products.length) {
       return
     }
 
-    let allocation
-    if (options.version === 'last') {
-      allocation = location.allocations[location.allocations.length - 1]
-    } else {
-      allocation = find(location.allocations, isVersion.bind(null, stockCount.allocations.version))
-    }
+    const { weeklyLevels, weeksOfStock, targetPopulations } = getFactors(stockCount, location, options)
 
-    if (!(allocation && allocation.weeklyLevels)) {
+    if (!(weeklyLevels && weeksOfStock && targetPopulations)) {
       return
     }
 
-    const weeklyLevels = allocation.weeklyLevels
-
-    let weeksOfStock = zonesPlan
-
-    if (location.level !== 'zone') {
-      let plan
-      if (options.version === 'last') {
-        plan = location.plans[location.plans.length - 1]
-      } else {
-        plan = find(location.plans, isVersion.bind(null, stockCount.plans.version))
-      }
-
-      if (!(plan && plan.weeksOfStock)) {
-        return
-      }
-      weeksOfStock = plan.weeksOfStock
-    }
-
-    let thresholds = Object.keys(weeklyLevels).reduce((index, productId) => {
+    return Object.keys(weeklyLevels).reduce((index, productId) => {
       index[productId] = Object.keys(weeksOfStock).reduce((productThresholds, threshold) => {
         const level = weeklyLevels[productId] * weeksOfStock[threshold]
         const product = find(products, isId.bind(null, productId))
@@ -102,14 +163,10 @@ class ThresholdsService {
         return productThresholds
       }, {})
 
-      if (location.targetPopulation) {
-        index[productId].targetPopulation = location.targetPopulation[productId]
-      }
+      index[productId].targetPopulation = targetPopulations[productId]
 
       return index
     }, {})
-
-    return thresholds
   }
 
   getThresholdsFor (stockCounts, products) {
@@ -129,7 +186,12 @@ class ThresholdsService {
       const id = this.smartId.idify(scLocation, locationIdPattern)
       const allocations = stockCount.allocations || { version: 1 }
       const plans = stockCount.plans || { version: 1 }
-      index[id] = angular.merge({}, { allocations: allocations, plans: plans })
+      const targetPopulations = stockCount.targetPopulations || { version: 1 }
+      index[id] = angular.merge({}, {
+        allocations,
+        plans,
+        targetPopulations
+      })
 
       if (scLocation.lga) {
         if (!promises.lga) {

test/thresholds.service.spec.js

@@ -47,10 +47,22 @@ describe('thresholds service', function () {
         }
       }
     ],
-    targetPopulation: {
-      'product:a': 1000,
-      'product:b': 2000
-    },
+    targetPopulations: [
+      {
+        version: 1,
+        monthlyTargetPopulations: {
+          'product:a': 500,
+          'product:b': 1000
+        }
+      },
+      {
+        version: 2,
+        monthlyTargetPopulations: {
+          'product:a': 1000,
+          'product:b': 2000
+        }
+      }
+    ],
     plans: [
       {
         version: 1,
@@ -73,15 +85,10 @@ describe('thresholds service', function () {
 
   var stockCount = {
     allocations: { version: 2 },
-    plans: { version: 1 }
+    plans: { version: 1 },
+    targetPopulations: { version: 2 }
   }
 
-  var stockCounts = [
-    // { location: { zone: 'nc' }, allocations: { version: 2 }, plans: { version: 1 } },
-    { location: { zone: 'nc', state: 'kogi' }, allocations: { version: 2 }, plans: { version: 1 } },
-    { location: { zone: 'nc', state: 'kogi', lga: 'adavi' } }
-  ]
-
   var products = [
     // TODO: presentation should be ints
     { _id: 'product:a', presentation: '10' },
@@ -179,7 +186,7 @@ describe('thresholds service', function () {
       var actual = thresholdsService.calculateThresholds(unroundedLocation, stockCount, products)
       expect(actual).toEqual(expected)
     })
-    it('uses the last version of plans and allocations if { version: "last"} is passed as option', function () {
+    it('uses the last version of all factors if { version: "last"} is passed as option', function () {
       var expected = {
         'product:a': {
           min: 200,
@@ -197,10 +204,57 @@ describe('thresholds service', function () {
       var actual = thresholdsService.calculateThresholds(location, stockCount, products, null, { version: 'last' })
       expect(actual).toEqual(expected)
     })
+    it('uses 1 as default version for all factors if no version is provided', function () {
+      var expected = {
+        'product:a': {
+          min: 50,
+          reOrder: 100,
+          max: 250,
+          targetPopulation: 500
+        },
+        'product:b': {
+          min: 100,
+          reOrder: 200,
+          max: 500,
+          targetPopulation: 1000
+        }
+      }
+      var actual = thresholdsService.calculateThresholds(location, {}, products)
+      expect(actual).toEqual(expected)
+    })
+    it('still works if the location doc contains a non versioned targetPopulation field', function () {
+      var oldStyleTargetPopulations = {
+        'product:a': 500,
+        'product:b': 1000
+      }
+      var oldStyleLocation = angular.extend({}, location, { targetPopulation: oldStyleTargetPopulations })
+      delete oldStyleLocation.targetPopulations
+      var expected = {
+        'product:a': {
+          min: 50,
+          reOrder: 100,
+          max: 250,
+          targetPopulation: 500
+        },
+        'product:b': {
+          min: 100,
+          reOrder: 200,
+          max: 500,
+          targetPopulation: 1000
+        }
+      }
+      var actual = thresholdsService.calculateThresholds(oldStyleLocation, {}, products)
+      expect(actual).toEqual(expected)
+    })
   })
 
   describe('getThresholdsFor', function () {
     it('takes an array of objects with location, allocations and plans fields and returns an object of location thresholds', function (done) {
+      var stockCounts = [
+        // { location: { zone: 'nc' }, allocations: { version: 2 }, plans: { version: 1 } },
+        { location: { zone: 'nc', state: 'kogi' }, allocations: { version: 2 }, plans: { version: 1 }, targetPopulations: { version: 2 } },
+        { location: { zone: 'nc', state: 'kogi', lga: 'adavi' } }
+      ]
       var expected = {
         // 'zone:nc': {
           // thresholds: {
@@ -211,6 +265,7 @@ describe('thresholds service', function () {
         'zone:nc:state:kogi': {
           allocations: { version: 2 },
           plans: { version: 1 },
+          targetPopulations: { version: 2 },
           thresholds: {
             'product:a': { min: 100, reOrder: 200, max: 500, targetPopulation: 1000 },
             'product:b': { min: 200, reOrder: 400, max: 1000, targetPopulation: 2000 }
@@ -219,9 +274,10 @@ describe('thresholds service', function () {
         'zone:nc:state:kogi:lga:adavi': {
           allocations: { version: 1 },
           plans: { version: 1 },
+          targetPopulations: { version: 1 },
           thresholds: {
-            'product:a': { min: 50, reOrder: 100, max: 250, targetPopulation: 1000 },
-            'product:b': { min: 100, reOrder: 200, max: 500, targetPopulation: 2000 }
+            'product:a': { min: 50, reOrder: 100, max: 250, targetPopulation: 500 },
+            'product:b': { min: 100, reOrder: 200, max: 500, targetPopulation: 1000 }
           }
         }
       }