@tiledesk/tiledesk-server 3.5.0 → 3.5.1

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.
@@ -4,20 +4,28 @@ var Request = require("../models/request");
4
4
  var winston = require('../config/winston');
5
5
  var moment = require('moment');
6
6
  const requestEvent = require('../event/requestEvent');
7
- const { check, validationResult } = require('express-validator');
8
7
  var requestService = require('../services/requestService');
9
8
  var mongoose = require('mongoose');
9
+ var numericInput = require('../utils/numericInput');
10
10
 
11
11
 
12
12
  router.patch('/:requestid/rating', function (req, res) {
13
13
  winston.debug(req.body);
14
14
  const update = {};
15
15
 
16
- if (req.body.rating) {
17
- update.rating = req.body.rating;
16
+ // Satisfaction is an integer 1-5. Negative, zero, and out-of-range values are rejected.
17
+ if (req.body.rating !== undefined && req.body.rating !== null && req.body.rating !== '') {
18
+ var rating = numericInput.parseBoundedInteger(req.body.rating, 1, 5);
19
+ if (rating === null) {
20
+ return numericInput.sendInvalidNumber(res, 'rating must be an integer between 1 and 5');
21
+ }
22
+ update.rating = rating;
18
23
  }
19
24
 
20
25
  if (req.body.rating_message) {
26
+ if (typeof req.body.rating_message !== 'string') {
27
+ return numericInput.sendInvalidNumber(res, 'rating_message must be a string');
28
+ }
21
29
  update.rating_message = req.body.rating_message;
22
30
  }
23
31
 
@@ -32,7 +40,7 @@ router.patch('/:requestid/rating', function (req, res) {
32
40
  }
33
41
 
34
42
  //cacheinvalidation
35
- return Request.findOneAndUpdate(query, { $set: update }, { new: true, upsert: false })
43
+ return Request.findOneAndUpdate(query, { $set: update }, { new: true, upsert: false, runValidators: true })
36
44
  .populate('lead')
37
45
  .populate('department')
38
46
  .populate('participatingBots')
@@ -87,25 +95,11 @@ router.get('/me', function (req, res, next) {
87
95
  winston.debug("req.query.sort", req.query.sort);
88
96
  winston.debug('REQUEST ROUTE - QUERY ', req.query)
89
97
 
90
- const DEFAULT_LIMIT = 40;
91
-
92
- var limit = DEFAULT_LIMIT; // Number of request per page
93
-
94
- if (req.query.limit) {
95
- limit = parseInt(req.query.limit);
96
- }
97
- if (limit > 100) {
98
- limit = DEFAULT_LIMIT;
99
- }
100
-
101
-
102
- var page = 0;
103
-
104
- if (req.query.page) {
105
- page = req.query.page;
106
- }
107
-
108
- var skip = page * limit;
98
+ const paging = numericInput.takePagination(res, req.query, { defaultLimit: 40, maxLimit: 100, overMax: 'default' });
99
+ if (!paging) return;
100
+ var limit = paging.limit;
101
+ var page = paging.page;
102
+ var skip = paging.skip;
109
103
  winston.debug('REQUEST ROUTE - SKIP PAGE ', skip);
110
104
 
111
105
 
@@ -149,14 +143,17 @@ router.get('/me', function (req, res, next) {
149
143
 
150
144
  if (req.query.status) {
151
145
  winston.debug('req.query.status', req.query.status);
152
- query.status = req.query.status;
153
-
154
- if (req.query.status == 1000 || req.query.status == "1000") {
146
+ if (req.query.status === "all") {
155
147
  history_search = true;
156
- }
157
- if (req.query.status==="all") {
158
- history_search = true;
159
- delete query.status;
148
+ } else {
149
+ var status = numericInput.takeOptionalAllowedInteger(res, req.query.status, numericInput.REQUEST_STATUSES, 'status');
150
+ if (status === null) return;
151
+ if (status !== undefined) {
152
+ query.status = status;
153
+ if (status === 1000) {
154
+ history_search = true;
155
+ }
156
+ }
160
157
  }
161
158
  }
162
159
 
@@ -312,10 +309,8 @@ router.get('/me', function (req, res, next) {
312
309
  }
313
310
 
314
311
 
315
- var direction = -1; //-1 descending , 1 ascending
316
- if (req.query.direction) {
317
- direction = req.query.direction;
318
- }
312
+ var direction = numericInput.takeSortDirection(res, req.query.direction);
313
+ if (direction === null) return;
319
314
  winston.debug("direction", direction);
320
315
 
321
316
  var sortField = "createdAt";
package/test/kbRoute.js CHANGED
@@ -1482,7 +1482,7 @@ describe('KbRoute', () => {
1482
1482
 
1483
1483
  }).timeout(10000)
1484
1484
 
1485
- it('add-multiple-urls-with-scrape-option-success-type-3', (done) => {
1485
+ it('add-multiple-urls-rejects-unknown-scrape-type-3', (done) => {
1486
1486
 
1487
1487
  var email = "test-signup-" + Date.now() + "@email.com";
1488
1488
  var pwd = "pwd";
@@ -1512,12 +1512,9 @@ describe('KbRoute', () => {
1512
1512
  if (err) { console.error("err: ", err); }
1513
1513
  if (log) { console.log("res.body: ", res.body) }
1514
1514
 
1515
- res.should.have.status(200);
1516
-
1517
- let realResponse = res.body.result;
1518
- expect(realResponse.length).to.equal(1)
1519
- expect(realResponse[0].scrape_type).to.equal(3)
1520
- expect(typeof realResponse[0].scrape_options === null);
1515
+ res.should.have.status(422);
1516
+ expect(res.body.success).to.equal(false);
1517
+ expect(res.body.msg).to.include('scrape_type');
1521
1518
 
1522
1519
  done();
1523
1520
 
@@ -0,0 +1,137 @@
1
+ process.env.NODE_ENV = 'test';
2
+
3
+ var assert = require('assert');
4
+ var express = require('express');
5
+ var chai = require('chai');
6
+ var chaiHttp = require('chai-http');
7
+ var numericInput = require('../utils/numericInput');
8
+
9
+ chai.use(chaiHttp);
10
+
11
+ describe('numeric input validation', function () {
12
+
13
+ it('rejects a rating outside 1-5, including negatives', function () {
14
+ assert.strictEqual(numericInput.parseBoundedInteger(-1, 1, 5), null);
15
+ assert.strictEqual(numericInput.parseBoundedInteger(-100, 1, 5), null);
16
+ assert.strictEqual(numericInput.parseBoundedInteger('-3', 1, 5), null);
17
+ assert.strictEqual(numericInput.parseBoundedInteger(0, 1, 5), null);
18
+ assert.strictEqual(numericInput.parseBoundedInteger(6, 1, 5), null);
19
+ assert.strictEqual(numericInput.parseBoundedInteger(1.5, 1, 5), null);
20
+ assert.strictEqual(numericInput.parseBoundedInteger(true, 1, 5), null);
21
+ assert.strictEqual(numericInput.parseBoundedInteger([1], 1, 5), null);
22
+ assert.strictEqual(numericInput.parseBoundedInteger('1e2', 1, 5), null);
23
+ });
24
+
25
+ it('accepts an integer rating from 1 to 5', function () {
26
+ assert.strictEqual(numericInput.parseBoundedInteger(1, 1, 5), 1);
27
+ assert.strictEqual(numericInput.parseBoundedInteger(5, 1, 5), 5);
28
+ assert.strictEqual(numericInput.parseBoundedInteger('4', 1, 5), 4);
29
+ });
30
+
31
+ it('allows -1 only for fields whose domain includes that sentinel', function () {
32
+ assert.strictEqual(numericInput.parseBoundedInteger(-1, -1, 100000), -1);
33
+ assert.strictEqual(numericInput.parseBoundedInteger(-2, -1, 100000), null);
34
+ assert.strictEqual(numericInput.parseBoundedInteger(0, -1, 100000), 0);
35
+ assert.strictEqual(numericInput.parseAllowedInteger(-1, numericInput.DEPARTMENT_STATUSES), -1);
36
+ assert.strictEqual(numericInput.parseAllowedInteger(-2, numericInput.DEPARTMENT_STATUSES), null);
37
+ assert.strictEqual(numericInput.parseAllowedInteger(-100, numericInput.MESSAGE_STATUSES), -100);
38
+ assert.strictEqual(numericInput.parseAllowedInteger(-1, numericInput.MESSAGE_STATUSES), null);
39
+ assert.strictEqual(numericInput.parseAllowedInteger(-1, numericInput.REQUEST_STATUSES), null);
40
+ });
41
+
42
+ it('rejects negative page and limit and keeps an over-max limit on the previous default', function () {
43
+ var negativePage = numericInput.readPagination({ page: -1, limit: 10 }, { defaultLimit: 40, maxLimit: 100, overMax: 'default' });
44
+ assert.ok(negativePage.error);
45
+
46
+ var negativeLimit = numericInput.readPagination({ limit: -5 }, { defaultLimit: 40, maxLimit: 100, overMax: 'default' });
47
+ assert.ok(negativeLimit.error);
48
+
49
+ var overMax = numericInput.readPagination({ limit: 200 }, { defaultLimit: 40, maxLimit: 100, overMax: 'default' });
50
+ assert.strictEqual(overMax.limit, 40);
51
+ assert.strictEqual(overMax.error, undefined);
52
+
53
+ var ok = numericInput.readPagination({ page: '2', limit: '10' }, { defaultLimit: 40, maxLimit: 100, overMax: 'default' });
54
+ assert.strictEqual(ok.page, 2);
55
+ assert.strictEqual(ok.limit, 10);
56
+ assert.strictEqual(ok.skip, 20);
57
+ });
58
+
59
+ it('accepts sort direction -1 and 1 only', function () {
60
+ assert.strictEqual(numericInput.parseBoundedInteger(-1, -1, 1), -1);
61
+ assert.strictEqual(numericInput.parseBoundedInteger(1, -1, 1), 1);
62
+ assert.strictEqual(numericInput.parseBoundedInteger(-5, -1, 1), null);
63
+ assert.strictEqual(numericInput.parseBoundedInteger(0, -1, 1), 0);
64
+ });
65
+
66
+ describe('PATCH /:requestid/rating', function () {
67
+ var app;
68
+ var Request;
69
+ var originalFindOneAndUpdate;
70
+ var lastUpdate;
71
+
72
+ before(function () {
73
+ Request = require('../models/request');
74
+ originalFindOneAndUpdate = Request.findOneAndUpdate;
75
+ Request.findOneAndUpdate = function (query, update) {
76
+ lastUpdate = update;
77
+ var chain = {
78
+ populate: function () { return chain; },
79
+ exec: function (callback) {
80
+ callback(null, Object.assign({ request_id: 'req-1' }, update.$set));
81
+ return chain;
82
+ }
83
+ };
84
+ return chain;
85
+ };
86
+ var userRequest = require('../routes/user-request');
87
+ app = express();
88
+ app.use(express.json());
89
+ app.use(userRequest);
90
+ });
91
+
92
+ after(function () {
93
+ Request.findOneAndUpdate = originalFindOneAndUpdate;
94
+ });
95
+
96
+ beforeEach(function () {
97
+ lastUpdate = undefined;
98
+ });
99
+
100
+ function patch(body) {
101
+ return chai.request(app).patch('/req-1/rating').send(body);
102
+ }
103
+
104
+ it('returns 422 for a negative rating', function (done) {
105
+ patch({ rating: -1, rating_message: 'bad' }).end(function (err, res) {
106
+ if (err) return done(err);
107
+ assert.strictEqual(res.status, 422);
108
+ assert.ok(res.body.msg.indexOf('rating') !== -1);
109
+ assert.strictEqual(lastUpdate, undefined);
110
+ done();
111
+ });
112
+ });
113
+
114
+ it('returns 422 for zero, above 5, floats and non-numeric values', function () {
115
+ return Promise.all([0, 6, 1.5, 'no', true, [-1]].map(function (rating) {
116
+ return new Promise(function (resolve, reject) {
117
+ patch({ rating: rating }).end(function (err, res) {
118
+ if (err) return reject(err);
119
+ if (res.status !== 422) return reject(new Error('expected 422 for ' + JSON.stringify(rating) + ', got ' + res.status));
120
+ resolve();
121
+ });
122
+ });
123
+ }));
124
+ });
125
+
126
+ it('stores an in-range rating', function (done) {
127
+ patch({ rating: '4', rating_message: 'Good' }).end(function (err, res) {
128
+ if (err) return done(err);
129
+ assert.strictEqual(res.status, 200);
130
+ assert.strictEqual(res.body.rating, 4);
131
+ assert.strictEqual(lastUpdate.$set.rating, 4);
132
+ assert.strictEqual(lastUpdate.$set.rating_message, 'Good');
133
+ done();
134
+ });
135
+ });
136
+ });
137
+ });
@@ -0,0 +1,200 @@
1
+ var MessageConstants = require('../models/messageConstants');
2
+ var RequestConstants = require('../models/requestConstants');
3
+ var LeadConstants = require('../models/leadConstants');
4
+
5
+ var MESSAGE_STATUSES = Object.values(MessageConstants.CHAT_MESSAGE_STATUS);
6
+ var REQUEST_STATUSES = Object.values(RequestConstants);
7
+ var LEAD_STATUSES = Object.values(LeadConstants);
8
+ var DEPARTMENT_STATUSES = [-1, 0, 1];
9
+ var PROPERTY_STATUSES = [100, 1000];
10
+ var SCRAPE_TYPES = [0, 1, 2, 4];
11
+
12
+ function parseBoundedInteger(value, min, max) {
13
+ if (typeof value === 'boolean' || value === null || value === undefined) {
14
+ return null;
15
+ }
16
+ if (Array.isArray(value) || typeof value === 'object') {
17
+ return null;
18
+ }
19
+
20
+ var n;
21
+ if (typeof value === 'number') {
22
+ n = value;
23
+ } else if (typeof value === 'string') {
24
+ var trimmed = value.trim();
25
+ if (!/^-?\d+$/.test(trimmed)) {
26
+ return null;
27
+ }
28
+ n = Number(trimmed);
29
+ } else {
30
+ return null;
31
+ }
32
+
33
+ if (!Number.isSafeInteger(n) || n < min || n > max) {
34
+ return null;
35
+ }
36
+ return n;
37
+ }
38
+
39
+ function parseAllowedInteger(value, allowed) {
40
+ if (!allowed || allowed.length === 0) {
41
+ return null;
42
+ }
43
+ var min = allowed[0];
44
+ var max = allowed[0];
45
+ for (var i = 1; i < allowed.length; i++) {
46
+ if (allowed[i] < min) min = allowed[i];
47
+ if (allowed[i] > max) max = allowed[i];
48
+ }
49
+ var n = parseBoundedInteger(value, min, max);
50
+ if (n === null || allowed.indexOf(n) === -1) {
51
+ return null;
52
+ }
53
+ return n;
54
+ }
55
+
56
+ function sendInvalidNumber(res, msg) {
57
+ res.status(422).json({ success: false, msg: msg });
58
+ return null;
59
+ }
60
+
61
+ function isAbsent(value) {
62
+ return value === undefined || value === null || value === '';
63
+ }
64
+
65
+ function takeOptionalBoundedInteger(res, value, min, max, label) {
66
+ if (isAbsent(value)) {
67
+ return undefined;
68
+ }
69
+ var n = parseBoundedInteger(value, min, max);
70
+ if (n === null) {
71
+ return sendInvalidNumber(res, label + ' must be an integer between ' + min + ' and ' + max);
72
+ }
73
+ return n;
74
+ }
75
+
76
+ function takeOptionalAllowedInteger(res, value, allowed, label) {
77
+ if (isAbsent(value)) {
78
+ return undefined;
79
+ }
80
+ var n = parseAllowedInteger(value, allowed);
81
+ if (n === null) {
82
+ return sendInvalidNumber(res, label + ' must be an integer and one of: ' + allowed.join(', '));
83
+ }
84
+ return n;
85
+ }
86
+
87
+ function takeStatusList(res, raw, allowed) {
88
+ if (typeof raw !== 'string') {
89
+ return sendInvalidNumber(res, 'status must be "all" or a comma-separated list of: ' + allowed.join(', '));
90
+ }
91
+ var parts = raw.split(',').map(function (part) { return part.trim(); }).filter(Boolean);
92
+ if (parts.length === 0) {
93
+ return sendInvalidNumber(res, 'status must be "all" or a comma-separated list of: ' + allowed.join(', '));
94
+ }
95
+ var out = [];
96
+ for (var i = 0; i < parts.length; i++) {
97
+ var n = parseAllowedInteger(parts[i], allowed);
98
+ if (n === null) {
99
+ return sendInvalidNumber(res, 'status must be an integer and one of: ' + allowed.join(', '));
100
+ }
101
+ out.push(n);
102
+ }
103
+ return out;
104
+ }
105
+
106
+ /**
107
+ * overMax:
108
+ * - 'default': values above maxLimit fall back to defaultLimit (existing list endpoints)
109
+ * - 'clamp': values above maxLimit become maxLimit
110
+ * - 'reject': values above maxLimit are rejected
111
+ */
112
+ function readPagination(query, options) {
113
+ var defaultLimit = options.defaultLimit;
114
+ var maxLimit = options.maxLimit;
115
+ var overMax = options.overMax || 'reject';
116
+ var errors = [];
117
+ var limit = defaultLimit;
118
+ var page = 0;
119
+ var source = query || {};
120
+
121
+ if (!isAbsent(source.limit)) {
122
+ var parsedLimit = parseBoundedInteger(source.limit, 1, Number.MAX_SAFE_INTEGER);
123
+ if (parsedLimit === null) {
124
+ errors.push('limit must be an integer greater than or equal to 1');
125
+ } else if (maxLimit != null && parsedLimit > maxLimit) {
126
+ if (overMax === 'default') {
127
+ limit = defaultLimit;
128
+ } else if (overMax === 'clamp') {
129
+ limit = maxLimit;
130
+ } else {
131
+ errors.push('limit must be an integer between 1 and ' + maxLimit);
132
+ }
133
+ } else {
134
+ limit = parsedLimit;
135
+ }
136
+ }
137
+
138
+ if (!isAbsent(source.page)) {
139
+ var parsedPage = parseBoundedInteger(source.page, 0, 1000000);
140
+ if (parsedPage === null) {
141
+ errors.push('page must be an integer greater than or equal to 0');
142
+ } else {
143
+ page = parsedPage;
144
+ }
145
+ }
146
+
147
+ if (errors.length) {
148
+ return { error: errors.join('; ') };
149
+ }
150
+ return { limit: limit, page: page, skip: page * limit };
151
+ }
152
+
153
+ function takePagination(res, query, options) {
154
+ var paging = readPagination(query, options);
155
+ if (paging.error) {
156
+ return sendInvalidNumber(res, paging.error);
157
+ }
158
+ return paging;
159
+ }
160
+
161
+ function takeSortDirection(res, value) {
162
+ if (isAbsent(value)) {
163
+ return -1;
164
+ }
165
+ var n = parseBoundedInteger(value, -1, 1);
166
+ if (n !== -1 && n !== 1) {
167
+ return sendInvalidNumber(res, 'direction must be -1 or 1');
168
+ }
169
+ return n;
170
+ }
171
+
172
+ function takeMessageStatus(res, value) {
173
+ var parsed = takeOptionalAllowedInteger(res, value, MESSAGE_STATUSES, 'status');
174
+ if (parsed === null) {
175
+ return null;
176
+ }
177
+ if (parsed === undefined) {
178
+ return MessageConstants.CHAT_MESSAGE_STATUS.SENDING;
179
+ }
180
+ return parsed;
181
+ }
182
+
183
+ module.exports = {
184
+ MESSAGE_STATUSES: MESSAGE_STATUSES,
185
+ REQUEST_STATUSES: REQUEST_STATUSES,
186
+ LEAD_STATUSES: LEAD_STATUSES,
187
+ DEPARTMENT_STATUSES: DEPARTMENT_STATUSES,
188
+ PROPERTY_STATUSES: PROPERTY_STATUSES,
189
+ SCRAPE_TYPES: SCRAPE_TYPES,
190
+ parseBoundedInteger: parseBoundedInteger,
191
+ parseAllowedInteger: parseAllowedInteger,
192
+ sendInvalidNumber: sendInvalidNumber,
193
+ takeOptionalBoundedInteger: takeOptionalBoundedInteger,
194
+ takeOptionalAllowedInteger: takeOptionalAllowedInteger,
195
+ takeStatusList: takeStatusList,
196
+ readPagination: readPagination,
197
+ takePagination: takePagination,
198
+ takeSortDirection: takeSortDirection,
199
+ takeMessageStatus: takeMessageStatus
200
+ };