Resolved conflict

Author: VarmaSANJAY

client/cat3/package-lock.json

@@ -0,0 +1,82 @@
+/*
+ Copyright [2016] [Relevance Lab]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+const logger = require('_pr/logger')(module);
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const botHistoryAuditTrailSchema = new Schema ({
+    botId: {
+        type: String
+    },
+    actionLogId: {
+        type: String,
+        required: true
+    },
+    botRunId: {
+        type: String,
+        required: true
+    },
+    botExecutorName: {
+        type: String
+    },
+    input: {
+        type : Schema.Types.Mixed,
+        default : null
+    },
+    output: {
+        type : Schema.Types.Mixed,
+        default : null
+    },
+    createdOn: {
+        type: Number,
+        required: true,
+        default: Date.now()
+    },
+    lastUpdateOn: {
+        type: Number,
+        required: true,
+        default: Date.now()
+    }
+})
+
+botHistoryAuditTrailSchema.index({ actionLogId: 1, createdOn:1 }, { unique: true });
+
+botHistoryAuditTrailSchema.statics.addBotHistoryAudit = function (auditObj, callback) {
+    let audit = new this(auditObj);
+    audit.save(callback);
+};
+
+botHistoryAuditTrailSchema.statics.insertBotHistoryAudit = function (auditList, callback) {
+    let auditListDB = auditList.map((auditObj) => {
+        let audit = new this(auditObj);
+        audit.createdOn = Date.now();
+        audit.lastUpdateOn = Date.now();
+        return audit;
+    });
+    this.insertMany(auditListDB, callback);
+};
+
+botHistoryAuditTrailSchema.statics.findByQuery = function (query, project, options, callback) {
+    return this.find(query, project, options, callback);
+};
+
+botHistoryAuditTrailSchema.statics.findOneByQuery = function (query, project, options, callback) {
+    return this.findOne(query, project, options, callback);
+};
+
+const botHistoryAuditTrail = mongoose.model('botHistoryAuditTrail', botHistoryAuditTrailSchema);
+module.exports = botHistoryAuditTrail;

server/app/engine/bots/lambdaExecutor.js

@@ -24,7 +24,7 @@ module.exports.setRoutes = function(app, sessionVerificationFunc) {
      */
     app.get('/bot/all',function(req,res) {
         var loggedUser =  req.session.user.cn;
-        
+
         botService.getAllBotsList(req.query, loggedUser,function(err,data) {
             if (err) {
                 return res.status(500).send(err);
@@ -34,6 +34,41 @@ module.exports.setRoutes = function(app, sessionVerificationFunc) {
         });
     });
 
+    app.get('/bot/history/:actionLogId',function(req,res) {
+        const actionLogId =  req.params.actionLogId;
+        botService.getBotHistoryAudit(actionLogId, function(err, data) {
+            if (err) {
+                return res.status(500).send(err);
+            } else {
+                return res.status(200).send(data);
+            }
+        });
+    });
+
+    app.post('/bot/history',function(req,res) {
+        const loggedUser =  req.session.user.cn;
+        const rqObj =  req.body;
+        botService.addBotHistoryAudit(rqObj, loggedUser, function(err, data) {
+            if (err) {
+                return res.status(500).send(err);
+            } else {
+                return res.status(200).send(data);
+            }
+        });
+    });
+
+    app.post('/bot/historyList',function(req,res) {
+        const loggedUser =  req.session.user.cn;
+        const rqObjList =  req.body;
+        botService.insertBotHistoryAudit(rqObjList, loggedUser, function(err,data) {
+            if (err) {
+                return res.status(500).send(err);
+            } else {
+                return res.status(200).send(data);
+            }
+        });
+    });
+
     app.get('/bot',function(req,res) {
         var actionStatus = null,serviceNowCheck =null;
         var loggedUser =  req.session.user.cn;

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

@@ -52,6 +52,8 @@ var azurecloudProvider = require('_pr/model/classes/masters/cloudprovider/azureC
 var vmwareProvider = require('_pr/model/classes/masters/cloudprovider/vmwareCloudProvider.js');
 var botAuditTrailSummary = require('_pr/model/audit-trail/bot-audit-trail-summary');
 
+const botHistoryAuditTrail = require('_pr/model/audit-trail/bot-history-audit-trail');
+
 var appConfig = require('_pr/config');
 var botService = module.exports = {};
 
@@ -451,6 +453,8 @@ botService.executeBots = function executeBots(botsId, reqBody, userName, executi
 
                 }
 
+            } else if(bots[0].type === 'lambda') {
+
             } else {
                 var error = new Error();
                 logger.error("task_id"+taskId+" There is no record available in DB against BOT :"+botsId)
@@ -1514,3 +1518,33 @@ botService.getAllBotsList = function getAllBotsList(botsQuery, userName, callbac
         return;
     });
 }
+
+botService.addBotHistoryAudit = function addBotHistoryAudit(obj, userName, callback) {
+    botHistoryAuditTrail.addBotHistoryAudit(obj, (err, status) => {
+        if(err) {
+            callback(err, null);
+        } else {
+            callback(null, status);
+        };
+    });
+};
+
+botService.insertBotHistoryAudit = function insertBotHistoryAudit(objList, userName, callback) {
+    botHistoryAuditTrail.insertBotHistoryAudit(objList, (err, status) => {
+        if(err) {
+            callback(err, null);
+        } else {
+            callback(null, status);
+        };
+    });
+};
+
+botService.getBotHistoryAudit = function getBotHistoryAudit(actionLogId, callback) {
+    botHistoryAuditTrail.findOneByQuery({ actionLogId : actionLogId }, {}, {}, (err, status) => {
+        if(err) {
+            callback(err, null);
+        } else {
+            callback(null, status);
+        };
+    });
+};