Add Cron Job for Syncing Running Task

server/app/cronjobs/task-sync/package.json

@@ -0,0 +1,3 @@
+{
+  "main": "taskSync.js"
+}

server/app/cronjobs/task-sync/taskSync.js

@@ -0,0 +1,160 @@
+
+var logger = require('_pr/logger')(module);
+var CatalystCronJob = require('_pr/cronjobs/CatalystCronJob');
+var async = require('async');
+var auditTrail = require('_pr/model/audit-trail/audit-trail.js');
+var taskHistory = require('_pr/model/classes/tasks/taskHistory.js');
+var TaskSync = Object.create(CatalystCronJob);
+TaskSync.interval = '*/5 * * * *';
+TaskSync.execute = taskSync;
+
+module.exports = TaskSync;
+
+function taskSync(){
+    logger.debug("Task Sync is started");
+    async.parallel({
+        botSync  : function(callback){
+            var query={
+                auditType:'BOTs',
+                actionStatus:'running',
+                isDeleted:false
+            };
+            executeTaskSyncForBotHistory(query,callback);
+        },
+        taskSync : function(callback){
+            var query={
+                status:'running'
+            };
+            executeTaskSyncForTaskHistory(query,callback);
+        }
+
+    },function(err,results){
+        if(err){
+            logger.error("There are some error in Task Sync.",err);
+            return;
+        }else{
+            logger.debug("Task Sync is successfully ended");
+            return;
+        }
+
+    })
+}
+
+function executeTaskSyncForBotHistory(query,callback){
+    async.waterfall([
+        function(next){
+            auditTrail.getAuditTrails(query,next);
+        },
+        function(runningAuditTrailList,next){
+            if(runningAuditTrailList.length > 0){
+                var count = 0;
+                for(var i = 0; i < runningAuditTrailList.length; i++){
+                    (function(runningBot){
+                        var currentDate = new Date();
+                        var startBotTime = new Date(runningBot.startedOn);
+                        if(getMinutesDiff(startBotTime,currentDate) > 20){
+                            count++;
+                            var queryObj = {
+                                actionStatus:'failed',
+                                status:'failed',
+                                endedOn : new Date().getTime()
+                            }
+                            auditTrail.updateAuditTrails(runningBot._id,queryObj,function(err,updatedData){
+                                if(err){
+                                    logger.error(err);
+                                }else if(count === runningAuditTrailList.length){
+                                        next(null,runningAuditTrailList);
+                                }else{
+                                    logger.debug("Task Sync is going on");
+                                }
+                            })
+
+                        }else{
+                            count++;
+                            if(count === runningAuditTrailList.length) {
+                                next(null, runningAuditTrailList);
+                            }
+                        }
+                    })(runningAuditTrailList[i]);
+                }
+
+            }else{
+                next({
+                    errCode:400,
+                    errMsg:"There is no BOTs in running state currently."
+                },null);
+            }
+        }
+    ],function(err,results){
+        if(err){
+            callback(err,null);
+            return;
+        }else{
+            callback(null,results);
+            return;
+        }
+    })
+}
+
+function executeTaskSyncForTaskHistory(query,callback){
+    async.waterfall([
+        function(next){
+            taskHistory.getTaskHistory(query,next);
+        },
+        function(runningTaskHistoryList,next){
+            if(runningTaskHistoryList.length > 0){
+                var count = 0;
+                for(var i = 0; i < runningTaskHistoryList.length; i++){
+                    (function(runningTask){
+                        var currentDate = new Date();
+                        var startBotTime = new Date(runningTask.timestampStarted);
+                        if(getMinutesDiff(startBotTime,currentDate) > 20){
+                            count++;
+                            var queryObj = {
+                                status:'failed',
+                                timestampEnded : new Date().getTime()
+                            }
+                            taskHistory.updateRunningTaskHistory(runningTask._id,queryObj,function(err,updatedData){
+                                if(err){
+                                    logger.error(err);
+                                }else if(count === runningTaskHistoryList.length){
+                                    next(null,runningTaskHistoryList);
+                                }else{
+                                    logger.debug("Task Sync is going on");
+                                }
+                            })
+
+                        }else{
+                            count++;
+                            if(count === runningTaskHistoryList.length) {
+                                next(null, runningTaskHistoryList);
+                            }
+                        }
+                    })(runningTaskHistoryList[i]);
+                }
+
+            }else{
+                next({
+                    errCode:400,
+                    errMsg:"There is no Tasks in running state currently."
+                },null);
+            }
+        }
+    ],function(err,results){
+        if(err){
+            callback(err,null);
+            return;
+        }else{
+            callback(null,results);
+            return;
+        }
+    })
+}
+
+function getMinutesDiff(date1,date2){
+    var diff =(date2.getTime() - date1.getTime()) / 1000;
+    diff /= 60;
+    return Math.abs(Math.round(diff));
+}
+
+

server/app/model/audit-trail/audit-trail.js

@@ -60,6 +60,18 @@ AuditTrailSchema.statics.removeAuditTrails = function(queryObj,callback){
     });
 };
 
+AuditTrailSchema.statics.updateAuditTrails = function(auditId,queryObj,callback){
+    AuditTrail.update({_id:new ObjectId(auditId)},{$set:queryObj},{multi:true}, function(err, updatedAuditTrail) {
+        if (err) {
+            logger.error(err);
+            var error = new Error('Internal server error');
+            error.status = 500;
+            return callback(error);
+        }
+        return callback(null, updatedAuditTrail);
+    });
+};
+
 AuditTrailSchema.statics.softRemoveAuditTrails = function(auditId,callback){
     AuditTrail.update({auditId:auditId},{$set:{isDeleted:true}},{multi:true}, function(err, sortDeleteAuditTrail) {
         if (err) {

server/app/model/classes/tasks/taskHistory.js

@@ -251,6 +251,28 @@ taskHistorySchema.statics.updateHistory = function updateHistory(hId, historyDat
     });
 };
 
+taskHistorySchema.statics.getTaskHistory = function getTaskHistory(query,callback) {
+    this.find(query,function(err, tHistories) {
+        if (err) {
+            callback(err, null);
+            return;
+        }
+        callback(null, tHistories);
+    });
+};
+
+taskHistorySchema.statics.updateRunningTaskHistory = function updateRunningTaskHistory(taskHistoryId,queryObj,callback){
+    TaskHistory.update({_id:new ObjectId(taskHistoryId)},{$set:queryObj},{multi:true}, function(err, updatedTaskHistory) {
+        if (err) {
+            logger.error(err);
+            var error = new Error('Internal server error');
+            error.status = 500;
+            return callback(error);
+        }
+        return callback(null, updatedTaskHistory);
+    });
+};
+
 var TaskHistory = mongoose.model('taskHistory', taskHistorySchema);
 
 module.exports = TaskHistory;

server/app/services/auditTrailService.js

@@ -136,7 +136,7 @@ auditTrailService.getAuditTrailList = function getAuditTrailList(auditTrailQuery
             apiUtil.paginationRequest(auditTrailQuery, 'auditTrails', next);
         },
         function(paginationReq, next) {
-            paginationReq['searchColumns'] = ['status', 'action', 'user', 'actionStatus', 'masterDetails.orgName', 'masterDetails.bgName', 'masterDetails.projectName', 'masterDetails.envName'];
+            paginationReq['searchColumns'] = ['status', 'action', 'user', 'actionStatus', 'auditTrailConfig.name','masterDetails.orgName', 'masterDetails.bgName', 'masterDetails.projectName', 'masterDetails.envName'];
             reqData = paginationReq;
             apiUtil.databaseUtil(paginationReq, next);
         },
@@ -227,7 +227,7 @@ auditTrailService.getBOTsSummary = function getBOTsSummary(callback){
                     for(var i = 0; i < botAuditTrail.length; i++){
                         (function(auditTrail){
                             count++;
-                            if(auditTrail.endedOn && auditTrail.endedOn !== null && auditTrail.actionStatus !== 'failed'
+                            if(auditTrail.endedOn && auditTrail.endedOn !== null
                                 && auditTrail.auditTrailConfig.manualExecutionTime && auditTrail.auditTrailConfig.manualExecutionTime !== null) {
                                 var executionTime = getExecutionTime(auditTrail.endedOn, auditTrail.startedOn);
                                 totalTimeInSeconds = totalTimeInSeconds + ((auditTrail.auditTrailConfig.manualExecutionTime*60) - executionTime);

server/app/services/botsService.js

@@ -146,7 +146,7 @@ botsService.getBotsList = function getBotsList(botsQuery,actionStatus,callback)
             apiUtil.paginationRequest(botsQuery, 'bots', next);
         },
         function(paginationReq, next) {
-            paginationReq['searchColumns'] = ['botName', 'botType', 'botCategory', 'botLinkedCategory','botLinkedSubCategory', 'masterDetails.orgName', 'masterDetails.bgName', 'masterDetails.projectName', 'masterDetails.envName'];
+            paginationReq['searchColumns'] = ['botName', 'botType', 'botCategory','botDesc', 'botLinkedCategory','botLinkedSubCategory', 'masterDetails.orgName', 'masterDetails.bgName', 'masterDetails.projectName', 'masterDetails.envName'];
             reqData = paginationReq;
             apiUtil.databaseUtil(paginationReq, next);
         },