@bluedot-innovation/models 3.0.15 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (41) hide show
  1. package/CHANGELOG.md +6 -0
  2. package/Models.js +12 -12
  3. package/__tests__/beacon/beacon.spec.js +0 -10
  4. package/__tests__/{filter → condition}/dayRange/dayRange.spec.js +12 -12
  5. package/__tests__/{filter → condition}/percentageCrossed/travelPath.spec.js +11 -11
  6. package/__tests__/{filter → condition}/speed/speed.spec.js +21 -21
  7. package/__tests__/{filter → condition}/timeActive/timeActive.data.json +1 -1
  8. package/__tests__/{filter → condition}/timeActive/timeActive.spec.js +25 -25
  9. package/__tests__/{filter → condition}/travelDirection/travelDirection.spec.js +20 -20
  10. package/__tests__/project/project.data.json +2 -1
  11. package/__tests__/user/user.spec.js +22 -0
  12. package/__tests__/zone/zone.action.spec.js +2 -2
  13. package/__tests__/zone/zone.condition.spec.js +76 -0
  14. package/__tests__/zone/zone.data.json +1 -1
  15. package/__tests__/zone/zone.geofeatures.spec.js +2 -2
  16. package/__tests__/zone/zone.spec.js +7 -7
  17. package/helpers.js +21 -8
  18. package/models/Beacon.js +0 -2
  19. package/models/Project.js +2 -3
  20. package/models/Zone.js +24 -15
  21. package/models/{filters → conditions}/DayRange.js +7 -7
  22. package/models/{filters → conditions}/Speed.js +7 -7
  23. package/models/{filters → conditions}/TimeActive.js +8 -8
  24. package/models/{filters → conditions}/TravelDirection.js +7 -7
  25. package/models/{filters → conditions}/TravelPath.js +10 -10
  26. package/package.json +1 -1
  27. package/schemas/ProjectPermission.js +1 -0
  28. package/__tests__/zone/zone.filter.spec.js +0 -50
  29. package/models/SimpleCheckInZone.js +0 -29
  30. /package/__tests__/{filter → condition}/beacon/beaconFilter.data.json +0 -0
  31. /package/__tests__/{filter → condition}/beacon/beaconFilter.rules.json +0 -0
  32. /package/__tests__/{filter → condition}/beacon/beaconFilter.spec.js +0 -0
  33. /package/__tests__/{filter → condition}/dayRange/dayRange.data.json +0 -0
  34. /package/__tests__/{filter → condition}/dayRange/dayRange.rules.json +0 -0
  35. /package/__tests__/{filter → condition}/percentageCrossed/travelPath.data.json +0 -0
  36. /package/__tests__/{filter → condition}/percentageCrossed/travelPath.rules.json +0 -0
  37. /package/__tests__/{filter → condition}/speed/speed.data.json +0 -0
  38. /package/__tests__/{filter → condition}/speed/speed.rules.json +0 -0
  39. /package/__tests__/{filter → condition}/timeActive/timeActive.rules.json +0 -0
  40. /package/__tests__/{filter → condition}/travelDirection/travelDirection.data.json +0 -0
  41. /package/__tests__/{filter → condition}/travelDirection/travelDirection.rules.json +0 -0
package/CHANGELOG.md CHANGED
@@ -1,3 +1,9 @@
1
+ ## 3.1.0
2
+ - Rename `filters` to `conditions`
3
+
4
+ ## 3.0.16
5
+ - `timeActive` - Changed validations order
6
+
1
7
  ## 3.0.15
2
8
  - `webhooks` - Fixed webhooks validations
3
9
 
package/Models.js CHANGED
@@ -22,12 +22,12 @@ Models.Polygon = require('./models/geofeatures/Polygon').Model
22
22
  Models.Polyline = require('./models/geofeatures/Polyline').Model
23
23
  Models.ZoneBeacon = require('./models/geofeatures/ZoneBeacon').Model
24
24
 
25
- // Filters
26
- Models.DayRange = require('./models/filters/DayRange').Model
27
- Models.TimeActive = require('./models/filters/TimeActive').Model
28
- Models.TravelPath = require('./models/filters/TravelPath').Model
29
- Models.Speed = require('./models/filters/Speed').Model
30
- Models.TravelDirection = require('./models/filters/TravelDirection').Model
25
+ // Conditions
26
+ Models.DayRange = require('./models/conditions/DayRange').Model
27
+ Models.TimeActive = require('./models/conditions/TimeActive').Model
28
+ Models.TravelPath = require('./models/conditions/TravelPath').Model
29
+ Models.Speed = require('./models/conditions/Speed').Model
30
+ Models.TravelDirection = require('./models/conditions/TravelDirection').Model
31
31
 
32
32
  let Schemas = {}
33
33
 
@@ -48,12 +48,12 @@ Schemas.Polygon = require('./models/geofeatures/Polygon').Schema
48
48
  Schemas.Polyline = require('./models/geofeatures/Polyline').Schema
49
49
  Schemas.ZoneBeacon = require('./models/geofeatures/ZoneBeacon').Schema
50
50
 
51
- // Filters
52
- Schemas.DayRange = require('./models/filters/DayRange').Schema
53
- Schemas.Speed = require('./models/filters/Speed').Schema
54
- Schemas.TimeActive = require('./models/filters/TimeActive').Schema
55
- Schemas.TravelPath = require('./models/filters/TravelPath').Schema
56
- Schemas.TravelDirection = require('./models/filters/TravelDirection').Schema
51
+ // Conditions
52
+ Schemas.DayRange = require('./models/conditions/DayRange').Schema
53
+ Schemas.Speed = require('./models/conditions/Speed').Schema
54
+ Schemas.TimeActive = require('./models/conditions/TimeActive').Schema
55
+ Schemas.TravelPath = require('./models/conditions/TravelPath').Schema
56
+ Schemas.TravelDirection = require('./models/conditions/TravelDirection').Schema
57
57
 
58
58
  Models.Schemas = Schemas
59
59
  module.exports = Models
@@ -29,16 +29,6 @@ describe('Beacon', () => {
29
29
  done()
30
30
  })
31
31
  })
32
- it('should accept a valid API Key and customer API Key', (done) => {
33
- beacon.apiKey = '23a01af0-232a-4518-9c0e-323fb773f5ef'
34
- beacon.customerApiKey = '23a01af0-232a-4518-9c0e-323fb773ffff'
35
- let Beacon = new BeaconModel(beacon)
36
- Beacon.validate((err, res) => {
37
- assert.notExists(res)
38
- assert(err === null, 'err should equal null')
39
- done()
40
- })
41
- })
42
32
  })
43
33
 
44
34
  describe('Invalid Beacon', () => {
@@ -19,11 +19,11 @@ beforeEach(() => {
19
19
  dayRange = JSON.parse(JSON.stringify(require('./dayRange.data.json')))
20
20
  })
21
21
 
22
- testCase('DayRangeFilter', () => {
23
- testCase('Valid DayRangeFilter', () => {
22
+ testCase('DayRangeCondition', () => {
23
+ testCase('Valid DayRangeCondition', () => {
24
24
  assertions('should validate a valid dayRange', (done) => {
25
- let DayRangeFilter = new DayRangeModel(dayRange)
26
- DayRangeFilter.validate((err, res) => {
25
+ let DayRangeCondition = new DayRangeModel(dayRange)
26
+ DayRangeCondition.validate((err, res) => {
27
27
  assert.notExists(res)
28
28
  assert(err === null, 'err should equals null')
29
29
  done()
@@ -31,11 +31,11 @@ testCase('DayRangeFilter', () => {
31
31
  })
32
32
  })
33
33
 
34
- testCase('Invalid DayRangeFilter', () => {
35
- assertions('should not validate a dayRange with invalid DayRangeFilter', (done) => {
34
+ testCase('Invalid DayRangeCondition', () => {
35
+ assertions('should not validate a dayRange with invalid DayRangeCondition', (done) => {
36
36
  delete dayRange[rules.requiredFields[0]]
37
- let DayRangeFilter = new DayRangeModel(dayRange)
38
- DayRangeFilter.validate((err, res) => {
37
+ let DayRangeCondition = new DayRangeModel(dayRange)
38
+ DayRangeCondition.validate((err, res) => {
39
39
  assert.exists(err, 'err object should exist')
40
40
  assert.isObject(err)
41
41
  done()
@@ -45,8 +45,8 @@ testCase('DayRangeFilter', () => {
45
45
  assertions('should throw an error if both startDate and endDate are not provided', (done) => {
46
46
  delete dayRange.startDate
47
47
  delete dayRange.endDate
48
- let DayRangeFilter = new DayRangeModel(dayRange)
49
- DayRangeFilter.validate((err, res) => {
48
+ let DayRangeCondition = new DayRangeModel(dayRange)
49
+ DayRangeCondition.validate((err, res) => {
50
50
  assert.exists(err, 'err object should exist')
51
51
  assert.isObject(err)
52
52
  done()
@@ -59,8 +59,8 @@ testCase('DayRangeFilter', () => {
59
59
  assertions(`should throw an error with property '${i}' if '${i}' is not present`, (done) => {
60
60
  // delete i from geofeatures' dayRange child
61
61
  delete dayRange[i]
62
- let DayRangeFilter = new DayRangeModel(dayRange)
63
- DayRangeFilter.validate((err, res) => {
62
+ let DayRangeCondition = new DayRangeModel(dayRange)
63
+ DayRangeCondition.validate((err, res) => {
64
64
  assert.notExists(res)
65
65
  assert.exists(err, 'err object should exist')
66
66
  assert.isObject(err)
@@ -2,7 +2,7 @@ let mongoose = require('mongoose')
2
2
 
3
3
  mongoose.Promise = global.Promise
4
4
 
5
- let TravelPathFilterModel = require('../../../Models').TravelPath(mongoose)
5
+ let TravelPathConditionModel = require('../../../Models').TravelPath(mongoose)
6
6
  let testCase = require('mocha').describe
7
7
  let assertions = require('mocha').it
8
8
  let chai = require('chai')
@@ -19,11 +19,11 @@ beforeEach(() => {
19
19
  travelPath = JSON.parse(JSON.stringify(require('./travelPath.data.json')))
20
20
  })
21
21
 
22
- testCase('PercentageCrossedFilter', () => {
23
- testCase('Valid PercentageCrossedFilter', () => {
22
+ testCase('PercentageCrossedCondition', () => {
23
+ testCase('Valid PercentageCrossedCondition', () => {
24
24
  assertions('should validate a valid travelPath ', (done) => {
25
- let PercentageCrossedFilter = new TravelPathFilterModel(travelPath)
26
- PercentageCrossedFilter.validate((err, res) => {
25
+ let PercentageCrossedCondition = new TravelPathConditionModel(travelPath)
26
+ PercentageCrossedCondition.validate((err, res) => {
27
27
  assert.notExists(res)
28
28
  assert(err === null, 'err should equals null')
29
29
  done()
@@ -31,11 +31,11 @@ testCase('PercentageCrossedFilter', () => {
31
31
  })
32
32
  })
33
33
 
34
- testCase('Invalid PercentageCrossedFilter', () => {
35
- assertions('should not validate a travelPath with invalid PercentageCrossedFilter', (done) => {
34
+ testCase('Invalid PercentageCrossedCondition', () => {
35
+ assertions('should not validate a travelPath with invalid PercentageCrossedCondition', (done) => {
36
36
  delete travelPath[rules.requiredFields[0]]
37
- let PercentageCrossedFilter = new TravelPathFilterModel(travelPath)
38
- PercentageCrossedFilter.validate((err, res) => {
37
+ let PercentageCrossedCondition = new TravelPathConditionModel(travelPath)
38
+ PercentageCrossedCondition.validate((err, res) => {
39
39
  assert.exists(err, 'err object should exist')
40
40
  assert.isObject(err)
41
41
  done()
@@ -47,8 +47,8 @@ testCase('PercentageCrossedFilter', () => {
47
47
  assertions(`should throw an error with property '${i}' if '${i}' is not present`, (done) => {
48
48
  // delete i from geofeatures' travelPath child
49
49
  delete travelPath[i]
50
- let PercentageCrossedFilter = new TravelPathFilterModel(travelPath)
51
- PercentageCrossedFilter.validate((err, res) => {
50
+ let PercentageCrossedCondition = new TravelPathConditionModel(travelPath)
51
+ PercentageCrossedCondition.validate((err, res) => {
52
52
  assert.notExists(res)
53
53
  assert.exists(err, 'err object should exist')
54
54
  assert.isObject(err)
@@ -2,7 +2,7 @@ let mongoose = require('mongoose')
2
2
 
3
3
  mongoose.Promise = global.Promise
4
4
 
5
- let SpeedFilterModel = require('../../../Models').Speed(mongoose)
5
+ let SpeedConditionModel = require('../../../Models').Speed(mongoose)
6
6
  let testCase = require('mocha').describe
7
7
  let assertions = require('mocha').it
8
8
  let chai = require('chai')
@@ -13,17 +13,17 @@ let beforeEach = mocha.beforeEach
13
13
 
14
14
  let rules = require('./speed.rules.json')
15
15
 
16
- let speedFilter
16
+ let speedCondition
17
17
 
18
18
  beforeEach(() => {
19
- speedFilter = JSON.parse(JSON.stringify(require('./speed.data.json')))
19
+ speedCondition = JSON.parse(JSON.stringify(require('./speed.data.json')))
20
20
  })
21
21
 
22
- testCase('SpeedFilter', () => {
23
- testCase('Valid SpeedFilter', () => {
24
- assertions('should validate a valid speedFilter ', (done) => {
25
- let SpeedFilter = new SpeedFilterModel(speedFilter)
26
- SpeedFilter.validate((err, res) => {
22
+ testCase('SpeedCondition', () => {
23
+ testCase('Valid SpeedCondition', () => {
24
+ assertions('should validate a valid speedCondition ', (done) => {
25
+ let SpeedCondition = new SpeedConditionModel(speedCondition)
26
+ SpeedCondition.validate((err, res) => {
27
27
  assert.notExists(res)
28
28
  assert(err === null, 'err should equals null')
29
29
  done()
@@ -31,21 +31,21 @@ testCase('SpeedFilter', () => {
31
31
  })
32
32
  })
33
33
 
34
- testCase('Invalid SpeedFilter', () => {
35
- assertions('should not validate a speedFilter with invalid SpeedFilter', (done) => {
36
- delete speedFilter[rules.requiredFields[0]]
37
- let SpeedFilter = new SpeedFilterModel(speedFilter)
38
- SpeedFilter.validate((err, res) => {
34
+ testCase('Invalid SpeedCondition', () => {
35
+ assertions('should not validate a speedCondition with invalid SpeedCondition', (done) => {
36
+ delete speedCondition[rules.requiredFields[0]]
37
+ let SpeedCondition = new SpeedConditionModel(speedCondition)
38
+ SpeedCondition.validate((err, res) => {
39
39
  assert.exists(err, 'err object should exist')
40
40
  assert.isObject(err)
41
41
  done()
42
42
  })
43
43
  })
44
44
  assertions('should throw an error when maxSpeed is less than 5 of minSpeed', (done) => {
45
- speedFilter.minimumSpeed = 10
46
- speedFilter.maximumSpeed = 11
47
- let SpeedFilter = new SpeedFilterModel(speedFilter)
48
- SpeedFilter.validate((err, res) => {
45
+ speedCondition.minimumSpeed = 10
46
+ speedCondition.maximumSpeed = 11
47
+ let SpeedCondition = new SpeedConditionModel(speedCondition)
48
+ SpeedCondition.validate((err, res) => {
49
49
  assert.exists(err, 'err object should exist')
50
50
  assert.isObject(err)
51
51
  assert.nestedProperty(err, `errors.maximumSpeed`, 'error should have a maximumSpeed property')
@@ -56,10 +56,10 @@ testCase('SpeedFilter', () => {
56
56
  let requiredFields = rules.requiredFields
57
57
  requiredFields.map((i) => {
58
58
  assertions(`should throw an error with property '${i}' if '${i}' is not present`, (done) => {
59
- // delete i from geofeatures' speedFilter child
60
- delete speedFilter[i]
61
- let SpeedFilter = new SpeedFilterModel(speedFilter)
62
- SpeedFilter.validate((err, res) => {
59
+ // delete i from geofeatures' speedCondition child
60
+ delete speedCondition[i]
61
+ let SpeedCondition = new SpeedConditionModel(speedCondition)
62
+ SpeedCondition.validate((err, res) => {
63
63
  assert.notExists(res)
64
64
  assert.exists(err, 'err object should exist')
65
65
  assert.isObject(err)
@@ -1,5 +1,5 @@
1
1
  {
2
- "type": "timeActiveFilter",
2
+ "type": "timeActiveCondition",
3
3
  "fromTime": "00:30:00",
4
4
  "toTime": "20:30:00"
5
5
  }
@@ -2,7 +2,7 @@ let mongoose = require('mongoose')
2
2
 
3
3
  mongoose.Promise = global.Promise
4
4
 
5
- let TimeActiveFilterModel = require('../../../Models').TimeActive(mongoose)
5
+ let TimeActiveConditionModel = require('../../../Models').TimeActive(mongoose)
6
6
  let testCase = require('mocha').describe
7
7
  let assertions = require('mocha').it
8
8
  let chai = require('chai')
@@ -12,17 +12,17 @@ let beforeEach = mocha.beforeEach
12
12
 
13
13
  let rules = require('./timeActive.rules.json')
14
14
 
15
- let timeActiveFilter
15
+ let timeActiveCondition
16
16
 
17
17
  beforeEach(() => {
18
- timeActiveFilter = JSON.parse(JSON.stringify(require('./timeActive.data.json')))
18
+ timeActiveCondition = JSON.parse(JSON.stringify(require('./timeActive.data.json')))
19
19
  })
20
20
 
21
- testCase('TimeOfDayRangeFilter', () => {
22
- testCase('Valid TimeOfDayRangeFilter', () => {
23
- assertions('should validate a valid timeActiveFilter ', (done) => {
24
- let TimeOfDayRangeFilter = new TimeActiveFilterModel(timeActiveFilter)
25
- TimeOfDayRangeFilter.validate((err, res) => {
21
+ testCase('TimeOfDayRangeCondition', () => {
22
+ testCase('Valid TimeOfDayRangeCondition', () => {
23
+ assertions('should validate a valid timeActiveCondition ', (done) => {
24
+ let TimeOfDayRangeCondition = new TimeActiveConditionModel(timeActiveCondition)
25
+ TimeOfDayRangeCondition.validate((err, res) => {
26
26
  assert.notExists(res)
27
27
  assert(err === null, 'err should equals null')
28
28
  done()
@@ -30,21 +30,21 @@ testCase('TimeOfDayRangeFilter', () => {
30
30
  })
31
31
  })
32
32
 
33
- testCase('Invalid TimeOfDayRangeFilter', () => {
34
- assertions('should not validate a timeActiveFilter with invalid TimeOfDayRangeFilter', (done) => {
35
- delete timeActiveFilter[rules.requiredFields[0]]
36
- let TimeOfDayRangeFilter = new TimeActiveFilterModel(timeActiveFilter)
37
- TimeOfDayRangeFilter.validate((err, res) => {
33
+ testCase('Invalid TimeOfDayRangeCondition', () => {
34
+ assertions('should not validate a timeActiveCondition with invalid TimeOfDayRangeCondition', (done) => {
35
+ delete timeActiveCondition[rules.requiredFields[0]]
36
+ let TimeOfDayRangeCondition = new TimeActiveConditionModel(timeActiveCondition)
37
+ TimeOfDayRangeCondition.validate((err, res) => {
38
38
  assert.exists(err, 'err object should exist')
39
39
  assert.isObject(err)
40
40
  done()
41
41
  })
42
42
  })
43
43
  assertions('should throw an error when toTime === fromTime', (done) => {
44
- timeActiveFilter.toTime = "00:30:00"
45
- timeActiveFilter.fromTime = "00:30:00"
46
- let TimeOfDayRangeFilter = new TimeActiveFilterModel(timeActiveFilter)
47
- TimeOfDayRangeFilter.validate((err, res) => {
44
+ timeActiveCondition.toTime = "00:30:00"
45
+ timeActiveCondition.fromTime = "00:30:00"
46
+ let TimeOfDayRangeCondition = new TimeActiveConditionModel(timeActiveCondition)
47
+ TimeOfDayRangeCondition.validate((err, res) => {
48
48
  assert.exists(err, 'err object should exist')
49
49
  assert.isObject(err)
50
50
  assert.nestedProperty(err, `errors.toTime`, 'error should have a toTime property')
@@ -58,10 +58,10 @@ testCase('TimeOfDayRangeFilter', () => {
58
58
  invalidTimes.map(i => {
59
59
  i.invalidInput.map(j => {
60
60
  assertions(`should throw an error with property '${i.name}' if '${i.name} is invalid => ${i.name} = ${j}'`, done => {
61
- timeActiveFilter = JSON.parse(JSON.stringify(timeActiveFilter))
62
- timeActiveFilter[i.name] = j
63
- let TimeOfDayRangeFilter = new TimeActiveFilterModel(timeActiveFilter)
64
- TimeOfDayRangeFilter.validate((err, res) => {
61
+ timeActiveCondition = JSON.parse(JSON.stringify(timeActiveCondition))
62
+ timeActiveCondition[i.name] = j
63
+ let TimeOfDayRangeCondition = new TimeActiveConditionModel(timeActiveCondition)
64
+ TimeOfDayRangeCondition.validate((err, res) => {
65
65
  assert.exists(err, 'err object should exits')
66
66
  assert.isObject(err)
67
67
  assert.nestedProperty(err, `errors.${i.name}`, 'time format must be hh:mm:ss')
@@ -77,10 +77,10 @@ testCase('TimeOfDayRangeFilter', () => {
77
77
  let requiredFields = rules.requiredFields
78
78
  requiredFields.map((i) => {
79
79
  assertions(`should throw an error with property '${i}' if '${i}' is not present`, (done) => {
80
- // delete i from geofeatures' timeActiveFilter child
81
- delete timeActiveFilter[i]
82
- let TimeOfDayRangeFilter = new TimeActiveFilterModel(timeActiveFilter)
83
- TimeOfDayRangeFilter.validate((err, res) => {
80
+ // delete i from geofeatures' timeActiveCondition child
81
+ delete timeActiveCondition[i]
82
+ let TimeOfDayRangeCondition = new TimeActiveConditionModel(timeActiveCondition)
83
+ TimeOfDayRangeCondition.validate((err, res) => {
84
84
  assert.notExists(res)
85
85
  assert.exists(err, 'err object should exist')
86
86
  assert.isObject(err)
@@ -2,7 +2,7 @@ let mongoose = require('mongoose')
2
2
  mongoose.Promise = global.Promise
3
3
 
4
4
  const TravelDirectionModel = require('../../../Models').TravelDirection(mongoose)
5
- const { isMinimumNinetyApart } = require.main.require('models/filters/TravelDirection')
5
+ const { isMinimumNinetyApart } = require.main.require('models/conditions/TravelDirection')
6
6
  const describe = require('mocha').describe
7
7
  const it = require('mocha').it
8
8
  const chai = require('chai')
@@ -11,16 +11,16 @@ const mocha = require('mocha')
11
11
  const beforeEach = mocha.beforeEach
12
12
  const rules = require('./travelDirection.rules.json')
13
13
 
14
- let travelDirectionFilter
14
+ let travelDirectionCondition
15
15
 
16
16
  beforeEach(() => {
17
- travelDirectionFilter = JSON.parse(JSON.stringify(require('./travelDirection.data.json')))
17
+ travelDirectionCondition = JSON.parse(JSON.stringify(require('./travelDirection.data.json')))
18
18
  })
19
19
 
20
20
  describe('TravelDirection', () => {
21
21
  describe('Valid TravelDirection', () => {
22
- it('should validate a valid travelDirectionFilter ', (done) => {
23
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
22
+ it('should validate a valid travelDirectionCondition ', (done) => {
23
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
24
24
  TravelDirection.validate((err, res) => {
25
25
  assert.notExists(res)
26
26
  assert(err === null, 'err should equals null')
@@ -30,9 +30,9 @@ describe('TravelDirection', () => {
30
30
  })
31
31
 
32
32
  describe('Invalid TravelDirection', () => {
33
- it('should not validate a travelDirectionFilter with invalid TravelDirection', (done) => {
34
- delete travelDirectionFilter[rules.requiredFields[0]]
35
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
33
+ it('should not validate a travelDirectionCondition with invalid TravelDirection', (done) => {
34
+ delete travelDirectionCondition[rules.requiredFields[0]]
35
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
36
36
  TravelDirection.validate((err, res) => {
37
37
  assert.exists(err, 'err object should exist')
38
38
  assert.isObject(err)
@@ -40,9 +40,9 @@ describe('TravelDirection', () => {
40
40
  })
41
41
  })
42
42
  it('should throw an error when toAngle === fromAngle', (done) => {
43
- travelDirectionFilter.toAngle = 10
44
- travelDirectionFilter.fromAngle = 10
45
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
43
+ travelDirectionCondition.toAngle = 10
44
+ travelDirectionCondition.fromAngle = 10
45
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
46
46
  TravelDirection.validate((err, res) => {
47
47
  assert.exists(err, 'err object should exist')
48
48
  assert.isObject(err)
@@ -51,9 +51,9 @@ describe('TravelDirection', () => {
51
51
  })
52
52
  })
53
53
  it('should throw an error when toAngle < 90 degrees from fromAngle (and toAngle < fromAngle)', (done) => {
54
- travelDirectionFilter.toAngle = 5
55
- travelDirectionFilter.fromAngle = 10
56
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
54
+ travelDirectionCondition.toAngle = 5
55
+ travelDirectionCondition.fromAngle = 10
56
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
57
57
  TravelDirection.validate((err, res) => {
58
58
  assert.exists(err, 'err object should exist')
59
59
  assert.isObject(err)
@@ -62,9 +62,9 @@ describe('TravelDirection', () => {
62
62
  })
63
63
  })
64
64
  it('should throw an error when toAngle < 90 degrees from fromAngle (and toAngle > fromAngle)', (done) => {
65
- travelDirectionFilter.toAngle = 10
66
- travelDirectionFilter.fromAngle = 5
67
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
65
+ travelDirectionCondition.toAngle = 10
66
+ travelDirectionCondition.fromAngle = 5
67
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
68
68
  TravelDirection.validate((err, res) => {
69
69
  assert.exists(err, 'err object should exist')
70
70
  assert.isObject(err)
@@ -76,9 +76,9 @@ describe('TravelDirection', () => {
76
76
  let requiredFields = rules.requiredFields
77
77
  requiredFields.map((i) => {
78
78
  it(`should throw an error with property '${i}' if '${i}' is not present`, (done) => {
79
- // delete i from geofeatures' travelDirectionFilter child
80
- delete travelDirectionFilter[i]
81
- let TravelDirection = new TravelDirectionModel(travelDirectionFilter)
79
+ // delete i from geofeatures' travelDirectionCondition child
80
+ delete travelDirectionCondition[i]
81
+ let TravelDirection = new TravelDirectionModel(travelDirectionCondition)
82
82
  TravelDirection.validate((err, res) => {
83
83
  assert.notExists(res)
84
84
  assert.exists(err, 'err object should exist')
@@ -13,5 +13,6 @@
13
13
  "securityToken" : "value"
14
14
  }
15
15
  },
16
- "firebaseApiKey": "88888888-4444-4444-4444-121212121212"
16
+ "firebaseApiKey": "88888888-4444-4444-4444-121212121212",
17
+ "apiKey": "88888888-4444-4444-4444-123412341234"
17
18
  }
@@ -94,6 +94,17 @@ describe('User', () => {
94
94
  })
95
95
  })
96
96
 
97
+ it('should fail if projectId is missing', (done) => {
98
+ user = JSON.parse(JSON.stringify(user))
99
+ user.projectPermissions[0].projectId = undefined
100
+ const User = new UserModel(user)
101
+
102
+ User.validate((err, res) => {
103
+ assert.match(err, /(Path `projectId` is required.)/i)
104
+ done()
105
+ })
106
+ })
107
+
97
108
  it('should fail if permissionLevel is invalid', (done) => {
98
109
  user = JSON.parse(JSON.stringify(user))
99
110
  user.projectPermissions[0].permissionLevel = 'INVALID'
@@ -104,5 +115,16 @@ describe('User', () => {
104
115
  done()
105
116
  })
106
117
  })
118
+
119
+ it('should fail if permissionLevel is missing', (done) => {
120
+ user = JSON.parse(JSON.stringify(user))
121
+ user.projectPermissions[0].permissionLevel = undefined
122
+ const User = new UserModel(user)
123
+
124
+ User.validate((err, res) => {
125
+ assert.match(err, /(Path `permissionLevel` is required.)/i)
126
+ done()
127
+ })
128
+ })
107
129
  })
108
130
  })
@@ -14,8 +14,8 @@ let zone
14
14
 
15
15
  beforeEach(() => {
16
16
  zone = JSON.parse(JSON.stringify(require('./zone.data.json')))
17
- // remove filters as it's not tested
18
- delete zone.filters
17
+ // remove conditions as it's not tested
18
+ delete zone.conditions
19
19
  // remove all but 1 geofeatures as geofeatures are required
20
20
  zone.geofeatures = zone.geofeatures.filter(x => x.type.match(/circle/i))
21
21
  // remove customData
@@ -0,0 +1,76 @@
1
+ let mongoose = require('mongoose')
2
+
3
+ mongoose.Promise = global.Promise
4
+
5
+ let ZoneModel = require('../../models/Zone').Model(mongoose)
6
+ let testCase = require('mocha').describe
7
+ let assertions = require('mocha').it
8
+ let chai = require('chai')
9
+ let assert = chai.assert
10
+ let mocha = require('mocha')
11
+ let beforeEach = mocha.beforeEach
12
+
13
+ let zone
14
+ let geofeatures
15
+
16
+ beforeEach(() => {
17
+ zone = JSON.parse(JSON.stringify(require('./zone.data.json')))
18
+ // remove actions as it's not tested
19
+ delete zone.actions
20
+ // remove all but 1 geofeatures as geofeatures are required
21
+ geofeatures = zone.geofeatures
22
+ zone.geofeatures = zone.geofeatures.filter(x => x.type.match(/circle/i))
23
+ // remove customData
24
+ delete zone.customData
25
+ })
26
+
27
+ testCase('Zone - Condition', () => {
28
+ testCase('Valid Zone - Condition', () => {
29
+ assertions('should not throw an error when a valid condition is instantiated within a zone', (done) => {
30
+ let Zone = new ZoneModel(zone)
31
+ Zone.validate((err, res) => {
32
+ assert.notExists(res)
33
+ assert(err === null, 'err equals null')
34
+ done()
35
+ })
36
+ })
37
+ })
38
+
39
+ testCase('Invalid Zone - Condition', () => {
40
+ assertions('should throw an error when an invalid condition is instantiated within a zone', (done) => {
41
+ zone.conditions[0].startDate = 'abc'
42
+ let Zone = new ZoneModel(zone)
43
+ Zone.validate((err, res) => {
44
+ assert.exists(err, 'err object should exist')
45
+ assert.isObject(err)
46
+ assert('conditions.0.startDate' in err.errors)
47
+ assert.notNestedProperty(err, `errors.geofeatures`, 'error should have a url property')
48
+ done()
49
+ })
50
+ })
51
+ assertions('should not throw an error when a valid condition is instantiated within a zone', (done) => {
52
+ let Zone = new ZoneModel(zone)
53
+ Zone.validate((err, res) => {
54
+ assert.notExists(res)
55
+ assert(err === null, 'err equals null')
56
+ done()
57
+ })
58
+ })
59
+ assertions('should throw an error when the minimumGeofeaturesCrossed for a travel path condition is greater than the total number of geofeatures', (done) => {
60
+ zone.geofeatures = geofeatures
61
+ zone.conditions.push({
62
+ "type" : "travelPath",
63
+ "minimumGeofeaturesCrossed" : zone.geofeatures.length+1,
64
+ "timeOutSeconds": 120,
65
+ "sequential" : false
66
+ })
67
+ let Zone = new ZoneModel(zone)
68
+ Zone.validate((err, res) => {
69
+ assert.exists(err, 'err object should exist')
70
+ assert(err instanceof Error)
71
+ assert(err.message.includes("Zone must not have minimumGeofeaturesCrossed higher than geofeatures count"))
72
+ done()
73
+ })
74
+ })
75
+ })
76
+ })
@@ -22,7 +22,7 @@
22
22
  }
23
23
  ],
24
24
  "beacons": [],
25
- "filters": [
25
+ "conditions": [
26
26
  {
27
27
  "type" : "dayRange",
28
28
  "startDate" : "2017-11-14",
@@ -14,8 +14,8 @@ let zone
14
14
 
15
15
  beforeEach(() => {
16
16
  zone = JSON.parse(JSON.stringify(require('./zone.data.json')))
17
- // remove filters as it's not tested
18
- delete zone.filters
17
+ // remove conditions as it's not tested
18
+ delete zone.conditions
19
19
 
20
20
  // geofeatures are tested individually so we only need to try one in Zones' test
21
21
  zone.geofeatures = zone.geofeatures.filter(x => x.type.match(/beacon/i))
@@ -90,13 +90,13 @@ describe('Zone', () => {
90
90
  })
91
91
  })
92
92
 
93
- it('should throw an error when a filter is invalid', (done) => {
94
- zone.filters[0].startDate = 'abc'
93
+ it('should throw an error when a condition is invalid', (done) => {
94
+ zone.conditions[0].startDate = 'abc'
95
95
  let Zone = new ZoneModel(zone)
96
96
  Zone.validate((err, res) => {
97
97
  assert.exists(err, 'err object should exist')
98
98
  assert.isObject(err)
99
- assert('filters.0.startDate' in err.errors, `errors should have a 'filters.0.startDate' property`)
99
+ assert('conditions.0.startDate' in err.errors, `errors should have a 'conditions.0.startDate' property`)
100
100
  done()
101
101
  })
102
102
  })
@@ -111,8 +111,8 @@ describe('Zone', () => {
111
111
  })
112
112
  })
113
113
 
114
- it('should throw an error when it contains both a beacon and a travelDirection filter', (done) => {
115
- zone.filters.push(require('../filter/travelDirection/travelDirection.data.json'));
114
+ it('should throw an error when it contains both a beacon and a travelDirection condition', (done) => {
115
+ zone.conditions.push(require('../condition/travelDirection/travelDirection.data.json'));
116
116
  let Zone = new ZoneModel(zone)
117
117
  Zone.validate((err, res) => {
118
118
  assert.exists(err, 'err object should exist')
@@ -121,8 +121,8 @@ describe('Zone', () => {
121
121
  })
122
122
  })
123
123
 
124
- it('should throw an error when it contains both a beacon and a speed filter', (done) => {
125
- zone.filters.push(require('../filter/speed/speed.data.json'));
124
+ it('should throw an error when it contains both a beacon and a speed condition', (done) => {
125
+ zone.conditions.push(require('../condition/speed/speed.data.json'));
126
126
  let Zone = new ZoneModel(zone)
127
127
  Zone.validate((err, res) => {
128
128
  assert.exists(err, 'err object should exist')
package/helpers.js CHANGED
@@ -61,7 +61,7 @@ helpers.checkIsDifferent = function(propertyName) {
61
61
  }
62
62
  }
63
63
 
64
- helpers.checkFiltersSuitableForBeacon = function(zone, next) {
64
+ helpers.checkConditionsSuitableForBeacon = function(zone, next) {
65
65
  let hasBeacons = false;
66
66
  if( zone.geofeatures && zone.geofeatures.length ) {
67
67
  for( let geofeature of zone.geofeatures ) {
@@ -73,14 +73,27 @@ helpers.checkFiltersSuitableForBeacon = function(zone, next) {
73
73
  }
74
74
  if( !hasBeacons )
75
75
  return next(); // No beacons.
76
- if( !zone.filters || !zone.filters.length )
77
- return next(); // No filters.
78
- for( let filter of zone.filters ) {
79
- if( filter.type === "travelDirection" ) {
80
- return next(new Error("Zone cannot both contain a beacon and have a Travel Direction filter."))
76
+ if( !zone.conditions || !zone.conditions.length )
77
+ return next(); // No conditions.
78
+ for( let condition of zone.conditions ) {
79
+ if( condition.type === "travelDirection" ) {
80
+ return next(new Error("Zone cannot both contain a beacon and have a Travel Direction condition."))
81
81
  }
82
- if( filter.type === "speed" ) {
83
- return next(new Error("Zone cannot both contain a beacon and have a Speed filter."))
82
+ if( condition.type === "speed" ) {
83
+ return next(new Error("Zone cannot both contain a beacon and have a Speed condition."))
84
+ }
85
+ }
86
+ next();
87
+ }
88
+
89
+ helpers.checkMinimumGeofeaturesValidForZone = function(zone, next) {
90
+ if( !zone.geofeatures )
91
+ return next();
92
+ if( !zone.conditions || !zone.conditions.length )
93
+ return next(); // No conditions.
94
+ for( let condition of zone.conditions ) {
95
+ if( condition.type === "travelPath" && condition.minimumGeofeaturesCrossed > zone.geofeatures.length ) {
96
+ return next(new Error("Zone must not have minimumGeofeaturesCrossed higher than geofeatures count"))
84
97
  }
85
98
  }
86
99
  next();
package/models/Beacon.js CHANGED
@@ -39,8 +39,6 @@ BeaconSchema.index({ macAddress: 1 })
39
39
  BeaconSchema.index({ proximityUUID: 1, major: 1, minor: 1 })
40
40
  BeaconSchema.index({ accountId: 1, geometry: '2dsphere' })
41
41
 
42
- // accountId: 1, geometry: "2dsphere"
43
-
44
42
  BeaconSchema.plugin(patcher)
45
43
 
46
44
  // mongoose validator helper plugin
package/models/Project.js CHANGED
@@ -15,8 +15,6 @@ let WebhookSchema = require('../schemas/Webhook')
15
15
 
16
16
  let ProjectSchema = new mongoose.Schema({
17
17
  _id: {type: String, default: uuidv4},
18
- apiKey: {type: String, default: uuidv4}, // Backwards compatability
19
- state: {type: String, default: StateEnum.active},
20
18
  nextRuleUpdateInterval: {
21
19
  type: Number,
22
20
  required: [true, 'nextRuleUpdateInterval is required'],
@@ -34,7 +32,8 @@ let ProjectSchema = new mongoose.Schema({
34
32
  accountId: {type: String, required: true, validate: {isAsync: false, validator: helpers.validateUUIDv4, msg: 'default error message'}},
35
33
  webhooks: [WebhookSchema],
36
34
  configurationParameters: {type: Schema.Types.Mixed, default: null}, // http://collab.bluedot.io/display/PD/Remote+configuration
37
- firebaseApiKey: {type: String} // BP-491
35
+ firebaseApiKey: {type: String},
36
+ apiKey: {type: String}
38
37
  },
39
38
  {collection: 'project'})
40
39
 
package/models/Zone.js CHANGED
@@ -15,12 +15,12 @@ let polylineSchema = require('./geofeatures/Polyline').polylineSchema
15
15
  let polygonSchema = require('./geofeatures/Polygon').polygonSchema
16
16
  let beaconSchema = require('./geofeatures/ZoneBeacon').beaconSchema
17
17
 
18
- // Filters
19
- let speedRawSchema = require('./filters/Speed').rawSchema
20
- let dayRangeRawSchema = require('./filters/DayRange').rawSchema
21
- let travelDirectionRawSchema = require('./filters/TravelDirection').rawSchema
22
- let travelPathRawSchema = require('./filters/TravelPath').rawSchema
23
- let timeActiveRawSchema = require('./filters/TimeActive').rawSchema
18
+ // Conditions
19
+ let speedRawSchema = require('./conditions/Speed').rawSchema
20
+ let dayRangeRawSchema = require('./conditions/DayRange').rawSchema
21
+ let travelDirectionRawSchema = require('./conditions/TravelDirection').rawSchema
22
+ let travelPathRawSchema = require('./conditions/TravelPath').rawSchema
23
+ let timeActiveRawSchema = require('./conditions/TimeActive').rawSchema
24
24
 
25
25
  let uuidv4 = require('uuid/v4')
26
26
  let patcher = require('mongoose-json-patch')
@@ -38,7 +38,7 @@ let customDataValidators = [
38
38
  let actionSchema = new Schema({},
39
39
  { discriminatorKey: 'type', _id: false })
40
40
 
41
- let filterSchema = new Schema({},
41
+ let conditionSchema = new Schema({},
42
42
  { discriminatorKey: 'type', _id: false })
43
43
 
44
44
  let geofeatureSchema = new Schema({},
@@ -58,8 +58,8 @@ let zoneSchema = new Schema({
58
58
  }
59
59
  },
60
60
  tags: {type: [String]},
61
- filters: {
62
- type: [filterSchema]
61
+ conditions: {
62
+ type: [conditionSchema]
63
63
  },
64
64
  actions: {
65
65
  type: [actionSchema]
@@ -83,11 +83,11 @@ zoneSchema.plugin(patcher)
83
83
  zoneSchema.path('actions').discriminator('url', new Schema(urlActionSchema, {_id: false}))
84
84
  zoneSchema.path('actions').discriminator('message', new Schema(messageActionSchema, {_id: false}))
85
85
 
86
- zoneSchema.path('filters').discriminator('dayRange', new Schema(dayRangeRawSchema, {_id: false}))
87
- zoneSchema.path('filters').discriminator('speed', new Schema(speedRawSchema, {_id: false}))
88
- zoneSchema.path('filters').discriminator('timeActive', new Schema(timeActiveRawSchema, {_id: false}))
89
- zoneSchema.path('filters').discriminator('travelDirection', new Schema(travelDirectionRawSchema, {_id: false}))
90
- zoneSchema.path('filters').discriminator('travelPath', new Schema(travelPathRawSchema, {_id: false}))
86
+ zoneSchema.path('conditions').discriminator('dayRange', new Schema(dayRangeRawSchema, {_id: false}))
87
+ zoneSchema.path('conditions').discriminator('speed', new Schema(speedRawSchema, {_id: false}))
88
+ zoneSchema.path('conditions').discriminator('timeActive', new Schema(timeActiveRawSchema, {_id: false}))
89
+ zoneSchema.path('conditions').discriminator('travelDirection', new Schema(travelDirectionRawSchema, {_id: false}))
90
+ zoneSchema.path('conditions').discriminator('travelPath', new Schema(travelPathRawSchema, {_id: false}))
91
91
 
92
92
  zoneSchema.path('geofeatures').discriminator('beacon', new Schema(beaconSchema))
93
93
  zoneSchema.path('geofeatures').discriminator('circle', new Schema(circleSchema))
@@ -96,7 +96,16 @@ zoneSchema.path('geofeatures').discriminator('polyline', new Schema(polylineSche
96
96
  zoneSchema.path('geofeatures').discriminator('boundingBox', new Schema(boundingBoxSchema))
97
97
 
98
98
  zoneSchema.pre('validate', function(next) {
99
- helpers.checkFiltersSuitableForBeacon(this, next)
99
+ Promise.all([
100
+ new Promise((resolve, reject) => helpers.checkConditionsSuitableForBeacon(this, resolve)),
101
+ new Promise((resolve, reject) => helpers.checkMinimumGeofeaturesValidForZone(this, resolve))
102
+ ]).then(results => {
103
+ for( let result of results ) {
104
+ if( result )
105
+ return next(result)
106
+ }
107
+ next()
108
+ });
100
109
  })
101
110
 
102
111
  // optional mongoose
@@ -6,12 +6,12 @@ let schema = {
6
6
  endDate: {type: Date}
7
7
  }
8
8
 
9
- let DayRangeFilterSchema = new mongoose.Schema(schema, {
9
+ let DayRangeConditionSchema = new mongoose.Schema(schema, {
10
10
  _id: false,
11
11
  versionKey: false
12
12
  })
13
13
 
14
- DayRangeFilterSchema.add({
14
+ DayRangeConditionSchema.add({
15
15
  type: {type: String, required: true, validate: {isAsync: true, validator: validateDateRange}}
16
16
  })
17
17
 
@@ -39,14 +39,14 @@ function validateDateRange (type, callback) {
39
39
 
40
40
  // optional mongoose
41
41
  let model = (mongooseInstance) => {
42
- let DayRangeFilter
42
+ let DayRangeCondition
43
43
  if (mongooseInstance) {
44
- DayRangeFilter = mongooseInstance.model('DayRangeFilter', DayRangeFilterSchema)
44
+ DayRangeCondition = mongooseInstance.model('DayRangeCondition', DayRangeConditionSchema)
45
45
  } else {
46
- DayRangeFilter = mongoose.model('DayRangeFilter', DayRangeFilterSchema)
46
+ DayRangeCondition = mongoose.model('DayRangeCondition', DayRangeConditionSchema)
47
47
  }
48
48
 
49
- return DayRangeFilter
49
+ return DayRangeCondition
50
50
  }
51
51
  // Exports Mongoose Model, Mongoose Schema, JSON schema (required locally for discriminators)
52
- module.exports = { Model: model, Schema: DayRangeFilterSchema, rawSchema: schema }
52
+ module.exports = { Model: model, Schema: DayRangeConditionSchema, rawSchema: schema }
@@ -5,12 +5,12 @@ let schema = {
5
5
  minimumSpeed: {type: Number, required: [true, 'minimumSpeed is required. '], min: 0},
6
6
  maximumSpeed: {type: Number, required: true, validate: {isAsync: true, validator: validateMaxSpeed, msg: 'default error message'}}
7
7
  }
8
- let SpeedFilterSchema = new mongoose.Schema(schema, {
8
+ let SpeedConditionSchema = new mongoose.Schema(schema, {
9
9
  _id: false,
10
10
  versionKey: false
11
11
  })
12
12
 
13
- SpeedFilterSchema.add({
13
+ SpeedConditionSchema.add({
14
14
  type: {type: String, required: true}
15
15
  })
16
16
 
@@ -29,14 +29,14 @@ function validateMaxSpeed (v, magicCallback) {
29
29
 
30
30
  // optional mongoose
31
31
  let model = (mongooseInstance) => {
32
- let SpeedFilter
32
+ let SpeedCondition
33
33
  if (mongooseInstance) {
34
- SpeedFilter = mongooseInstance.model('SpeedFilter', SpeedFilterSchema)
34
+ SpeedCondition = mongooseInstance.model('SpeedCondition', SpeedConditionSchema)
35
35
  } else {
36
- SpeedFilter = mongoose.model('SpeedFilter', SpeedFilterSchema)
36
+ SpeedCondition = mongoose.model('SpeedCondition', SpeedConditionSchema)
37
37
  }
38
38
 
39
- return SpeedFilter
39
+ return SpeedCondition
40
40
  }
41
41
  // Exports Mongoose Model, Mongoose Schema, JSON schema (required locally for discriminators)
42
- module.exports = { Model: model, Schema: SpeedFilterSchema, rawSchema: schema }
42
+ module.exports = { Model: model, Schema: SpeedConditionSchema, rawSchema: schema }
@@ -3,14 +3,14 @@ let uuidv4 = require('uuid/v4')
3
3
 
4
4
  let schema = {
5
5
  fromTime: {type: String, required: [true, 'time is required. '], validate: {isAsync: true, validator: validateTimeHHmmssFormat}},
6
- toTime: {type: String, required: true, validate: [{isAsync: true, validator: validateTimeHHmmssFormat}, {isAsync: true, validator: validateTime}]}
6
+ toTime: {type: String, required: true, validate: [{isAsync: true, validator: validateTime}, {isAsync: true, validator: validateTimeHHmmssFormat}]}
7
7
  }
8
- let TimeActiveFilterSchema = new mongoose.Schema(schema, {
8
+ let TimeActiveConditionSchema = new mongoose.Schema(schema, {
9
9
  _id: false,
10
10
  versionKey: false
11
11
  })
12
12
 
13
- TimeActiveFilterSchema.add({
13
+ TimeActiveConditionSchema.add({
14
14
  type: {type: String, required: true}
15
15
  })
16
16
 
@@ -36,15 +36,15 @@ function validateTimeHHmmssFormat(time, magicCallback) {
36
36
 
37
37
  // optional mongoose
38
38
  let model = (mongooseInstance) => {
39
- let TimeActiveFilter
39
+ let TimeActiveCondition
40
40
  if (mongooseInstance) {
41
- TimeActiveFilter = mongooseInstance.model('TimeActiveFilter', TimeActiveFilterSchema)
41
+ TimeActiveCondition = mongooseInstance.model('TimeActiveCondition', TimeActiveConditionSchema)
42
42
  } else {
43
- TimeActiveFilter = mongoose.model('TimeActiveFilter', TimeActiveFilterSchema)
43
+ TimeActiveCondition = mongoose.model('TimeActiveCondition', TimeActiveConditionSchema)
44
44
  }
45
45
 
46
- return TimeActiveFilter
46
+ return TimeActiveCondition
47
47
  }
48
48
 
49
49
  // Exports Mongoose Model, Mongoose Schema, JSON schema (required locally for discriminators)
50
- module.exports = { Model: model, Schema: TimeActiveFilterSchema, rawSchema: schema }
50
+ module.exports = { Model: model, Schema: TimeActiveConditionSchema, rawSchema: schema }
@@ -6,13 +6,13 @@ const schema = {
6
6
  toAngle: {type: Number, required: true, min: 0, max: 359, validate: {isAsync: true, validator: validateAngles, msg: 'default error message'}}
7
7
  }
8
8
 
9
- const TravelDirectionFilterSchema = new mongoose.Schema(schema, {
9
+ const TravelDirectionConditionSchema = new mongoose.Schema(schema, {
10
10
  _id: false,
11
11
  versionKey: false
12
12
  })
13
13
 
14
14
  // For discriminator key
15
- TravelDirectionFilterSchema.add({
15
+ TravelDirectionConditionSchema.add({
16
16
  type: {type: String, required: true}
17
17
  })
18
18
 
@@ -49,19 +49,19 @@ function isMinimumNinetyApart (fromAngle, toAngle) {
49
49
 
50
50
  // optional mongoose
51
51
  let model = (mongooseInstance) => {
52
- let TravelDirectionFilter
52
+ let TravelDirectionCondition
53
53
  if (mongooseInstance) {
54
- TravelDirectionFilter = mongooseInstance.model('TravelDirectionFilter', TravelDirectionFilterSchema)
54
+ TravelDirectionCondition = mongooseInstance.model('TravelDirectionCondition', TravelDirectionConditionSchema)
55
55
  } else {
56
- TravelDirectionFilter = mongoose.model('TravelDirectionFilter', TravelDirectionFilterSchema)
56
+ TravelDirectionCondition = mongoose.model('TravelDirectionCondition', TravelDirectionConditionSchema)
57
57
  }
58
58
 
59
- return TravelDirectionFilter
59
+ return TravelDirectionCondition
60
60
  }
61
61
  // Exports Mongoose Model, Mongoose Schema, JSON schema (required locally for discriminators)
62
62
  module.exports = {
63
63
  Model: model,
64
- Schema: TravelDirectionFilterSchema,
64
+ Schema: TravelDirectionConditionSchema,
65
65
  rawSchema: schema,
66
66
  isMinimumNinetyApart
67
67
  }
@@ -1,4 +1,4 @@
1
- // In V2 this is becoming "Travel Path" filter
1
+ // In V2 this is becoming "Travel Path" condition
2
2
  let mongoose = require('mongoose')
3
3
  let uuidv4 = require('uuid/v4')
4
4
 
@@ -6,31 +6,31 @@ let schema = {
6
6
  minimumGeofeaturesCrossed: {
7
7
  type: Number,
8
8
  required: [true, 'minimumGeofeaturesCrossed is required.'],
9
- min: 1
9
+ min: 2
10
10
  },
11
11
  timeOutSeconds: {type: Number, required: [true, 'timeOutSeconds is required. '], min: 60, max: 86400},
12
12
  sequential: {type: Boolean, default: false}
13
13
  }
14
14
 
15
- let TravelPathFilterSchema = new mongoose.Schema(schema, {
15
+ let TravelPathConditionSchema = new mongoose.Schema(schema, {
16
16
  _id: false,
17
- versionKey: false
17
+ versionKey: false
18
18
  })
19
19
 
20
- TravelPathFilterSchema.add({
20
+ TravelPathConditionSchema.add({
21
21
  type: {type: String, required: true}
22
22
  })
23
23
 
24
24
  // optional mongoose
25
25
  let model = (mongooseInstance) => {
26
- let TravelPathFilter
26
+ let TravelPathCondition
27
27
  if (mongooseInstance) {
28
- TravelPathFilter = mongooseInstance.model('TravelPathFilter', TravelPathFilterSchema)
28
+ TravelPathCondition = mongooseInstance.model('TravelPathCondition', TravelPathConditionSchema)
29
29
  } else {
30
- TravelPathFilter = mongoose.model('TravelPathFilter', TravelPathFilterSchema)
30
+ TravelPathCondition = mongoose.model('TravelPathCondition', TravelPathConditionSchema)
31
31
  }
32
32
 
33
- return TravelPathFilter
33
+ return TravelPathCondition
34
34
  }
35
35
  // Exports Mongoose Model, Mongoose Schema, JSON schema (required locally for discriminators)
36
- module.exports = { Model: model, Schema: TravelPathFilterSchema, rawSchema: schema }
36
+ module.exports = { Model: model, Schema: TravelPathConditionSchema, rawSchema: schema }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@bluedot-innovation/models",
3
- "version": "3.0.15",
3
+ "version": "3.1.0",
4
4
  "main": "Models.js",
5
5
  "scripts": {
6
6
  "lint": "./node_modules/.bin/eslint -c .eslintrc.js ./models/*.js ./__tests__/**/*.js ./__tests__/**/**/*.js ./schemas/*.js",
@@ -10,6 +10,7 @@ const ProjectPermissionSchema = new mongoose.Schema({
10
10
  },
11
11
  projectId: {
12
12
  type: String,
13
+ required: true,
13
14
  validate: {isAsync: false, validator: helpers.validateUUIDv4, msg: 'projectId not in UUID v4 format'}
14
15
  }
15
16
  }, {
@@ -1,50 +0,0 @@
1
- let mongoose = require('mongoose')
2
-
3
- mongoose.Promise = global.Promise
4
-
5
- let ZoneModel = require('../../models/Zone').Model(mongoose)
6
- let testCase = require('mocha').describe
7
- let assertions = require('mocha').it
8
- let chai = require('chai')
9
- let assert = chai.assert
10
- let mocha = require('mocha')
11
- let beforeEach = mocha.beforeEach
12
-
13
- let zone
14
-
15
- beforeEach(() => {
16
- zone = JSON.parse(JSON.stringify(require('./zone.data.json')))
17
- // remove actions as it's not tested
18
- delete zone.actions
19
- // remove all but 1 geofeatures as geofeatures are required
20
- zone.geofeatures = zone.geofeatures.filter(x => x.type.match(/circle/i))
21
- // remove customData
22
- delete zone.customData
23
- })
24
-
25
- testCase('Zone - Filter', () => {
26
- testCase('Valid Zone - Filter', () => {
27
- assertions('should not throw an error when a valid filter is instantiated within a zone', (done) => {
28
- let Zone = new ZoneModel(zone)
29
- Zone.validate((err, res) => {
30
- assert.notExists(res)
31
- assert(err === null, 'err equals null')
32
- done()
33
- })
34
- })
35
- })
36
-
37
- testCase('Invalid Zone - Filter', () => {
38
- assertions('should throw an error when an invalid filter is instantiated within a zone', (done) => {
39
- zone.filters[0].startDate = 'abc'
40
- let Zone = new ZoneModel(zone)
41
- Zone.validate((err, res) => {
42
- assert.exists(err, 'err object should exist')
43
- assert.isObject(err)
44
- assert('filters.0.startDate' in err.errors)
45
- assert.notNestedProperty(err, `errors.geofeatures`, 'error should have a url property')
46
- done()
47
- })
48
- })
49
- })
50
- })
@@ -1,29 +0,0 @@
1
- /**
2
- * Created by Arun on 10/09/2014.
3
- * Copyright : Bluedot Innovations.
4
- * Owner :
5
- */
6
- let mongoose = require('mongoose')
7
- let Schema = mongoose.Schema
8
- let StateEnum = require('@bluedot-innovation/enums').StateEnum
9
-
10
- let SimpleCheckInZoneSchema = new Schema({
11
- _id: {type: String},
12
- name: String,
13
- description: {type: String, default: ''},
14
- minimumRetriggerTime: {type: Number},
15
- checkout: {type: Boolean, default: false},
16
- dataSource: {type: String, select: false, default: 'openApi'},
17
- conditionalActions: [],
18
- spatialFilters: [],
19
- creationTime: {type: Date, default: Date.now},
20
- lastUpdateTime: {type: Date, default: Date.now},
21
- activeTimeRange: Schema.Types.Mixed,
22
- applicationId: String,
23
- state: {type: String, default: StateEnum.active, select: false}
24
- },
25
- {collection: 'zone'})
26
-
27
- let SimpleCheckInZone = mongoose.model('SimpleCheckInZone', SimpleCheckInZoneSchema)
28
-
29
- module.exports = SimpleCheckInZone