@idiamantino/livepro-utils/aws/dynamodb.js

Stuff for LP

 "use strict"; 
// Libraries 
// const DDB_PROCESS_CLIENTS = "livepro_process_client";
// const DDB_CLIENT_PROCESSES = "livepro_client_processes";
// const DDB_PROCESS_PER_CLIENT = "livepro_process_per_client";
// const DDB_PROCESS_IN_PROGRESS = "livepro_process_in_progress";

const DDB_INDEXER_OBJECTS = "indexer_objects";
const DDB_GLOBALCONFIG = "globalconfig";
const DDB_CLIENTS = "clients";
const DDB_SOLR = "solr";
const DDB_DATABASES = "databases";
const DDB_PROCESS_ENDPOINTS = "processes_endpoints";
const DDB_PROCESS_QUEUE = "processes_queue";
const DDB_PROCESS_SCHEDULE = "processes_schedule";

const AWS = require('aws-sdk');

const Utils = require("../library/utils");
let LpUtils = new Utils();
const { v1: uuidv1 } = require('uuid');

const dynamoattr = require('dynamodb-data-types').AttributeValue;

 class DynamoDB {
     
    constructor(region, apiVersion = '2012-08-10', debug = false) {
        this.setDebug(debug);
        this.region = region;
        LpUtils.printDebug("Dynamodb constructor region:", region);
        
        AWS.config.update({region:this.region});
        this.ddb = new AWS.DynamoDB({apiVersion: apiVersion}, { region: this.region });
        this.ddbClient = new AWS.DynamoDB.DocumentClient({ service: this.ddb });
    }
    
    setDebug(debug = false) {
        this.debug = debug;
        LpUtils.setDebug(debug);
    }
    
    async test(params){
         LpUtils.printDebug("Dynamodb function accessible:", params);
         LpUtils.printDebug("Region:", this.region);
        //  this.setProcessQueueStatus("cdf2c150-c724-11ea-94ea-5d5d37731bbc","testing: " + params);
         
         let result = "";
         
        //  result = await this.getIndexerObjects("qa416");
        //  console.log(result);
         
        //  result = await this.setIndexerObjectStatus("1f706780-e66f-11ea-9ec9-b385466e4e56","processing");
        //  console.log(result);
        
        //  result = await this.getClient("test");
        //  console.log(result);
         
        //  console.log(this.getProcessQueue("qa415"));
        //  await this.getIndexerObjects("qa416");
         
         return (true);
    }
    
    async getProcessClientById(processId = "", limit = "") {
        // LpUtils.printDebug("Process ID", processId);
        let processesList = await this.getProcessClient(processId, "", "", "", limit);
        if(processesList.length > 0)
        return processesList[0];
    }
    
    async getProcessQueueByClientName(clientName = "", limit = "") {
        let processesList = await this.getProcessClient("", clientName, "", "", limit);
        return processesList;
    }
    
    async getProcessQueueByProcessName(processName = "", limit = "") {
        let processesList = await this.getProcessClient("", "", "", processName, limit);
        return processesList;
    }
    
    async getProcessQueueByStatus(processStatus = "", limit = "") {
        let processesList = await this.getProcessClient("", "", processStatus, "", limit);
        return processesList;
    }
    
    async getProcessQueueByClientNameAndProcessInfo(clientName, processStatus, processName, limit = "") {
        let processesList = await this.getProcessClient("", clientName, "", "", limit);
        
        // if(processesList.length > 0) {
        //     processesList.forEach(process => { 
        //       if(process.process_status == processStatus && process.process_name == processName) {
        //           LpUtils.printDebug("Process already found for:", process.client_name);
        //           // TODO: update timed out processes and return false
        //           console.log("Process already exists, not adding duplicate");
        //           existentProcess = process;
        //       }
        //     }); 
        // }
        
        
        // var processLoop = new Promise((resolve, reject) => {
        //     processesList.forEach((process, index, array) => {
        //       LpUtils.printDebug(processStatus + "-" + processName);
        //       if(process.process_status == processStatus && process.process_name == processName) {
        //           LpUtils.printDebug("Process already found for:", process.client_name);
        //           // TODO: update timed out processes and return false
        //           console.log("Process already exists, not adding duplicate");
        //           existentProcess = process;
        //           if (index === array.length -1) resolve();
        //       }
        //     }); 
        // });
        // existentProcess = processLoop.then(() => {
        //     LpUtils.printDebug("Process existent:", existentProcess);
        //     return existentProcess;
        // });
        
        // return existentProcess;
        
        let existentProcess = false;
        processesList.forEach((process, index, array) => {
            if(process.process_status == processStatus && process.process_name == processName) {
                // existentProcess.push(process);
                existentProcess = process;
            }
        });
        LpUtils.printDebug("Process existent:", existentProcess);
        return existentProcess;
        
    }
    
    async getProcessClient(processId = "", clientName = "", processStatus = "", processName = "", limit = "") {
        console.log("List processes from the process table in Dynamodb");
        
        let results = [];
        let items;
        let params;
        
        // QUERY with process_status
        if(processStatus !== "") {
            params = {
                TableName: DDB_PROCESS_QUEUE,
                IndexName: 'process_status-index',
                KeyConditionExpression: "#process_status = :process_status",
                ExpressionAttributeNames:{
                    "#process_status": "process_status"
                    },
                ExpressionAttributeValues: {
                    ":process_status":{"S" : processStatus}
                    }
            };
        } 
        
        // Query with process_id
        if(processId !== "") {
            params = {
                TableName: DDB_PROCESS_QUEUE,
                KeyConditionExpression: "#id = :id",
                ConsistentRead: true,
                ExpressionAttributeNames:{
                    "#id": "id"
                    },
                ExpressionAttributeValues: {
                    ":id":{"S" : processId}
                    }
            };
        } 
        
        // QUERY with clientName    
        if (clientName != "") {
            params = {
                TableName: DDB_PROCESS_QUEUE,
                IndexName: 'client_name-index',
                KeyConditionExpression: "#client_name = :client_name",
                ExpressionAttributeNames:{
                    "#client_name": "client_name"
                    },
                ExpressionAttributeValues: {
                    ":client_name":{"S" : clientName}
                    }
            };
        }
        
        LpUtils.printDebug("DDB Params:", params);
        
        if(limit !== "") params.Limit = limit;
        
        do{
            let i = 0;
            items =  await this.ddb.query(params).promise();
            items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
            params.ExclusiveStartKey  = items.LastEvaluatedKey;
            i++;
            if(i >= limit) break;
        }while(typeof items.LastEvaluatedKey != "undefined");
        return(results);
    }
    
    async setProcessQueueStatus(processId, processStatus) {
        let resultJson;
        LpUtils.printDebug("Set Process Status", processId + "->" + processStatus);
        const statusUpdated = await this.ddbUpdateProcessClientProcessStatus(processId, processStatus, DDB_PROCESS_QUEUE);
        if(statusUpdated)
            return(true);
        else
            return(false);
    }
    
    async setIndexerObjectStatus(processId, processStatus) {
        let resultJson;
        LpUtils.printDebug("Set Process Status", processId + "->" + processStatus);
        const statusUpdated = await this.ddbUpdateIndexerObjectsProcessStatus(processId, processStatus, DDB_INDEXER_OBJECTS);
        if(statusUpdated)
            return(true);
        else
            return(false);
    }
    
    async updateClientSecrets(clientName, systemSecret = "", processSecret = "") {
        let client = await this.getClient(clientName);
        if(client[0] === undefined || client[0] === "") {
            console.log("Client not found while updating secrets: " + clientName);
            return(false);
        } else {
            client = client[0];
        }
        
        if(systemSecret !== "") client.system_secret = systemSecret;
        if(processSecret !== "") client.process_secret = processSecret;
        // console.log(client);
        if(client.client_name === undefined) {
            console.log("Client name is undefined ");
            return(false);
        } else {
            try {
                return this.ddbAddClient(client.client_uid, client.client_name, client.database_client_name, client.database_server_name, client.solr_client_name, client.solr_server_name, client.client_subdomain, client.report_uid, client.system_secret, client.process_secret, client.client_url);
            } catch (error) {
                console.log(error);
                return(false);
            }
        }
    }
    
    async updateClient(clientUid = "", clientName = "", databaseClientName = "",databaseServerName = "",solrClientName = "",solrServerName = "",clientSubdomain = "",reportUid = "",systemSecret = "", processSecret = "", clientUrl = "", dateCreated = "") {
        let client;
        if(clientUid !== "") {
            this.getClient()
        } else if (clientName !== "") {
            client = this.getClient(clientName);
        } else {
            
        }
    }
    
    async getClient(clientName = "") {
        console.log("List clients from Dynamodb:", clientName);
        let results = [];
        let items;
        let params;
        
        // QUERY with process_status
        if(clientName !== "") {
            params = {
                TableName: DDB_CLIENTS,
                KeyConditionExpression: "#client_name = :client_name",
                IndexName: 'client_name-index',
                ExpressionAttributeNames:{
                    "#client_name": "client_name"
                    },
                ExpressionAttributeValues: {
                    ":client_name":{"S" : clientName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else {
           params = {
                TableName: DDB_CLIENTS
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.scan(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
        }
        return(results);
    }
    
    async getSolr(solrName) {
        console.log("List solr from Dynamodb:", solrName);
        let results = [];
        let items;
        let params;
        
        // QUERY with process_status
        if(solrName !== "") {
            params = {
                TableName: DDB_SOLR,
                KeyConditionExpression: "#solr_name = :solr_name",
                IndexName: 'solr_name-index',
                ExpressionAttributeNames:{
                    "#solr_name": "solr_name"
                    },
                ExpressionAttributeValues: {
                    ":solr_name":{"S" : solrName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else {
            LpUtils.printDebug("client_name must be defined");
        }
        return(results);
    }
    
    async getDatabase(databaseName) {
        console.log("List database from Dynamodb:", databaseName);
        let results = [];
        let items;
        let params;
        
        // QUERY with process_status
        if(databaseName !== "") {
            params = {
                TableName: DDB_DATABASES,
                KeyConditionExpression: "#database_name = :database_name",
                IndexName: 'database_name-index',
                ExpressionAttributeNames:{
                    "#database_name": "database_name"
                    },
                ExpressionAttributeValues: {
                    ":database_name":{"S" : databaseName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else {
            LpUtils.printDebug("databaseName must be defined");
        }
        return(results);
    }
    
    async getIndexerObjects(clientName = "", processStatus = "", limit = "") {
        console.log("List Indexer Objects from Dynamodb:", clientName);
        let results = [];
        let items;
        let params;
        
        if(clientName !== "") {
            params = {
                TableName: DDB_INDEXER_OBJECTS,
                IndexName: 'client_name-index',
                KeyConditionExpression: "#client_name = :client_name",
                ExpressionAttributeNames:{
                    "#client_name": "client_name"
                    },
                ExpressionAttributeValues: {
                    ":client_name":{"S" : clientName}
                    }
            };
        }
        if(processStatus !== "") {
            params = {
                TableName: DDB_INDEXER_OBJECTS,
                IndexName: 'process_status-index',
                KeyConditionExpression: "#process_status = :process_status",
                ExpressionAttributeNames:{
                    "#process_status": "process_status"
                    },
                ExpressionAttributeValues: {
                    ":process_status":{"S" : processStatus}
                    }
            };
        } 
        // LpUtils.printDebug("Dynamodb Params:", params);
        
        if(limit !== "") params.Limit = limit;
        do{
            let i = 0;
            items =  await this.ddb.query(params).promise();
            items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
            params.ExclusiveStartKey  = items.LastEvaluatedKey;
            i++;
            if(i >= limit) break;
        }while(typeof items.LastEvaluatedKey != "undefined");
        return(results);
    }
    
    async getProcessSchedule(clientName = "", processName = "") {
        console.log("List processes schedule from Dynamodb");
        let results = [];
        let items;
        let params;
        
        if(processName !== "") {
            params = {
                TableName: DDB_PROCESS_SCHEDULE,
                KeyConditionExpression: "#process_name = :process_name",
                ExpressionAttributeNames:{
                    "#process_name": "process_name"
                    },
                ExpressionAttributeValues: {
                    ":process_name":{"S" : processName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else if(clientName !== "") {
            params = {
                TableName: DDB_PROCESS_SCHEDULE,
                KeyConditionExpression: "#client_name = :client_name",
                ExpressionAttributeNames:{
                    "#client_name": "client_name"
                    },
                ExpressionAttributeValues: {
                    ":client_name":{"S" : clientName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");    
            
        } else {
            params = {
                TableName: DDB_PROCESS_SCHEDULE
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.scan(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
        }
        return(results);
    }
    
    async getProcessEndpoints(processName = "") {
        console.log("List processes endpoints from Dynamodb:", processName);
        let results = [];
        let items;
        let params;
        
        if(processName !== "") {
            params = {
                TableName: DDB_PROCESS_ENDPOINTS,
                KeyConditionExpression: "#process_name = :process_name",
                ExpressionAttributeNames:{
                    "#process_name": "process_name"
                    },
                ExpressionAttributeValues: {
                    ":process_name":{"S" : processName}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else {
            params = {
                TableName: DDB_PROCESS_ENDPOINTS
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            do{
                items =  await this.ddb.scan(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
        }
        return(results);
    }
    
    async getGlobalConfig(globalconfigCode) {
        console.log("List globalconfig from Dynamodb:", globalconfigCode);
        let results = [];
        let items;
        let params;
        
        // QUERY with process_status
        if(globalconfigCode !== "") {
            params = {
                TableName: DDB_GLOBALCONFIG,
                KeyConditionExpression: "#globalconfig_code = :globalconfig_code",
                IndexName: 'globalconfig_code-index',
                ExpressionAttributeNames:{
                    "#globalconfig_code": "globalconfig_code"
                    },
                ExpressionAttributeValues: {
                    ":globalconfig_code":{"S" : globalconfigCode}
                    }
            };
            LpUtils.printDebug("Dynamodb Params:", params);
            
            do{
                items =  await this.ddb.query(params).promise();
                items.Items.forEach((item) => results.push(dynamoattr.unwrap(item)));
                params.ExclusiveStartKey  = items.LastEvaluatedKey;
            }while(typeof items.LastEvaluatedKey != "undefined");
            
        } else {
            LpUtils.printDebug("globalconfig_code must be defined");
        }
        return(results);
    }
    
    
    /** 
     * Indexer Objects Table Section
     */
    async ddbUpdateIndexerObjectsProcessStatus(indexerUid, processStatus, tableName) {
        if(tableName === "") tableName = DDB_INDEXER_OBJECTS;
        var paramsdb = {
            TableName: tableName,
            Key: {
                "indexer_uid": indexerUid
            },
            UpdateExpression: "set process_status = :process_status",
            ExpressionAttributeValues: {":process_status": processStatus},
            ReturnValues:"UPDATED_NEW"
        };
        const updated = new Promise((res, rej) => {
            console.log(paramsdb); 
            res(true);
            this.ddbClient.update(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    async ddbAddIndexerObject(indexerUid, urlSolr, clientName, content, type, processStatus, s3PathContent, dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
            "TableName": DDB_INDEXER_OBJECTS,
            "Item": {
                "indexer_uid": { S: indexerUid },
                "url_solr": {"S": urlSolr},
                "client_name": {"S": clientName},
                "content": {"S": JSON.stringify(content)},
                "type": {"S": type},
                "s3_path_content": {"S": s3PathContent},
                "process_status": {"S": processStatus},
                "date_created": {"S": dateCreated},
                "date_updated": {"S": dateUpdated},
            },
            "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
        };
        
        LpUtils.printDebug("Process Client DDB Params: ", paramsdb);
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    /** 
     * Process Client Table Section
     */
    
    async ddbAddProcessClient(uid, clientName, processStatus, processName, dateExecution, dateCreated, dateUpdated, priority, processUrl, checkResponse) {
        let paramsdb = {
            "TableName": DDB_PROCESS_QUEUE,
            "Item": {
                "id": { S: uid },
                "client_name": {"S": clientName},
                "process_status": {"S": processStatus},
                "process_name": {"S": processName},
                "date_execution": {"S": dateExecution},
                "date_created": {"S": dateCreated},
                "date_updated": {"S": dateUpdated},
                "priority": {"N": priority},
                "process_url": {"S": processUrl},
                "check_response": {"BOOL": checkResponse}
            },
            "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
        };
        LpUtils.printDebug("Process Client DDB Params: ", paramsdb);
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    // V2: Update client with only fields for the new environment
    async ddbUpdateClient(ddbClient) {
        let paramsdb = {
                "TableName": DDB_CLIENTS,
                "Item": {},
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        
        if(ddbClient['client_name'] === undefined || ddbClient['client_name'] === "") {
            console.log("Client Name can't be empty");
            return false;
        }
        if(ddbClient['client_uid'] === undefined || ddbClient['client_uid'] === "") {
            ddbClient['client_uid'] = LpUtils.randomString(10, true) + "-" + uuidv1();
        }
        
        let currentTimestamp = Math.floor(Date.now() / 1000);
        ddbClient["date_updated"] = currentTimestamp.toString();
        if(ddbClient["date_created"] === "") ddbClient["date_created"] = ddbClient["date_updated"];
        
        if(ddbClient["client_uid"] !== undefined && ddbClient['client_uid'] !== "")  paramsdb.Item.client_uid = {"S": ddbClient['client_uid']};
        if(ddbClient["client_name"] !== undefined && ddbClient['client_name'] !== "")  paramsdb.Item.client_name = {"S": ddbClient['client_name']};
        if(ddbClient["database_username"] !== undefined && ddbClient['database_username'] !== "")  paramsdb.Item.database_username = {"S": ddbClient['database_username']};
        if(ddbClient["database_password"] !== undefined && ddbClient['database_password'] !== "")  paramsdb.Item.database_password = {"S": ddbClient['database_password']};
        if(ddbClient["database_name"] !== undefined && ddbClient['database_name'] !== "")  paramsdb.Item.database_name = {"S": ddbClient['database_name']};
        if(ddbClient["subdomain"] !== undefined && ddbClient['subdomain'] !== "")  paramsdb.Item.subdomain = {"S": ddbClient['subdomain']};
        if(ddbClient["domain"] !== undefined && ddbClient['domain'] !== "")  paramsdb.Item.domain = {"S": ddbClient['domain']};
        if(ddbClient["date_created"] !== undefined && ddbClient['date_created'] !== "")  paramsdb.Item.date_created = {"S": ddbClient['date_created']};
        if(ddbClient["date_updated"] !== undefined && ddbClient['date_updated'] !== "")  paramsdb.Item.date_updated = {"S": ddbClient['date_updated']};
        
        LpUtils.printDebug("Client ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    
    /** 
     * Client Table Section
     */
    async ddbAddClient(clientUid,clientName,databaseClientName = "",databaseServerName = "",solrClientName = "",solrServerName = "",clientSubdomain = "",reportUid = "",systemSecret = "", processSecret = "", clientUrl = "", dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_CLIENTS,
                "Item": {
                    "client_uid": { S: clientUid },
                    "client_name": {"S": clientName},
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(databaseClientName !== "")  paramsdb.Item.database_client_name = {"S": databaseClientName};
        if(databaseServerName !== "")  paramsdb.Item.database_server_name = {"S": databaseServerName};    
        if(solrClientName !== "")  paramsdb.Item.solr_client_name = {"S": solrClientName};    
        if(solrServerName !== "")  paramsdb.Item.solr_server_name = {"S": solrServerName};    
        if(clientSubdomain !== "")  paramsdb.Item.client_subdomain = {"S": clientSubdomain};    
        if(reportUid !== "")  paramsdb.Item.report_uid = {"S": reportUid};    
        if(systemSecret !== "")  paramsdb.Item.system_secret = {"S": systemSecret};
        if(processSecret !== "")  paramsdb.Item.process_secret = {"S": processSecret};
        if(clientUrl !== "")  paramsdb.Item.client_url = {"S": clientUrl};    

        LpUtils.printDebug("Client ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    async ddbUpdateProcessClientProcessStatus(id, processStatus, tableName) {
        if(tableName === "") tableName = DDB_PROCESS_QUEUE;
        var paramsdb = {
            TableName: tableName,
            Key: {
                id: id
            },
            UpdateExpression: "set process_status = :process_status",
            ExpressionAttributeValues: {":process_status": processStatus},
            ReturnValues:"UPDATED_NEW"
            };
            const updated = new Promise((res, rej) => {
                this.ddbClient.update(paramsdb, function(err, data) {
                  if (err) {
                    console.log("Error", err);
                    rej(false);
                  } else {
                    res(true);
                  }
                }); 
            });
            return(await updated);
    }
    
    
    /** 
     * Solr Table Section
     */
    async ddbAddSolr(solrUid,solrName,solrReadHost = "",solrWriteHost = "", dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_SOLR,
                "Item": {
                    "solr_uid": { S: solrUid },
                    "solr_name": {"S": solrName},
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(solrReadHost !== "")  paramsdb.Item.solr_read_host = {"S": solrReadHost};
        if(solrWriteHost !== "")  paramsdb.Item.solr_write_host = {"S": solrWriteHost};    
        
        LpUtils.printDebug("Solr ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    /** 
     * Database Table Section
     */
    async ddbAddDatabase(databaseUid ,databaseName ,databaseUsername = "",databasePassword = "",databaseHost = "", databaseEndpoint = "",databaseReplicaEndpoint = "", dateCreated = "") {

        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_DATABASES,
                "Item": {
                    "database_uid": { S: databaseUid },
                    "database_name": {"S": databaseName},
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(databaseUsername !== "")  paramsdb.Item.database_username = {"S": databaseUsername};
        if(databasePassword !== "")  paramsdb.Item.database_password = {"S": databasePassword};
        if(databaseHost !== "")  paramsdb.Item.database_host = {"S": databaseHost};
        if(databaseEndpoint !== "")  paramsdb.Item.database_endpoint = {"S": databaseEndpoint};
        if(databaseReplicaEndpoint !== "")  paramsdb.Item.database_replica_endpoint = {"S": databaseReplicaEndpoint};
        
        LpUtils.printDebug("Database ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    /** 
     * Global Config Table Section
     */
    async ddbAddGlobalConfig(globalconfigUid,globalconfigCode,globalconfigContent = "",globalconfigSection = "", dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_GLOBALCONFIG,
                "Item": {
                    "globalconfig_uid": { S: globalconfigUid },
                    "globalconfig_code": {"S": globalconfigCode},
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(globalconfigContent !== "")  paramsdb.Item.globalconfig_content = {"S": globalconfigContent};
        if(globalconfigSection !== "")  paramsdb.Item.globalconfig_section = {"S": globalconfigSection};    
        
        LpUtils.printDebug("Global Config ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    /** 
     * Process Schedule Table Section
     */
     async ddbAddProcessSchedule(uid, processName, clientName = "", cronExpression = "", dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_PROCESS_SCHEDULE,
                "Item": {
                    "id": { "S": uid },
                    "process_name": { "S": processName },
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(clientName !== "")  paramsdb.Item.client_name = {"S": clientName};
        if(cronExpression !== "")  paramsdb.Item.cron_expression = {"S": cronExpression};
        
        LpUtils.printDebug("Process Schedule ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }
    
    /** 
     * Process Endpoints Table Section
     */
     async ddbAddProcessEndpoints(processName, checkResponse = "", priority = "", processType = "", processUrl = "", expirationMinutes = "", dateCreated = "") {
        let currentTimestamp = Math.floor(Date.now() / 1000);
        let dateUpdated = currentTimestamp.toString();
        if(dateCreated === "") dateCreated = dateUpdated;
        let paramsdb = {
                "TableName": DDB_PROCESS_ENDPOINTS,
                "Item": {
                    "process_name": { "S": processName },
                    "date_created": {"S": dateCreated},
                    "date_updated": {"S": dateUpdated}
                },
                "ConditionExpression": 'attribute_not_exists(partitionKey) AND attribute_not_exists(sortKey)'
             };
        if(checkResponse !== "")  paramsdb.Item.check_response = {"BOOL": checkResponse};
        if(priority !== "")  paramsdb.Item.priority = {"S": priority};
        if(processType !== "")  paramsdb.Item.process_type = {"S": processType};   
        if(processUrl !== "")  paramsdb.Item.process_url = {"S": processUrl};   
        if(expirationMinutes !== "")  paramsdb.Item.expiration_minutes = {"N": expirationMinutes};
        
        LpUtils.printDebug("Process Endpoints ddb params: ", paramsdb);
        
        const updated = new Promise((res, rej) => {
            this.ddb.putItem(paramsdb, function(err, data) {
              if (err) {
                console.log("Error", err);
                rej(false);
              } else {
                res(true);
              }
            }); 
        });
        return(await updated);
    }

 }

 module.exports = DynamoDB;