@tiledesk/tiledesk-voice-twilio-connector 0.1.26-rc5 → 0.1.26-rc6

package/index.js

@@ -200,13 +200,12 @@ router.post('/webhook/:id_project', async (req, res) => {
     return res.status(500).send({ message: "Redis not ready. Check redis connection..." })
   }
   //for (const [key, value] of Object.entries(redis_data)){
-  //  await redis_client.hSet('tiledesk:vxml:'+callId, key, JSON.stringify(value))
+  //  await redis_client.hSet('tiledesk:voice:'+callId, key, JSON.stringify(value))
   //}
-  //await redis_client.expire('tiledesk:vxml:'+callId, 86400)
+  //await redis_client.expire('tiledesk:voice:'+callId, 86400)
   
-  await redis_client.set('tiledesk:vxml:'+callSid+':session', JSON.stringify(session_data), {'EX': 86400});
+  await redis_client.set('tiledesk:voice:'+callSid+':session', JSON.stringify(session_data), {'EX': 86400});
   
-  let start4 = new Date().getTime();
   let tiledeskMessage= {
     text:'/start',
     senderFullname: from,
@@ -221,18 +220,22 @@ router.post('/webhook/:id_project', async (req, res) => {
     departmentid: settings.department_id
   };
   
-  let message = await tdChannel.send(tiledeskMessage, user.token, conversation_id)
-  if(!message){
+  let response = await tdChannel.send(tiledeskMessage, user.token, conversation_id)
+  if(!response){
     return res.status(503).send({ message: "Bad response: Quota exceeded" })
   }
-  let end4 = new Date().getTime();
-  console.log('Time after sent message /start: ', end4-start4, '[ms]')
+
+  //await for a response message from tiledesk queue
+  let start_time_get_message = new Date()
+  let message = await getMessage(callId, ani, project_id, conversation_id)
+  let end_time_get_message = new Date()
+  winston.verbose('Time to getMessage from queue in /:project_id/start : ' + end_time_get_message-start_time_get_message + '[ms] --- at time:' + new Date())
   
-  //generate Tiledesk wait message
-  let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-  let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime)
-  //update delayIndex for wait command message time
-  await voiceChannel.saveDelayIndexForCallId(from)
+  // //generate Tiledesk wait message
+  // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+  // let waitTiledeskMessage = await tdChannel.generateWaitTdMessage(from, delayTime)
+  // //update delayIndex for wait command message time
+  // await voiceChannel.saveDelayIndexForCallId(from)
   
   // send standard wait vxml message
   let messageToVXML = await tdTranslator.toVXML(waitTiledeskMessage, callSid, vxmlAttributes, session_data) 
@@ -249,7 +252,7 @@ router.post('/webhook/:id_project', async (req, res) => {
 });
 
 
-router.post('/nextblock/:callSid/', async(req, res) => {
+router.post('/nextblock_old/:callSid/', async(req, res) => {
   let start_call = new Date()
   winston.debug("(voice) called POST /nextblock ", req.body);
   winston.debug("(voice) called POST /nextblock query ", req.query);
@@ -263,8 +266,8 @@ router.post('/nextblock/:callSid/', async(req, res) => {
   let project_id, conversation_id, user;
   let from, to;
 
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
-  //let redis_data = await redis_client.hGetAll('tiledesk:vxml:'+callId);
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
+  //let redis_data = await redis_client.hGetAll('tiledesk:voice:'+callId);
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -338,7 +341,108 @@ router.post('/nextblock/:callSid/', async(req, res) => {
   
 })
 
-async function getMessage(callSid, from, project_id, conversation_id){
+router.post('/nextblock/:callSid/', async(req, res) => {
+  let start_call = new Date()
+  winston.debug("(voice) called POST /nextblock ", req.body);
+  winston.debug("(voice) called POST /nextblock query ", req.query);
+  console.log("(voice) called POST /nextblock at" + new Date() + "with text: " + req.body.SpeechResult)
+  
+  let usertext = req.body.SpeechResult;
+  let confidence = req.body.Confidence
+  let callSid = req.params.callSid;
+  
+  let sessionInfo;
+  let project_id, conversation_id, user;
+  let from, to;
+
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
+  //let redis_data = await redis_client.hGetAll('tiledesk:voice:'+callId);
+  if (!redis_data) {
+    return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
+  }
+  sessionInfo = JSON.parse(redis_data)
+  project_id = sessionInfo.project_id;
+  from = sessionInfo.from;
+  to = sessionInfo.to;
+  conversation_id = sessionInfo.conversation_id;
+  user = sessionInfo.user;
+  
+  let vxmlAttributes = {
+    TTS_VOICE_LANGUAGE: VOICE_LANGUAGE,
+    TTS_VOICE_NAME: VOICE_NAME,
+    callSid: callSid,
+  };
+  
+      
+  const tdChannel = new TiledeskChannel({
+    API_URL: API_URL,
+    redis_client: redis_client
+  })
+  tdChannel.setProjectId(project_id);
+
+  const tdTranslator = new TiledeskTwilioTranslator({
+    BASE_URL: BASE_URL,
+    aiService: aiService,
+    uploadService: uploadService
+  });
+    
+  
+  let start_promise_message= new Date();
+  let message = await new Promise(async (resolve, reject) => {
+    winston.debug('******* user text -->'+ usertext)
+    if(usertext === '' || !usertext){
+
+      let start_time_get_message = new Date()
+      let message = await getMessage(callSid, from, project_id, conversation_id)
+      let end_time_get_message = new Date()
+      winston.verbose(`(if) Time to getMessage from queue in /nextblock/${callSid} : ` + end_time_get_message-start_time_get_message + '[ms]')
+      resolve(message)
+    }else{
+      //CASE:usertext is not empty and queue is empty -->  send message to tiledesk and manage delayTime 
+      let tiledeskMessage= {
+        text:usertext,
+        senderFullname: from,
+        type: 'text',
+        channel: { name: CHANNEL_NAME }
+      };
+
+      let start_time_send_message = new Date()
+      let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
+      let end_time_send_message = new Date()
+      winston.debug("message sent : ", tdMessage);
+      winston.verbose(`(else) Time to send message to tiledesk in /nextblock/${callSid} : ` + end_time_send_message-start_time_send_message + '[ms] with text ' + tdMessage.text + ' --- at time:' + new Date())
+     
+      let start_time_get_message = new Date()
+      let message = await getMessage(callSid, from, project_id, conversation_id)
+      let end_time_get_message = new Date()
+      winston.verbose(`(else) Time to getMessage from queue in /nextblock/${callSid} : ` + end_time_get_message-start_time_get_message + '[ms]  --- at time:' + new Date())
+      resolve(message)
+      
+      //generate Tiledesk wait message
+      // let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
+      // let message = await tdChannel.generateWaitTdMessage(from, delayTime)
+      // //update delayIndex for wait command message time
+      // await voiceChannel.saveDelayIndexForCallId(callSid)
+      // resolve(message)
+    }
+  })
+  let end_promise_message = new Date()
+  winston.verbose(`Time to manage message in Promise /nextblock/${callSid}: ` + end_promise_message-start_promise_message + '[ms] with text' + message.text + ' --- at time --' + new Date())  
+  
+  // convert response to vxml
+  let messageToVXML = await tdTranslator.toVXML(message, callSid, vxmlAttributes, sessionInfo)
+  winston.debug("(voice) VXML to SEND: "+ messageToVXML);
+
+  let end_call = new Date()
+  console.log(`Time to responde to /nextblock/${callSid} : `, end_call-start_call, '[ms]')
+  
+  // Render the response as XML in reply to the webhook request
+  res.set('Content-Type', 'application/xml');
+  res.status(200).send(messageToVXML);
+  
+})
+
+async function getMessage(callId, ani, project_id, conversation_id){
   const startTime = Date.now();
   
   const tdChannel = new TiledeskChannel({
@@ -348,62 +452,78 @@ async function getMessage(callSid, from, project_id, conversation_id){
   tdChannel.setProjectId(project_id);
   
   let message = {}, queue = []
-  return new Promise(async (resolve, reject)=>{
-    /********function checkQueue ************ */
-    //get queue
-    //if queue exist and has at least one message
+  
+  //get queue
+  //if queue exist and has at least one message
+    //get message from queue, remove it from queue and clear delayTime
+  //else
+    //subscribe to topic
+    //create promise that resolve after MAX_POLLING_TIME s
+    //race between subscription and timeout and return a message
+    //if subscription resolve first and queue has at least one message
       //get message from queue, remove it from queue and clear delayTime
-    //if call duration is more than MAX_WAITING_TIME
-      //generate wait command messaget time
-    // recall yourself after delayTime s
-    const checkQueue = async ()=>{
-      winston.debug('(checkQueue FN ) ******* call checkQUEUE')
-      try{
-        queue = await tdChannel.getMessagesFromQueue(conversation_id)
-        winston.debug('(checkQueue FN ) /NEXT controllo coda--> '+ queue.length)
-
-        if (queue && queue.length > 0) {
-          //CASE: queue has at least one message to reproduce --> get message from tiledesk queue and reset delayTime
+
+    try{
+
+      // 1. First attempt: read from queue
+      queue = await tdChannel.getMessagesFromQueue(conversation_id)
+      console.log('[getMessage] /NEXT check queue length--> '+ queue.length)
+
+      if (queue && queue.length > 0) {
+        //CASE: queue has at least one message to reproduce --> get message from tiledesk queue and reset delayTime
+        message = queue[0]
+        winston.debug('[getMessage] QUEUE --> '+ queue[0].text, queue[0])
+
+        // remove message from queue and reset delayIndex
+        await tdChannel.removeMessageFromQueue(conversation_id, message._id)
+        await voiceChannel.clearDelayTimeForCallId(callId)
+
+        return message;
+      }
+
+      // 2. If queue is empty: subscribe with timeout
+      if(queue && queue.length === 0){
+        winston.debug("[getMessage] Queue is empty, starting subscription...");
+        const subscriptionPromise = (async () => {
+          await tdChannel.subscribeToTopic(conversation_id);
+          queue = await tdChannel.getMessagesFromQueue(conversation_id)
+
+          if (!queue || queue.length === 0) {
+            throw new Error("No message received after subscription");
+          }
+
           message = queue[0]
-          winston.debug('(checkQueue FN ) QUEUE --> '+ queue[0].text, queue[0])
-          //remove message from queue
+          winston.debug(`[getMessage] Message received from subscription: ${message.text}`, message);
+
+          // remove message from queue and reset delayIndex
           await tdChannel.removeMessageFromQueue(conversation_id, message._id)
-          //reset delayIndex for wait command message time
-          await voiceChannel.clearDelayTimeForCallId(callSid)
-          //manage attributes for current callId
-          await voiceChannel.saveSettingsForCallId(message.attributes, callSid)
+          await voiceChannel.clearDelayTimeForCallId(callId)
 
-          resolve(message);
-          return;
-        }
+          return message;
+        })();
 
-        const elapsedTime = (Date.now() - startTime) / 1000;
-        if (elapsedTime >= MAX_POLLING_TIME) {
-          //CASE: queue is empty --> generate Tiledesk wait message and manage delayTime 
-          let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-          message = await tdChannel.generateWaitTdMessage(from, delayTime)
-          //update delayIndex for wait command message time
-          await voiceChannel.saveDelayIndexForCallId(callSid)
+        const timeoutPromise = new Promise(async (resolve) => {
+          setTimeout(async () => {
+            winston.debug("[getMessage] Subscription timeout, generating waitTdMessage...");
 
-          resolve(message);
-          return;
-        }
+            //CASE: queue is empty --> generate Tiledesk wait message and manage delayTime 
+            const delayTime = await voiceChannel.getNextDelayTimeForCallId(callId);
+            const waitMessage = await tdChannel.generateWaitTdMessage(ani, delayTime);
+            //update delayIndex for wait command message time
+            await voiceChannel.saveDelayIndexForCallId(callId);
 
-        let delayTime = await voiceChannel.getNextDelayTimeForCallId(callSid)
-        await voiceChannel.saveDelayIndexForCallId(callSid)
-        winston.debug('(checkQueue FN ) RECALL checkQueue FN in: '+ delayTime + '[ms]')
-        messageTimeout = setTimeout(checkQueue, delayTime);
+            resolve(waitMessage);
+          }, MAX_POLLING_TIME * 1000); // MAX_POLLING_TIME is in seconds
+        });
 
-      }catch(err){
-        winston.debug("Error occurred while check message in queue: ", err);
-        reject(err);
-        return;
+        // Vince chi arriva prima: subscription o timeout
+        return await Promise.race([subscriptionPromise, timeoutPromise]);
       }
-    };
-    winston.debug('(checkQueue FN ) INIT POLLING . . . ')
-    checkQueue();
-    
-  })
+    }catch(err){
+      winston.debug("[getMessage] Error occurred: ", err);
+      reject(err);
+      return;
+    }
     
 }
 
@@ -422,8 +542,8 @@ router.post('/speechresult/:callSid', async (req, res) => {
   let project_id, conversation_id, user;
   let from, to;
 
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
-  //let redis_data = await redis_client.hGetAll('tiledesk:vxml:'+callId);
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
+  //let redis_data = await redis_client.hGetAll('tiledesk:voice:'+callId);
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -548,7 +668,7 @@ router.post('/menublock/:callSid', async (req, res) => {
   let project_id, conversation_id, user;
   let from, to;
 
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -622,7 +742,7 @@ router.post('/handle/:callSid/:event', async (req, res) => {
   let project_id, conversation_id, user;
   let from, to;
 
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -707,7 +827,7 @@ router.post('/event/:callSid/:event', async(req, res)=> {
   let project_id, conversation_id, user;
   let from, to;
   
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -806,7 +926,7 @@ router.post('/twilio/status',async (req, res) => {
   let project_id, conversation_id, user;
   let from, to;
   
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -858,8 +978,8 @@ router.post('/twilio/status',async (req, res) => {
       let tdMessage = await tdChannel.send(tiledeskMessage, user.token, conversation_id);
 
       //remove session data for current callId and relative queue data
-      await redis_client.del('tiledesk:vxml:'+callSid+':session');
-      await redis_client.del('tiledesk:vxml:'+callSid+':delayIndex');
+      await redis_client.del('tiledesk:voice:'+callSid+':session');
+      await redis_client.del('tiledesk:voice:'+callSid+':delayIndex');
       await tdChannel.clearQueue(conversation_id);
       break;
     }
@@ -891,7 +1011,7 @@ router.post('/record/:callSid/',async (req, res) => {
   let project_id, conversation_id, user;
   let from, to;
   
-  let redis_data = await redis_client.get('tiledesk:vxml:'+callSid+':session');
+  let redis_data = await redis_client.get('tiledesk:voice:'+callSid+':session');
   if (!redis_data) {
     return res.status(500).send({ success: "false", message: "Can't retrive data for callSid ->" + callSid });
   }
@@ -1048,8 +1168,8 @@ async function generateSTT(audioFileUrl, attributes, sessionInfo, settings){
 
 
 router.get('/addon/transcript', async (req, res) => {
-  winston.verbose("(vxml) called GET /transcript query-->" , req.query);
-  winston.debug("(vxml) called GET /transcript body -->" , req.body);
+  winston.verbose("(voice) called GET /transcript query-->" , req.query);
+  winston.debug("(voice) called GET /transcript body -->" , req.body);
   
   res.status(200).send('ok');
   
@@ -1297,7 +1417,7 @@ async function startApp(settings, callback) {
   }
   
   if(settings.MAX_POLLING_TIME){
-    MAX_POLLING_TIME = settings.MAX_POLLING_TIME/10000; //convert in seconds
+    MAX_POLLING_TIME = settings.MAX_POLLING_TIME/1000; //convert in seconds
   }
   
   if (settings.REDIS_HOST && settings.REDIS_PORT) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiledesk/tiledesk-voice-twilio-connector",
-  "version": "0.1.26-rc5",
+  "version": "0.1.26-rc6",
   "description": "Tiledesk VOICE Twilio connector",
   "license": "MIT",
   "author": "Gabriele Panico",

package/tiledesk/TiledeskChannel.js

@@ -221,6 +221,7 @@ class TiledeskChannel {
     //push element to queue list and set expiration time
     await this.redis_client.rPush('tiledesk:queue:'+conversation_id, JSON.stringify(message));
     this.redis_client.expire('tiledesk:queue:'+conversation_id, 86400)
+    await this.redis_client.publish('tiledesk:conversation:'+conversation_id, JSON.stringify(message));
     
   }
 
@@ -239,6 +240,71 @@ class TiledeskChannel {
     }
     return messages;
   }
+
+  /** PUBLISH MESSAGE TO REDIS TOPIC  **/
+  async publishMessageToTopic(message){
+    
+    /*SKIP INFO MESSAGES*/
+    if(utils.messageType(TYPE_MESSAGE.INFO, message)){
+      winston.verbose("> SKIPPING INFO message: " + JSON.stringify(message) );
+      return;
+    }
+
+    /*SKIP CURRENT USER MESSAGES*/
+    if (message.sender.indexOf("vxml") > -1) {
+      winston.verbose("> SKIPPING ECHO message: " + JSON.stringify(message) );
+      return;
+    }
+
+    winston.verbose("> SAVE message TO QUEUE: " + JSON.stringify(message) );
+
+    let conversation_id = message.recipient
+    //PUBLISH MESSAGE TO REDIS TOPIC WITH KET tiledesk:queue:+conversation_id
+    await this.redis_client.publish('tiledesk:conversation:'+conversation_id, JSON.stringify(message));
+  }
+
+  /** SUBSCRIBE TO REDIS TOPIC */
+  async subscribeToTopic(conversation_id){
+    const topic = `tiledesk:conversation:${conversation_id}`;
+    console.log("subscribeToTopic: " + topic);
+
+    // duplichi il client principale
+    const subscriber = this.redis_client.duplicate();
+    await subscriber.connect();
+
+    let resolved = false; // flag per assicurarsi che risolva solo una volta
+
+    return new Promise((resolve, reject) => {
+      const cleanup = async () => {
+        try {
+          await subscriber.unsubscribe(topic);
+          await subscriber.quit();
+        } catch (err) {
+          // ignora errori di chiusura
+        }
+      };
+
+      subscriber.subscribe(topic, async (message) => {
+        if (resolved) return; // se già risolto, ignora altri messaggi
+        resolved = true;
+
+        try {
+          const json = JSON.parse(message);
+          resolve(json);
+        } catch (err) {
+          reject(err);
+        } finally {
+          cleanup(); // chiudi il subscriber appena arriva il primo messaggio
+        }
+      }).catch(async (err) => {
+        if (!resolved) {
+          resolved = true;
+          reject(err);
+          await cleanup();
+        }
+      });
+    });
+  }
   
   /** REMOVE MESSAGE FROM REDIS QUEUE LIST **/
   async removeMessageFromQueue(conversation_id, message_id){

package/tiledesk/VoiceChannel.js

@@ -53,7 +53,7 @@ class VoiceChannel {
   
   
   async getNextDelayTimeForCallId(callId){
-    const index = await this.redis_client.get('tiledesk:vxml:'+callId + ':delayIndex');
+    const index = await this.redis_client.get('tiledesk:voice:'+callId + ':delayIndex');
     if(index){
       return this.getNextDelayTime(index)
     }
@@ -64,31 +64,31 @@ class VoiceChannel {
   async saveDelayIndexForCallId(callId){
 
     //get value for current callId
-    const index = await this.redis_client.get('tiledesk:vxml:'+callId + ':delayIndex');
+    const index = await this.redis_client.get('tiledesk:voice:'+callId + ':delayIndex');
     if(index){
       //increment 
       const delayIndex = (+index) +1
       //save new index to redis
-      await this.redis_client.set('tiledesk:vxml:'+callId + ':delayIndex', delayIndex, {'EX': 86400});
+      await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', delayIndex, {'EX': 86400});
       return;
     }
     //if index is not present: set to default (0)
-    await this.redis_client.set('tiledesk:vxml:'+callId + ':delayIndex', 0, {'EX': 86400});
+    await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', 0, {'EX': 86400});
   }
   
   /** RESET INDEX INTO REDIS DATA FOR CURRENT CALLID **/
   async clearDelayTimeForCallId(callId){
     
     //get value for current callId
-    const index = await this.redis_client.get('tiledesk:vxml:'+callId + ':delayIndex');
+    const index = await this.redis_client.get('tiledesk:voice:'+callId + ':delayIndex');
     winston.debug('clearDelayTimeForCallId: index -->'+index)
     if(index){
       //set index to default (0)
-      await this.redis_client.set('tiledesk:vxml:'+callId + ':delayIndex', 0, {'EX': 86400});
+      await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', 0, {'EX': 86400});
       return;
     }
     //if index is not present: set to default (0)
-    await this.redis_client.set('tiledesk:vxml:'+callId + ':delayIndex', 0, {'EX': 86400});
+    await this.redis_client.set('tiledesk:voice:'+callId + ':delayIndex', 0, {'EX': 86400});
   }
   
   
@@ -118,21 +118,21 @@ class VoiceChannel {
       
     }
     
-    const index = await this.redis_client.get('tiledesk:vxml:'+callId + ':attributes');
+    const index = await this.redis_client.get('tiledesk:voice:'+callId + ':attributes');
     winston.debug('saveSettingsForCallId: attributes found -->'+index)
     if(index){
       //set index to default (0)
-      await this.redis_client.set('tiledesk:vxml:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
+      await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
       return;
     }
     //if index is not present: set to default (0)
-    await this.redis_client.set('tiledesk:vxml:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
+    await this.redis_client.set('tiledesk:voice:'+callId + ':attributes', JSON.stringify(flowAttributes), {'EX': 86400});
   
   }
   
   
   async getSettingsForCallId(callId){
-    const attributes = await this.redis_client.get('tiledesk:vxml:'+callId + ':attributes');
+    const attributes = await this.redis_client.get('tiledesk:voice:'+callId + ':attributes');
     if(attributes){
       return JSON.parse(attributes)
     }