@tiledesk/tiledesk-server 2.15.8 → 2.16.0

package/CHANGELOG.md

@@ -5,6 +5,11 @@
 🚀        IN PRODUCTION                        🚀
 (https://www.npmjs.com/package/@tiledesk/tiledesk-server/v/2.3.77) 
 
+# 2.16.0
+- Added possibility to update Knowledge Base content
+- Added rated only filter in Conversations History
+- Improved pending requests management
+
 # 2.15.8
 - Updated tybot-connector to 2.0.45
 - Added support for tags management in knowledge base routes

package/event/messageEvent.js

@@ -5,6 +5,7 @@ var Message = require("../models/message");
 var Faq_kb = require("../models/faq_kb");
 var MessageConstants = require("../models/messageConstants");
 var message2Event = require("../event/message2Event");
+var requestEvent = require("../event/requestEvent");
 
 var cacheUtil = require('../utils/cacheUtil');
 var cacheEnabler = require("../services/cacheEnabler");
@@ -178,6 +179,29 @@ function populateMessageWithRequest(message, eventPrefix) {
 messageEvent.on('message.create.simple', populateMessageCreate);
 messageEvent.on('message.update.simple', populateMessageUpdate);
 
+// When the user (lead/requester) sends a message, reopen the conversation if it was pending
+messageEvent.on('message.create.from.requester', function (messageJson) {
+  if (!messageJson.request || messageJson.request.workingStatus !== 'pending') return;
+  var request_id = messageJson.request.request_id;
+  var id_project = messageJson.request.id_project;
+  Request.findOneAndUpdate(
+    { request_id: request_id, id_project: id_project },
+    { $set: { workingStatus: 'open' } },
+    { new: true },
+    function (err, updatedRequest) {
+      if (err) {
+        winston.error("Error updating request workingStatus from pending to open", err);
+        return;
+      }
+      if (updatedRequest) {
+        winston.debug("Request workingStatus set to open (was pending)", { request_id, id_project });
+        requestEvent.emit('request.workingStatus.update', { request: updatedRequest });
+        requestEvent.emit('request.update', updatedRequest);
+      }
+    }
+  );
+});
+
 
 
 // // riattiva commentato per performance

package/models/request.js

@@ -507,6 +507,7 @@ RequestSchema.index({ id_project: 1, createdAt: -1, status: 1 })
 RequestSchema.index({ id_project: 1, preflight: 1, smartAssignment: 1, "snapshot.department.routing": 1, createdAt: 1, status: 1 })
 
 RequestSchema.index({ status: 1, hasBot: 1, updatedAt: 1 }) // For closing unresponsive requests
+RequestSchema.index({ status: 1, hasBot: 1, workingStatus: 1, updatedAt: 1 }) // For closing unresponsive requests
 
 // Contact search by phone / email
 RequestSchema.index({ id_project: 1, 'contact.phone': 1 });

package/package.json

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

package/pubmodules/queue/reconnect.js

@@ -175,6 +175,11 @@ function startWorker() {
           winston.info("Data queue", oka)
         });
 
+        ch.bindQueue(_ok.queue, exchange, "request_workingStatus_update", {}, function(err3, oka) {
+          winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: request_workingStatus_update");
+          winston.info("Data queue", oka)
+        });
+
         ch.bindQueue(_ok.queue, exchange, "message_create", {}, function(err3, oka) {
               winston.info("Queue bind: "+_ok.queue+ " err: "+err3+ " key: message_create");
               winston.info("Data queue", oka)
@@ -286,6 +291,11 @@ function work(msg, cb) {
     requestEvent.emit('request.close.extended.queue',  JSON.parse(message_string));
   }     
 
+  if (topic === 'request_workingStatus_update') {
+    winston.debug("reconnect here topic:" + topic); 
+    requestEvent.emit('request.workingStatus.update.queue',  JSON.parse(message_string));
+  }     
+
   if (topic === 'message_create') {
     winston.debug("reconnect here topic:" + topic);
     // requestEvent.emit('request.create.queue', msg.content);
@@ -410,6 +420,12 @@ function listen() {
       });
     });
 
+    requestEvent.on('request.workingStatus.update', function(request) {
+      setImmediate(() => {
+        publish(exchange, "request_workingStatus_update", Buffer.from(JSON.stringify(request)));
+      });
+    });
+
     requestEvent.on('request.snapshot.update', function(data) {
       setImmediate(() => {
         winston.debug("reconnect request.snapshot.update")

package/pubmodules/routing-queue/listenerQueued.js

@@ -50,7 +50,7 @@ class Listener {
       return winston.warn("Chatbot is not a project_user. Skip update.")
     }
 
-    return Request.countDocuments({ id_project: id_project, participantsAgents: id_user, status: { $lt: 1000 }, draft: { $in: [null, false] } }, (err, requestsCount) => {
+    return Request.countDocuments({ id_project: id_project, participantsAgents: id_user, status: { $lt: 1000 }, draft: { $in: [null, false] }, workingStatus: { $ne: 'pending' } }, (err, requestsCount) => {
       winston.verbose("requestsCount for id_user: ", id_user, "and project: ", id_project, "-->", requestsCount);
       if (err) {
         return winston.error(err);
@@ -236,8 +236,27 @@ class Listener {
           });
         });
 
-     
-       
+        var requestWorkingStatusUpdateKey = 'request.workingStatus.update';
+        if (requestEvent.queueEnabled) {
+          requestWorkingStatusUpdateKey = 'request.workingStatus.update.queue';
+        }
+        winston.debug('Route queue requestWorkingStatusUpdateKey: ' + requestWorkingStatusUpdateKey);
+
+        requestEvent.on(requestWorkingStatusUpdateKey, async (data) => {
+          winston.debug('Route queue WorkingStatus Update');
+
+          var request = data.request;
+          var participantIds = (request.participantsAgents && request.participantsAgents.length)
+            ? request.participantsAgents
+            : (request.participatingAgents || []).map(u => u._id || u.id);
+          setImmediate(() => {
+            participantIds.forEach(id_user => {
+              if (id_user && !String(id_user).startsWith('bot_')) {
+                this.updateProjectUser(id_user, request.id_project, 0);
+              }
+            });
+          });
+        });
     }
 
 }

package/pubmodules/scheduler/tasks/closeAgentUnresponsiveRequestTask.js

@@ -65,7 +65,8 @@ class CloseAgentUnresponsiveRequestTask {
     const query = {
       hasBot: false,
       status: { $lt: 1000 },
-      updatedAt: { $lte: cutoffDate }
+      updatedAt: { $lte: cutoffDate },
+      workingStatus: { $ne: 'pending' }
     };
 
     if (this.queryProject) {

package/pubmodules/scheduler/tasks/closeBotUnresponsiveRequestTask.js

@@ -73,7 +73,8 @@ class CloseBotUnresponsiveRequestTask {
     const query = { 
       hasBot: true, 
       status: { $lt: 1000 }, 
-      updatedAt: { $lte: cutoffDate } 
+      updatedAt: { $lte: cutoffDate },
+      workingStatus: { $ne: 'pending' }
     };
 
     if (this.queryProject) {

package/routes/kb.js

@@ -1773,38 +1773,181 @@ router.post('/sitemap/import', async (req, res) => {
 
 router.put('/:kb_id', async (req, res) => {
 
-  let kb_id = req.params.kb_id;
-  winston.verbose("update kb_id " + kb_id);
+  const id_project = req.projectid;
+  const project = req.project;
+  const kb_id = req.params.kb_id;
+  
+  const { name, type, source, content, refresh_rate, scrape_type, scrape_options, tags } = req.body;
+  const namespace_id = req.body.namespace;
 
-  let update = {};
+  if (!namespace_id) {
+    return res.status(400).send({ success: false, error: "Missing 'namespace' body parameter" })
+  }
 
-  if (req.body.name != undefined) {
-    update.name = req.body.name;
+  let namespace;
+  try {
+    namespace = await aiManager.checkNamespace(id_project, namespace_id);
+  } catch (err) {
+    let errorCode = err?.errorCode ?? 500;
+    return res.status(errorCode).send({ success: false, error: err.error });
   }
 
-  if (req.body.status != undefined) {
-    update.status = req.body.status;
+  let kb = await KB.findOne({ id_project, namespace: namespace_id, _id: kb_id }).lean().exec();
+
+  if (!kb) {
+    return res.status(404).send({ success: false, error: "Content not found. Unable to update a non-existing content" })
   }
 
-  winston.debug("kb update: ", update);
+  let data = {
+    id: kb._id,
+    namespace: namespace_id,
+    engine: namespace.engine || default_engine
+  }
 
-  KB.findByIdAndUpdate(kb_id, update, { new: true }, (err, savedKb) => {
+  // if (kb.type === 'sitemap') {
+  //   let new_sitemap = {
+  //     id_project,
+  //     name,
+  //     source,
+  //     type: 'sitemap',
+  //     content: "",
+  //     namespace: namespace_id,
+  //     status: -1,
+  //     scrape_type,
+  //     scrape_options,
+  //     refresh_rate,
+  //     ...(Array.isArray(tags) && tags.length > 0 ? { tags } : {})
+  //   }
 
-    if (err) {
-      winston.error("KB findByIdAndUpdate error: ", err);
-      return res.status(500).send({ success: false, error: err });
+  //   try {
+  //     let result = await aiManager.updateSitemap(id_project, namespace, kb, new_sitemap);
+  //     return res.status(200).send(result);
+  //   } catch (err) {
+  //     winston.error("Error updating sitemap: ", err);
+  //     return res.status(500).send({ success: false, error: err });
+  //   }
+  // }
+
+  try {
+    let delete_response = await aiService.deleteIndex(data);
+
+    if (delete_response.data.success === true) {
+      await KB.findOneAndDelete({ id_project, namespace: namespace_id, source }).lean().exec();
+      // continue the flow
+    } else {
+      winston.error("Unable to update content due to an error: ", delete_response.data.error);
+      return res.status(500).send({ success: false, error: delete_response.data.error });
     }
 
-    if (!savedKb) {
-      winston.debug("Try to updating a non-existing kb");
-      return res.status(400).send({ success: false, message: "Content not found" })
+  } catch (err) {
+    winston.error("Error updating content: ", err);
+    return res.status(500).send({ success: false, error: err });
+  }
+
+  let new_content = {
+    id_project,
+    name,
+    type,
+    source,
+    content,
+    namespace: namespace_id,
+    status: -1,
+  }
+
+  if (new_content.type === 'url') {
+    new_content.refresh_rate = refresh_rate || 'never';
+    if (!scrape_type || scrape_type === 2) {
+      new_content.scrape_type = 2;
+      new_content.scrape_options = aiManager.setDefaultScrapeOptions();
+    } else {
+      new_content.scrape_type = scrape_type;
+      new_content.scrape_options = scrape_options;
     }
+  }
 
-    res.status(200).send(savedKb)
-  })
+  if (kb.sitemap_origin_id) {
+    new_content.sitemap_origin_id = kb.sitemap_origin_id;
+    new_content.sitemap_origin = kb.sitemap_origin;
+  }
+
+  if (tags && Array.isArray(tags) && tags.every(tag => typeof tag === "string")) {
+    new_content.tags = tags;
+  }
+
+  winston.debug("Update content. New content: ", new_content);
+
+  let updated_content;
+  try {
+    updated_content = await KB.findOneAndUpdate({ id_project, namespace: namespace_id, source }, new_content, { upsert: true, new: true }).lean().exec();
+  } catch (err) {
+    winston.error("Error updating content: ", err);
+    return res.status(500).send({ success: false, error: err });
+  }
+
+  const embedding = normalizeEmbedding(namespace.embedding);
+  embedding.api_key = process.env.EMBEDDING_API_KEY || process.env.GPTKEY;
+  let webhook = apiUrl + '/webhook/kb/status?token=' + KB_WEBHOOK_TOKEN;
+
+  const json = {
+    id: updated_content._id,
+    type: updated_content.type,
+    source: updated_content.source,
+    content: updated_content.content || "",
+    namespace: updated_content.namespace,
+    webhook: webhook,
+    hybrid: namespace.hybrid,
+    engine: namespace.engine || default_engine,
+    embedding: embedding,
+    ...(updated_content.scrape_type && { scrape_type: updated_content.scrape_type }),
+    ...(updated_content.scrape_options && { parameters_scrape_type_4: updated_content.scrape_options }),
+    ...(updated_content.tags && { tags: updated_content.tags }),
+  }
+
+  winston.debug("json: ", json);
+
+  if (process.env.NODE_ENV === 'test') {
+    return res.status(200).send({ success: true, message: "Schedule scrape skipped in test environment", data: updated_content, schedule_json: json });
+  }
+    
+  aiManager.scheduleScrape([json], namespace.hybrid);
+  return res.status(200).send(updated_content);
 
 })
 
+// router.put('/:kb_id', async (req, res) => {
+
+//   let kb_id = req.params.kb_id;
+//   winston.verbose("update kb_id " + kb_id);
+
+//   let update = {};
+
+//   if (req.body.name != undefined) {
+//     update.name = req.body.name;
+//   }
+
+//   if (req.body.status != undefined) {
+//     update.status = req.body.status;
+//   }
+
+//   winston.debug("kb update: ", update);
+
+//   KB.findByIdAndUpdate(kb_id, update, { new: true }, (err, savedKb) => {
+
+//     if (err) {
+//       winston.error("KB findByIdAndUpdate error: ", err);
+//       return res.status(500).send({ success: false, error: err });
+//     }
+
+//     if (!savedKb) {
+//       winston.debug("Try to updating a non-existing kb");
+//       return res.status(400).send({ success: false, message: "Content not found" })
+//     }
+
+//     res.status(200).send(savedKb)
+//   })
+
+// })
+
 router.delete('/:kb_id', async (req, res) => {
 
   let project_id = req.projectid;

package/routes/request.js

@@ -318,6 +318,10 @@ router.patch('/:requestid', function (req, res) {
         return res.status(404).send({ success: false, msg: 'Request not found' });
       }
 
+      if (update.workingStatus !== undefined) {
+        requestEvent.emit('request.workingStatus.update', { request });
+      }
+
       requestEvent.emit("request.update", request);
       requestEvent.emit("request.update.comment", { comment: "PATCH", request: request }); //Deprecated
       requestEvent.emit("request.updated", { comment: "PATCH", request: request, patch: update });
@@ -1376,6 +1380,10 @@ router.get('/', function (req, res, next) {
     }
   }
 
+  if (req.query.workingStatus?.ne) {
+    query.workingStatus = { $ne: req.query.workingStatus.ne };
+  }
+
   if (req.query.priority) {
     query.priority = req.query.priority;
   }
@@ -1421,10 +1429,31 @@ router.get('/', function (req, res, next) {
     query["attributes.fully_abandoned"] = true
   }
 
+  if (req.query.rated && (req.query.rated === true || req.query.rated === 'true')) {
+    query.rating = { $exists: true }
+  }
+
   if (req.query.draft && (req.query.draft === 'false' || req.query.draft === false)) {
     query.draft = { $in: [false, null] }
   }
 
+  let inWStatus = req.query.workingStatus?.in?.split(',').map(s => s.trim()).filter(Boolean);
+  let ninWStatus = req.query.workingStatus?.nin?.split(',').map(s => s.trim()).filter(Boolean);
+
+  if (ninWStatus && ninWStatus.length > 0) {
+    if (ninWStatus.length === 1) {
+      query.workingStatus = { $ne: ninWStatus[0] };
+    } else {
+      query.workingStatus = { $nin: ninWStatus };
+    }
+  } else if (inWStatus && inWStatus.length > 0) {
+    if (inWStatus.length === 1) {
+      query.workingStatus = inWStatus[0];
+    } else {
+      query.workingStatus = { $in: inWStatus };
+    }
+  }
+
   var projection = undefined;
 
   if (req.query.full_text) {
@@ -1872,57 +1901,67 @@ router.get('/csv', function (req, res, next) {
 
   var limit = 100000; // Number of request per page
   var page = 0;
+  var skip = 0;
+  let statusArray = [];
+  var projectuser = req.projectuser;
+  let filterRangeField = req.query.filterRangeField || 'createdAt';
 
   if (req.query.page) {
     page = req.query.page;
   }
 
-  var skip = page * limit;
+  skip = page * limit;
   winston.debug('REQUEST ROUTE - SKIP PAGE ', skip);
 
-  let statusArray = [];
+  // Default query (same as GET /)
+  var query = { "id_project": req.projectid, "status": { $lt: 1000, $nin: [50, 150] }, preflight: false };
 
-  var query = { "id_project": req.projectid };
+  if (req.user instanceof Subscription) {
+    // All request
+  } else if (projectuser && (projectuser.role == "owner" || projectuser.role == "admin")) {
+    if (req.query.mine) {
+      query["$or"] = [{ "snapshot.agents.id_user": req.user.id }, { "participants": req.user.id }];
+    }
+  } else {
+    query["$or"] = [{ "snapshot.agents.id_user": req.user.id }, { "participants": req.user.id }];
+  }
 
   if (req.query.dept_id) {
     query.department = req.query.dept_id;
     winston.debug('REQUEST ROUTE - QUERY DEPT ID', query.department);
   }
 
+  if (req.query.requester_email) {
+    query["snapshot.lead.email"] = req.query.requester_email;
+  }
+
   if (req.query.full_text) {
     winston.debug('req.query.fulltext', req.query.full_text);
     query.$text = { "$search": req.query.full_text };
   }
 
-  if (req.query.status) {
+  if (req.query.phone) {
+    var phoneDigits = req.query.phone.replace(/\D/g, '');
+    if (phoneDigits.length > 0) {
+      query["contact.phone"] = new RegExp(phoneDigits);
+    }
+  }
+
+  var history_search = false;
 
+  // Multiple status management (same as GET /)
+  if (req.query.status) {
     if (req.query.status === 'all') {
       delete query.status;
     } else {
-      let statusArray = req.query.status.split(',').map(Number);
-      statusArray = statusArray.map(status => { return isNaN(status) ? null : status }).filter(status => status !== null)
+      statusArray = req.query.status.split(',').map(Number);
+      statusArray = statusArray.map(status => { return isNaN(status) ? null : status }).filter(status => status !== null);
       if (statusArray.length > 0) {
-        query.status = {
-          $in: statusArray
-        }
+        query.status = { $in: statusArray };
       } else {
         delete query.status;
       }
     }
-
-    if (statusArray.length > 0) {
-      query.status = {
-        $in: statusArray
-      }
-    }
-
-  }
-
-  if (req.query.preflight) {
-    let preflight = (req.query.preflight === 'false');
-    if (preflight) {
-      query.preflight = false;
-    }
   }
 
   if (req.query.lead) {
@@ -1942,49 +1981,96 @@ router.get('/csv', function (req, res, next) {
     query.hasBot = req.query.hasbot;
   }
 
-  /**
-   * DATE RANGE  */
-  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);
+  if (req.query.tags) {
+    query["tags.tag"] = req.query.tags;
+  }
+
+  if (req.query.location) {
+    query.location = req.query.location;
+  }
+
+  if (req.query.ticket_id) {
+    query.ticket_id = req.query.ticket_id;
+  }
+
+  if (req.query.preflight && (req.query.preflight === 'true' || req.query.preflight === true)) {
+    delete query.preflight;
+  }
+
+  let timezone = req.query.timezone || 'Europe/Rome';
+  let queryDateRange = false;
+  let queryStartDate;
+  let queryEndDate;
+
+  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))) {
+    queryDateRange = true;
+    queryStartDate = moment().subtract(14, "days").format("YYYY/MM/DD");
+    queryEndDate = null;
+  }
 
-    /**
-     * 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 }
+  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;
+  }
 
+  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 });
+    }
+  }
 
-    /**
-     * 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');
+  if (req.query.snap_department_routing) {
+    query["snapshot.department.routing"] = req.query.snap_department_routing;
+  }
 
-    winston.debug('REQUEST ROUTE - REQ QUERY FORMATTED START DATE ', startDate);
-    winston.debug('REQUEST ROUTE - REQ QUERY FORMATTED END DATE ', endDate);
+  if (req.query.snap_department_default) {
+    query["snapshot.department.default"] = req.query.snap_department_default;
+  }
+
+  if (req.query.snap_department_id_bot) {
+    query["snapshot.department.id_bot"] = req.query.snap_department_id_bot;
+  }
 
-    // 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);
-    // var endDate_plusOneDay =   moment('2018-09-03').add(1, 'd')
-    // var endDate_plusOneDay =   endDate.add(1).day();
-    // var toDate = new Date(Date.parse(endDate_plusOneDay)).toISOString()
+  if (req.query.snap_department_id_bot_exists) {
+    query["snapshot.department.id_bot"] = { "$exists": req.query.snap_department_id_bot_exists };
+  }
 
-    query.createdAt = { $gte: new Date(Date.parse(startDate)).toISOString(), $lte: new Date(endDate_plusOneDay).toISOString() }
-    winston.debug('REQUEST ROUTE - QUERY CREATED AT ', query.createdAt);
+  if (req.query.snap_lead_lead_id) {
+    query["snapshot.lead.lead_id"] = req.query.snap_lead_lead_id;
+  }
 
-  } 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.snap_lead_email) {
+    query["snapshot.lead.email"] = req.query.snap_lead_email;
+  }
 
-    query.createdAt = { $gte: new Date(Date.parse(startDate)).toISOString() };
-    winston.debug('REQUEST ROUTE - QUERY CREATED AT (only for start date)', query.createdAt);
+  if (req.query.smartAssignment) {
+    query.smartAssignment = req.query.smartAssignment;
   }
-  winston.debug("csv query", query);
 
-  var direction = 1; //-1 descending , 1 ascending
+  if (req.query.channel) {
+    if (req.query.channel === "offline") {
+      query["channel.name"] = { "$in": ["email", "form"] };
+    } else if (req.query.channel === "online") {
+      query["channel.name"] = { "$nin": ["email", "form"] };
+    } else {
+      query["channel.name"] = req.query.channel;
+    }
+  }
+
+  if (req.query.priority) {
+    query.priority = req.query.priority;
+  }
+
+  var direction = -1; // same default as GET /
   if (req.query.direction) {
     direction = req.query.direction;
   }
@@ -1998,20 +2084,9 @@ router.get('/csv', function (req, res, next) {
 
   var sortQuery = {};
   sortQuery[sortField] = direction;
-
   winston.debug("sort query", sortQuery);
 
-  if (req.query.channel) {
-    if (req.query.channel === "offline") {
-      query["channel.name"] = { "$in": ["email", "form"] }
-    } else if (req.query.channel === "online") {
-      query["channel.name"] = { "$nin": ["email", "form"] }
-    } else {
-      query["channel.name"] = req.query.channel
-    }
-  }
-
-  // VOICE FILTERS - Start
+  // VOICE FILTERS
   if (req.query.caller) {
     query["attributes.caller_phone"] = req.query.caller;
   }
@@ -2021,45 +2096,52 @@ router.get('/csv', function (req, res, next) {
   if (req.query.call_id) {
     query["attributes.call_id"] = req.query.call_id;
   }
-  // VOICE FILTERS - End
-
-  // TODO ORDER BY SCORE
-  // return Faq.find(query,  {score: { $meta: "textScore" } }) 
-  // .sort( { score: { $meta: "textScore" } } ) //https://docs.mongodb.com/manual/reference/operator/query/text/#sort-by-text-search-score
-
-  // aggiungi filtro per data marco
 
   if (req.query.duration && req.query.duration_op) {
     let duration = Number(req.query.duration) * 60 * 1000;
     if (req.query.duration_op === 'gt') {
-      query.duration = { $gte: duration }
+      query.duration = { $gte: duration };
     } else if (req.query.duration_op === 'lt') {
-      query.duration = { $lte: duration }
+      query.duration = { $lte: duration };
     } else {
-      winston.verbose("Duration operator can be 'gt' or 'lt'. Skip duration_op " + req.query.duration_op)
+      winston.verbose("Duration operator can be 'gt' or 'lt'. Skip duration_op " + req.query.duration_op);
     }
   }
 
+  if (req.query.abandonded && (req.query.abandoned === true || req.query.abandoned === 'true')) {
+    query["attributes.fully_abandoned"] = true;
+  }
+
+  if (req.query.rated && (req.query.rated === true || req.query.rated === 'true')) {
+    query.rating = { $exists: true };
+  }
+
   if (req.query.draft && (req.query.draft === 'false' || req.query.draft === false)) {
-    query.draft = { $in: [false, null] }
+    query.draft = { $in: [false, null] };
   }
 
-  winston.debug('REQUEST ROUTE - REQUEST FIND ', query)
-  return Request.find(query, '-transcript -status -__v').
+  var csvProjection = '-transcript -status -__v';
+  if (req.query.full_text && req.query.no_textscore != "true" && req.query.no_textscore != true) {
+    winston.verbose('fulltext projection on');
+    csvProjection = { transcript: 0, status: 0, __v: 0, score: { $meta: "textScore" } };
+  }
+
+  winston.debug("csv query", query);
+  winston.debug('REQUEST ROUTE - REQUEST FIND ', query);
+
+  var q = Request.find(query, csvProjection).
     skip(skip).limit(limit).
-    //populate('department', {'_id':-1, 'name':1}).     
     populate('department').
     populate('lead').
-    // populate('participatingBots').
-    // populate('participatingAgents'). 
-    lean().
-    // populate({
-    //   path: 'department', 
-    //   //select: { '_id': -1,'name':1}
-    //   select: {'name':1}
-    // }).  
-    sort(sortQuery).
-    exec(function (err, requests) {
+    lean();
+
+  if (req.query.full_text && req.query.no_textscore != "true" && req.query.no_textscore != true) {
+    q.sort({ score: { $meta: "textScore" } });
+  } else {
+    q.sort(sortQuery);
+  }
+
+  return q.exec(function (err, requests) {
       if (err) {
         winston.error('REQUEST ROUTE - REQUEST FIND ERR ', err)
         return res.status(500).send({ success: false, msg: 'Error getting csv requests.', err: err });

package/services/aiManager.js

@@ -5,6 +5,7 @@ const { Scheduler } = require("./Scheduler");
 const { default: Sitemapper } = require('sitemapper');
 const winston = require('../config/winston');
 const configGlobal = require('../config/global');
+const _ = require('lodash');
 const JobManager = require('../utils/jobs-worker-queue-manager/JobManagerV2');
 
 // Constants
@@ -142,6 +143,73 @@ class AiManager {
     })
   }
 
+  async updateSitemap(id_project, namespace, old_sitemap, new_sitemap) {
+
+    let fieldsToCheck = ['scrape_type', 'scrape_options', 'refresh_rate', 'tags'];
+    let { stop } = this.shouldStop(old_sitemap, new_sitemap, fieldsToCheck);
+
+    let updated_sitemap;
+    try {
+      updated_sitemap = await KB.findOneAndUpdate({ id_project, namespace: namespace.id, _id: old_sitemap._id }, new_sitemap, { new: true });
+    } catch (err) {
+      winston.error("Error updating sitemap: ", err);
+      throw err;
+    }
+
+    if (stop) {
+      return;
+    }
+
+    // Find all url contents with sitemap_origin_id
+    let urlContents = await KB.find({ id_project, namespace: namespace.id, sitemap_origin_id: old_sitemap._id }).lean().exec();
+    if (urlContents.length === 0) {
+      winston.error("No url contents found with sitemap_origin_id: ", old_sitemap._id);
+      throw new Error("No url contents found with sitemap_origin_id: " + old_sitemap._id);
+    }
+
+    // Remove all url contents found with sitemap_origin_id
+    try {
+      await this.removeMultipleContents(namespace, urlContents);
+    } catch (err) {
+      winston.error("Error removing multiple contents: ", err);
+      throw err;
+    }
+
+    // Recreate all url contents with sitemap_origin_id
+    let result;
+    try {
+      result = await this.addMultipleUrls(namespace, urlContents.map(urlContent => urlContent.source), {
+        sitemap_origin_id: updated_sitemap._id,
+        sitemap_origin: updated_sitemap.source,
+        scrape_type: updated_sitemap.scrape_type,
+        scrape_options: updated_sitemap.scrape_options,
+        refresh_rate: updated_sitemap.refresh_rate,
+        tags: updated_sitemap.tags,
+      });
+    } catch (err) {
+      winston.error("Error recreating multiple contents: ", err);
+      throw err;
+    }
+
+    return result;
+
+  }
+
+  
+
+  shouldStop(oldObj, newObj, fieldsToCheck) {
+    for (const field of fieldsToCheck) {
+      const oldValue = _.get(oldObj, field);
+      const newValue = _.get(newObj, field);
+  
+      if (!_.isEqual(oldValue, newValue)) {
+        return { stop: false };
+      }
+    }
+  
+    return { stop: true };
+  }
+
   async checkNamespace(id_project, namespace_id) {
     return new Promise( async (resolve, reject) => {