@tiledesk/tiledesk-server 2.14.8 → 2.14.9

package/CHANGELOG.md

@@ -5,6 +5,9 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.14.9
+- Improved the requests search function and added the ability to specify a timezone when searching
+
 # 2.14.8
 - Added extraction of namespace_id from request body in scrape status route
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tiledesk/tiledesk-server",
   "description": "The Tiledesk server module",
-  "version": "2.14.8",
+  "version": "2.14.9",
   "scripts": {
     "start": "node ./bin/www",
     "pretest": "mongodb-runner start",

package/routes/request.js

@@ -33,6 +33,7 @@ const RoleConstants = require('../models/roleConstants');
 const eventService = require('../pubmodules/events/eventService');
 const { Scheduler } = require('../services/Scheduler');
 const faq_kb = require('../models/faq_kb');
+const datesUtil = require('../utils/datesUtil');
 //const JobManager = require('../utils/jobs-worker-queue-manager-v2/JobManagerV2');
 
 // var messageService = require('../services/messageService');
@@ -1178,6 +1179,7 @@ router.get('/', function (req, res, next) {
   var skip = 0;
   let statusArray = [];
   var projectuser = req.projectuser;
+  let filterRangeField = req.query.filterRangeField || 'createdAt';
 
   if (req.query.limit) {
     limit = parseInt(req.query.limit);
@@ -1278,6 +1280,10 @@ router.get('/', function (req, res, next) {
   //   query.request_id = req.query.request_id;
   // }
 
+  let timezone = req.query.timezone || 'Europe/Rome';
+  let queryDateRange = false;
+  let queryStartDate;
+  let queryEndDate;
   /**
    **! *** DATE RANGE  USECASE 1 ***
    *  in the tiledesk dashboard's HISTORY PAGE
@@ -1287,18 +1293,9 @@ router.get('/', function (req, res, next) {
    */
   //fixato. secondo me qui manca un parentesi tonda per gli or
   if (history_search === true && req.project && req.project.profile && ((req.project.profile.type === 'free' && req.project.trialExpired === true) || (req.project.profile.type === 'payment' && req.project.isActiveSubscription === false))) {
-
-    var startdate = moment().subtract(14, "days").format("YYYY-MM-DD");
-    var enddate = moment().format("YYYY-MM-DD");
-
-    winston.debug('»»» REQUEST ROUTE - startdate ', startdate);
-    winston.debug('»»» REQUEST ROUTE - enddate ', enddate);
-
-    var enddatePlusOneDay = moment(new Date()).add(1, 'days').toDate()
-    winston.debug('»»» REQUEST ROUTE - enddate + 1 days: ', enddatePlusOneDay);
-
-    query.createdAt = { $gte: new Date(Date.parse(startdate)).toISOString(), $lte: new Date(enddatePlusOneDay).toISOString() }
-    winston.debug('REQUEST ROUTE - QUERY CREATED AT ', query.createdAt);
+    queryDateRange = true;    
+    queryStartDate = moment().subtract(14, "days").format("YYYY/MM/DD");
+    queryEndDate = null;
   }
 
   /**
@@ -1306,45 +1303,26 @@ router.get('/', function (req, res, next) {
     *  in the tiledesk dashboard's HISTORY PAGE 
     *  WHEN THE USER SEARCH FOR DATE INTERVAL OF THE HISTORY OF REQUESTS
     */
-  if (req.query.start_date && req.query.end_date) {
-    winston.debug('REQUEST ROUTE - REQ QUERY start_date ', req.query.start_date);
-    winston.debug('REQUEST ROUTE - REQ QUERY end_date ', req.query.end_date);
-
-    /**
-     * USING TIMESTAMP  in MS    */
-    // var formattedStartDate = new Date(+req.query.start_date);
-    // var formattedEndDate = new Date(+req.query.end_date);
-    // query.createdAt = { $gte: formattedStartDate, $lte: formattedEndDate }
-
-    /**
-     * USING MOMENT      */
-    var startDate = moment(req.query.start_date, 'DD/MM/YYYY').format('YYYY-MM-DD');
-    var endDate = moment(req.query.end_date, 'DD/MM/YYYY').format('YYYY-MM-DD');
 
-    winston.debug('REQUEST ROUTE - REQ QUERY FORMATTED START DATE ', startDate);
-    winston.debug('REQUEST ROUTE - REQ QUERY FORMATTED END DATE ', endDate);
-
-    // ADD ONE DAY TO THE END DAY
-    var date = new Date(endDate);
-    var newdate = new Date(date);
-    var endDate_plusOneDay = newdate.setDate(newdate.getDate() + 1);
-    winston.debug('REQUEST ROUTE - REQ QUERY FORMATTED END DATE + 1 DAY ', endDate_plusOneDay);
-
-    query.createdAt = { $gte: new Date(Date.parse(startDate)).toISOString(), $lte: new Date(endDate_plusOneDay).toISOString() }
-    winston.debug('REQUEST ROUTE - QUERY CREATED AT ', query.createdAt);
-
-  } else if (req.query.start_date && !req.query.end_date) {
-    winston.debug('REQUEST ROUTE - REQ QUERY END DATE IS EMPTY (so search only for start date)');
-    var startDate = moment(req.query.start_date, 'DD/MM/YYYY').format('YYYY-MM-DD');
+  if (req.query.start_date || req.query.end_date) {
+    queryDateRange = true; 
+    queryStartDate = req.query.start_date;
+    queryEndDate = req.query.end_date;
+  }
+  else if (req.query.start_date_time || req.query.end_date_time) {
+    queryDateRange = true; 
+    queryStartDate = req.query.start_date_time;
+    queryEndDate = req.query.end_date_time;
+  }
 
-    var range = { $gte: new Date(Date.parse(startDate)).toISOString() };
-    if (req.query.filterRangeField) {
-      query[req.query.filterRangeField] = range;
-    } else {
-      query.createdAt = range;
+  if (queryDateRange) {
+    try {
+      let rangeQuery = datesUtil.createDateRangeQuery(queryStartDate, queryEndDate, timezone, filterRangeField);
+      Object.assign(query, rangeQuery);
+    } catch (error) {
+      winston.error('Error creating date range query: ', error);
+      return res.status(500).send({ success: false, error: error?.message });
     }
-
-    winston.debug('REQUEST ROUTE - QUERY CREATED AT (only for start date)', query.createdAt);
   }
 
   if (req.query.snap_department_routing) {
@@ -2395,4 +2373,4 @@ async function scheduleTags(id_project, tags) {
 }
 
 
-module.exports = router;
+module.exports = router;

package/test/dateUtils.test.js

@@ -0,0 +1,161 @@
+const { expect } = require('chai');
+const datesUtil = require('../utils/datesUtil');
+const moment = require('moment-timezone');
+
+describe('datesUtil', () => {
+
+    it('test1', () => {
+        const startDate = '21/01/2026';
+        const endDate = '21/01/2026';
+        const timezone = 'Europe/Rome';
+
+        const res = datesUtil.createDateRangeQuery(startDate, endDate, timezone);
+
+        expect(res).to.have.property('createdAt');
+        expect(res.createdAt).to.have.property('$gte');
+        expect(res.createdAt).to.have.property('$lt');
+
+        let startDateUTC = new Date("2026-01-20T23:00:00.000Z").toISOString();
+        let endDateUTC = new Date("2026-01-21T23:00:00.000Z").toISOString();
+    
+        expect(res.createdAt.$gte.toISOString()).to.equal(startDateUTC);
+        expect(res.createdAt.$lt.toISOString()).to.equal(endDateUTC);
+    })
+
+    it('test2', () => {
+        const startDate = '20/01/2026, 12:25';
+        const endDate = '20/01/2026, 15:25 ';
+        const timezone = 'Europe/Rome';
+
+        const res = datesUtil.createDateRangeQuery(startDate, endDate, timezone);
+
+        console.log(res);
+
+        expect(res).to.have.property('createdAt');
+        expect(res.createdAt).to.have.property('$gte');
+        expect(res.createdAt).to.have.property('$lte');
+
+        let startDateUTC = new Date("2026-01-20T11:25:00.000Z").toISOString();
+        let endDateUTC = new Date("2026-01-20T14:25:00.000Z").toISOString();
+    
+        expect(res.createdAt.$gte.toISOString()).to.equal(startDateUTC);
+        expect(res.createdAt.$lte.toISOString()).to.equal(endDateUTC);
+    })
+//   describe('parseDate', () => {
+//     it('should parse DD/MM/YYYY format and apply timezone', () => {
+//       const dateStr = '28/02/2023';
+//       const timezone = 'Europe/Rome';
+//       const m = datesUtil.parseDate(dateStr, timezone);
+//       expect(m).to.be.an.instanceof(moment);
+//       expect(m.tz()).to.equal(timezone);
+//       expect(m.format('DD/MM/YYYY')).to.equal('28/02/2023');
+//     });
+
+//     it('should parse DD/MM/YYYY HH:mm:ss format and apply timezone', () => {
+//       const dateStr = '01/03/2023 13:14:15';
+//       const timezone = 'America/New_York';
+//       const m = datesUtil.parseDate(dateStr, timezone);
+
+//       expect(m.format('DD/MM/YYYY HH:mm:ss')).to.equal('01/03/2023 07:14:15');
+//       expect(m.tz()).to.equal(timezone);
+//     });
+
+//     it('should throw error for invalid timezone', () => {
+//       expect(() => datesUtil.parseDate('01/03/2023', 'Invalid/Zone')).to.throw('Invalid timezone');
+//     });
+
+//     it('should throw error for unparseable date', () => {
+//       expect(() => datesUtil.parseDate('notadate', 'Europe/Rome')).to.throw('Unable to parse the date');
+//     });
+//   });
+
+
+//   describe('hasTimeComponent', () => {
+//     it('should return true for string with time', () => {
+//       expect(datesUtil.hasTimeComponent('20/02/2021 23:31:01')).to.be.true;
+//       expect(datesUtil.hasTimeComponent('20/02/2021 02:31')).to.be.true;
+//     });
+//     it('should return false for string without time', () => {
+//       expect(datesUtil.hasTimeComponent('20/02/2021')).to.be.false;
+//       expect(datesUtil.hasTimeComponent('01/03/2022')).to.be.false;
+//     });
+//   });
+
+//   describe('convertLocalDatesToUTC', () => {
+//     it('should convert start and end dates and output correct UTC ISO strings', () => {
+//       const timezone = 'Europe/Rome';
+//       const startDate = '01/06/2021';
+//       const endDate = '05/06/2021';
+//       const res = datesUtil.convertLocalDatesToUTC(startDate, endDate, timezone);
+
+//       // startDateUTC should be 2021-06-01T00:00:00.000Z in UTC
+//       expect(res.startDateUTC).to.match(/^2021-05-31T22:00:00/);
+//       // endDateUTC should be 2021-06-06T00:00:00.000Z in UTC (start of *next* day)
+//       expect(res.endDateUTC).to.match(/^2021-06-05T22:00:00/);
+//     });
+
+//     it('should convert when time is included in the dates', () => {
+//       const timezone = 'America/New_York';
+//       const startDate = '20/07/2022 09:30:00';
+//       const endDate = '21/07/2022 17:45:10';
+//       const res = datesUtil.convertLocalDatesToUTC(startDate, endDate, timezone);
+//       // The result.startDateUTC and endDateUTC should be the same as the input local time mapped to UTC
+//       expect(new Date(res.startDateUTC).toISOString()).to.equal(res.startDateUTC);
+//       expect(new Date(res.endDateUTC).toISOString()).to.equal(res.endDateUTC);
+//     });
+
+//     it('should throw if both startDate and endDate are missing', () => {
+//       expect(() => datesUtil.convertLocalDatesToUTC(null, null, 'Europe/Rome')).to.throw('At least one of startDate or endDate must be provided');
+//     });
+//   });
+
+//   describe('createDateRangeQuery', () => {
+//     it('should generate MongoDB query with $gte and $lt for date only', () => {
+//       const tz = 'Europe/Rome';
+//       const res = datesUtil.createDateRangeQuery('02/02/2022', '05/02/2022', tz, 'createdAt');
+//       expect(res).to.have.property('createdAt');
+//       expect(res.createdAt).to.have.property('$gte');
+//       expect(res.createdAt).to.have.property('$lt');
+//       expect(res.createdAt).to.not.have.property('$lte');
+//     });
+
+//     it('should use $lte operator for endDate with time component', () => {
+//       const tz = 'Europe/Rome';
+//       const r = datesUtil.createDateRangeQuery('02/02/2022 09:00:00', '05/02/2022 18:23:10', tz, 'createdAt');
+//       expect(r.createdAt).to.have.property('$gte');
+//       expect(r.createdAt).to.have.property('$lte');
+//       expect(r.createdAt).to.not.have.property('$lt');
+//     });
+
+//     it('should allow custom fieldName', () => {
+//       const tz = 'Europe/Rome';
+//       const result = datesUtil.createDateRangeQuery('10/08/2023', '15/08/2023', tz, 'customField');
+//       expect(result).to.have.property('customField');
+//       expect(result.customField).to.have.property('$gte');
+//       expect(result.customField).to.have.property('$lt');
+//     });
+
+//     it('should allow only startDate', () => {
+//       const tz = 'Europe/Rome';
+//       const result = datesUtil.createDateRangeQuery('10/09/2023', undefined, tz);
+//       expect(result).to.have.property('createdAt');
+//       expect(result.createdAt).to.have.property('$gte');
+//       expect(result.createdAt).to.not.have.property('$lt');
+//       expect(result.createdAt).to.not.have.property('$lte');
+//     });
+
+//     it('should allow only endDate', () => {
+//       const tz = 'Europe/Rome';
+//       const result = datesUtil.createDateRangeQuery(null, '10/09/2023', tz);
+//       expect(result).to.have.property('createdAt');
+//       expect(result.createdAt).to.have.property('$lt');
+//       expect(result.createdAt).to.not.have.property('$gte');
+//       expect(result.createdAt).to.not.have.property('$lte');
+//     });
+
+//     it('should throw error for invalid timezone', () => {
+//       expect(() => datesUtil.createDateRangeQuery('01/01/2023', '02/01/2023', 'Invalid/Timezone')).to.throw('Invalid timezone');
+//     });
+//   });
+
+});

package/utils/datesUtil.js

@@ -0,0 +1,173 @@
+const moment = require('moment-timezone');
+
+class DatesUtil {
+
+  /**
+   * Helper function to parse a date with optional time
+   * Supports formats: DD/MM/YYYY, DD/MM/YYYY HH:mm, DD/MM/YYYY HH:mm:ss, DD/MM/YYYY, HH:mm:ss
+   * 
+   * @param {string} dateString - Date string with or without time
+   * @param {string} timezone - Timezone
+   * @returns {moment.Moment} Parsed moment object
+   */
+  parseDate(dateString, timezone) {
+    if (!dateString || typeof dateString !== 'string') {
+      throw new Error(`The date must be a string: ${dateString}`);
+    }
+
+    if (!timezone || typeof timezone !== 'string') {
+      throw new Error(`The timezone must be a string: ${timezone}`);
+    }
+
+    // Validate timezone: check if it's a valid IANA timezone
+    if (!moment.tz.zone(timezone)) {
+      throw new Error(`Invalid timezone: ${timezone}. Please use a valid IANA timezone (e.g., "Europe/Rome", "America/New_York")`);
+    }
+
+    const trimmedDate = dateString.trim();
+
+    // List of possible formats to try
+    const formats = [
+      'DD/MM/YYYY HH:mm:ss',
+      'DD/MM/YYYY, HH:mm:ss',
+      'DD/MM/YYYY HH:mm',
+      'DD/MM/YYYY, HH:mm',
+      'DD/MM/YYYY',
+      'YYYY/MM/DD HH:mm:ss',
+      'YYYY/MM/DD, HH:mm:ss',
+      'YYYY/MM/DD HH:mm',
+      'YYYY/MM/DD, HH:mm',
+      'YYYY/MM/DD'
+    ];
+
+    // Try every format until one valid is found
+    for (const format of formats) {
+      // Parse the date in the specified format (without timezone)
+      //const parsed = moment(trimmedDate, format, true); // strict mode
+      const parsed = moment.tz(trimmedDate, format, timezone);
+      if (parsed && parsed.isValid && parsed.isValid()) {
+        // Apply the timezone to the parsed date
+        const dateWithTimezone = parsed.tz(timezone);
+        
+        // Verify that the timezone was applied correctly
+        if (!dateWithTimezone || !dateWithTimezone.isValid || !dateWithTimezone.isValid()) {
+          throw new Error(`Unable to apply timezone ${timezone} to date: ${dateString}`);
+        }
+        
+        return dateWithTimezone;
+      }
+    }
+
+    throw new Error(`Unable to parse the date: ${dateString} with timezone: ${timezone}`);
+  }
+
+  /**
+   * Checks if a date string contains time information
+   * 
+   * @param {string} dateString - Date string
+   * @returns {boolean} True if contains time information
+   */
+  hasTimeComponent(dateString) {
+    // Checks if contains time information (HH:mm or HH:mm:ss)
+    return /[0-9]{1,2}:[0-9]{2}(:[0-9]{2})?/.test(dateString);
+  }
+
+  /**
+   * Converts local dates to UTC for database queries
+   * 
+   * @param {string|null|undefined} startDate - Start date in the format DD/MM/YYYY or DD/MM/YYYY HH:mm:ss (e.g. "20/01/2026" or "20/01/2026 14:30:00"). Optional.
+   * @param {string|null|undefined} endDate - End date in the format DD/MM/YYYY or DD/MM/YYYY HH:mm:ss (e.g. "20/01/2026" or "20/01/2026 23:59:59"). Optional.
+   * @param {string} timezone - User timezone (e.g. "Europe/Rome", "America/New_York", "Asia/Tokyo")
+   * @returns {Object} Object with startDateUTC and/or endDateUTC in ISO string format for MongoDB
+   */
+  convertLocalDatesToUTC(startDate, endDate, timezone) {
+    if (!timezone || typeof timezone !== 'string') {
+      throw new Error(`The timezone must be a string: ${timezone}`);
+    }
+
+    // Validate timezone: check if it's a valid IANA timezone
+    if (!moment.tz.zone(timezone)) {
+      throw new Error(`Invalid timezone: ${timezone}. Please use a valid IANA timezone (e.g., "Europe/Rome", "America/New_York")`);
+    }
+
+    const result = {
+      startDateUTC: null,
+      endDateUTC: null,
+      startDate: null,
+      endDate: null
+    };
+
+    // Parse startDate if provided
+    if (startDate) {
+      const startMoment = this.parseDate(startDate, timezone);
+      // If startDate does not contain time, use the start of the day
+      // Otherwise use the specified time
+      const startParsed = this.hasTimeComponent(startDate)
+        ? startMoment
+        : startMoment.startOf('day');
+
+      result.startDateUTC = startParsed.utc().toISOString();
+      result.startDate = startParsed.utc().toDate();
+    }
+
+    // Parse endDate if provided
+    if (endDate) {
+      const endMoment = this.parseDate(endDate, timezone);
+      // If endDate does not contain time, use the start of the next day
+      // Otherwise use the specified time
+      const endParsed = this.hasTimeComponent(endDate)
+        ? endMoment
+        : endMoment.clone().add(1, 'day').startOf('day');
+
+      result.endDateUTC = endParsed.utc().toISOString();
+      result.endDate = endParsed.utc().toDate();
+    }
+
+    // At least one date must be provided
+    if (!startDate && !endDate) {
+      throw new Error('At least one of startDate or endDate must be provided');
+    }
+
+    return result;
+  }
+
+  /**
+   * Creates a MongoDB query object with the converted dates in UTC
+   * 
+   * @param {string|null|undefined} startDate - Start date in the format DD/MM/YYYY or DD/MM/YYYY HH:mm:ss. Optional (from this date onwards).
+   * @param {string|null|undefined} endDate - End date in the format DD/MM/YYYY or DD/MM/YYYY HH:mm:ss. Optional (until this date).
+   * @param {string} timezone - User timezone
+   * @param {string} fieldName - Field name in the database (default: "createdAt")
+   * @returns {Object} MongoDB query object with $gte (if startDate provided), $lt/$lte (if endDate provided), or both
+   */
+  createDateRangeQuery(startDate, endDate, timezone, fieldName = 'createdAt') {
+    const { startDate: start, endDate: end } = this.convertLocalDatesToUTC(startDate, endDate, timezone);
+
+    const query = {};
+    const dateQuery = {};
+
+    // Add start date condition (from this date onwards)
+    if (start) {
+      dateQuery.$gte = start;
+    }
+
+    // Add end date condition (until this date)
+    if (end) {
+      // If endDate contains time, use $lte to include up to that time
+      // Otherwise use $lt to exclude the start of the next day
+      const endOperator = endDate && this.hasTimeComponent(endDate) ? '$lte' : '$lt';
+      dateQuery[endOperator] = end;
+    }
+
+    // Only add the date query if at least one condition was set
+    if (Object.keys(dateQuery).length > 0) {
+      query[fieldName] = dateQuery;
+    }
+
+    return query;
+  }
+
+}
+
+const datesUtil = new DatesUtil();
+module.exports = datesUtil;