zocrmsdkmiblu 0.2.4

package/README.md

@@ -0,0 +1,19 @@
+# BLUELABEL PROGRAMERS SDK ZOHOCRM
+
+Please Install 
+
+    npm i zocrmsdk 
+
+GET RECORD CRM V4
+
+    await  zcrm.initialize({
+    client_id:  "",
+    client_secret:  "",
+    user_identifier:  "",
+    redirect_url:  "",
+    mysql_username:  "",
+    mysql_password:  ""
+    })
+    
+    var  response  =  await  zcrm.API.MODULES.get({ module:  "", id:  "" })
+

package/lib/js/OAuth.js

@@ -0,0 +1,66 @@
+
+var config = null;
+var qs = require('querystring');
+var httpclient = require('request');
+
+var actionvsurl = {
+
+    generate_token:'/oauth/v2/token'
+}
+
+var mand_configurations = {
+
+    generate_token : ['client_id','client_secret','redirect_uri','code','grant_type'],
+    refresh_access_token : ['client_id','client_secret','grant_type','refresh_token']
+}
+
+
+var OAuth = function (configuration,action) {
+  if (!configuration)
+    throw new Error('Missing configuration for Zoho OAuth2 service');
+    assertConfigAttributesAreSet(configuration, mand_configurations[action]);
+    config = configuration;
+};
+
+
+function assertConfigAttributesAreSet(configuration, attributes) {
+  attributes.forEach(function (attribute) {
+    if (!configuration[attribute])
+      throw new Error('Missing configuration for Zoho OAuth service: '+ attribute);
+  });
+}
+
+OAuth.constructurl=function(action){
+
+    var crmclient = require('./ZCRMRestClient');
+    var url = "https://"+crmclient.getIAMUrl()+actionvsurl[action]+'?' + qs.stringify(config);
+    return url;
+
+}
+
+ OAuth.generateTokens=function(url){
+ return new Promise(function(resolve,reject){
+
+    httpclient.post(url,{
+
+    },function (err, response) {
+
+        var resultObj = {};
+
+        if(err){
+
+            resolve(err);
+        }
+        resolve(response);
+    
+    });
+    })
+ }
+
+ 
+module.exports = OAuth;
+
+
+
+
+

package/lib/js/REST_API/Records.js

@@ -0,0 +1,88 @@
+var util = require('../util');
+
+var modules = function modules()
+{
+    
+    return {
+        get : function(input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}", HTTP_METHODS.GET, false));//No I18N
+        },
+        getRelated : function(input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}/"+input.related_module, HTTP_METHODS.GET, false));//No I18N
+        },
+        post : function(input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}", HTTP_METHODS.POST, false));//No I18N
+        },
+        put : function(input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}", HTTP_METHODS.PUT, false));//No I18N
+        },
+        delete : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}", HTTP_METHODS.DELETE, false));//No I18N
+        },
+        getAllDeletedRecords : function (input)
+        {
+            if (input.params)
+            {
+                input.params.type = "all";
+            }
+            else
+            {
+                input.params = {
+                    "type" : "all"//No I18N
+                };
+            }
+
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/deleted", HTTP_METHODS.GET, false));//No I18N
+        },
+        getRecycleBinRecords : function (input)
+        {
+            if (input.params)
+            {
+                input.type = "recycle";
+            }
+            else
+            {
+                input.params = {
+                    "type" : "recycle"//No I18N
+                };
+            }
+
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/deleted", HTTP_METHODS.GET, false));//No I18N
+        },
+        getPermanentlyDeletedRecords : function (input)
+        {
+            if (input.params)
+            {
+                input.type = "permanent";
+            }
+            else
+            {
+                input.params = {
+                    "type" : "permanent"//No I18N
+                };
+            }
+
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/deleted", HTTP_METHODS.GET, false));//No I18N
+        },
+        search : function (input)
+        {   
+            var query = util.convertToCOQLQuery(input.params.criteria,'id',input.module,input.params.page || 0,input.params.per_page || 200)
+            input.body = {select_query:query}
+            console.log(input)
+            //return util.promiseResponse(util.constructRequestDetails(input, input.module + "/search", HTTP_METHODS.GET, false));//No I18N
+
+            return this.coql(input)
+        },
+        coql: function(input) {
+            input.api_name = 'coql';
+            return util.promiseResponse(util.constructRequestDetails(input, input.api_name, HTTP_METHODS.POST, false));//No I18N
+        }
+    }
+}
+
+module.exports = modules;

package/lib/js/REST_API/actions.js

@@ -0,0 +1,31 @@
+var util = require("../util");
+
+var actions = function actions()
+{
+    return {
+        convert : function (input)
+        {
+
+            return util.promiseResponse(util.constructRequestDetails(input, "Leads/{id}/actions/convert", HTTP_METHODS.POST, false));//No I18N
+        },
+        blueprint : function (input)
+        {
+
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+"/{id}/actions/blueprint", HTTP_METHODS.PUT, false));//No I18N
+        },
+        getblueprint : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+"/{id}/actions/blueprint", HTTP_METHODS.GET, false));//No I18N
+        },
+        sendemail : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+"/{id}/actions/send_mail", HTTP_METHODS.POST, false));//No I18N
+        },
+        emailAttchDownload : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+"/{id}/Emails/actions/download_attachments", HTTP_METHODS.GET, false));//No I18N
+        },
+    }
+}
+
+module.exports = actions;

package/lib/js/REST_API/attachments.js

@@ -0,0 +1,44 @@
+
+var util = require('../util');
+var attachments = function attachments()
+{
+    
+    return {
+        uploadFile : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+ "/{id}/Attachments", HTTP_METHODS.POST, false));//No I18N
+        },
+        deleteFile : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+ "/{id}/Attachments/"+input.relatedId, HTTP_METHODS.DELETE, false));//No I18N
+        },
+        downloadFile : function (input)
+        {
+            input.download_file = true;
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+ "/{id}/Attachments/"+input.relatedId, HTTP_METHODS.GET, false));//No I18N
+        },
+        uploadLink : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+ "/{id}/Attachments", HTTP_METHODS.POST, false));//No I18N
+        },
+        uploadPhoto : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module+ "/{id}/photo", HTTP_METHODS.POST, false));//No I18N
+        },
+        downloadPhoto : function (input)
+        {
+            input.download_file = true;
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}/photo", HTTP_METHODS.GET, false));//No I18N
+        },
+        deletePhoto : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}/photo", HTTP_METHODS.DELETE, false));//No I18N
+        },
+        getAllAttachments : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, input.module + "/{id}/attachments", HTTP_METHODS.GET, false));//No I18N
+        }
+    }
+}
+
+module.exports = attachments;

package/lib/js/REST_API/functions.js

@@ -0,0 +1,22 @@
+var util = require('../util');
+var url = "functions/{api_name}/actions/execute";
+
+var functions = function functions(){
+
+    return{
+
+        executeFunctionsInGet :function(input){
+
+            
+            return util.promiseResponse(util.constructRequestDetails(input, url , HTTP_METHODS.GET, true));//No I18N
+        },
+
+        executeFunctionsInPost :function(input){
+
+            return util.promiseResponse(util.constructRequestDetails(input, url , HTTP_METHODS.POST, true));//No I18N
+        }
+    }
+   
+}
+
+module.exports = functions;

package/lib/js/REST_API/org.js

@@ -0,0 +1,18 @@
+
+var util = require('../util');
+
+var org = function org()
+{ 
+    return {
+        get : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "org", HTTP_METHODS.GET, true));//No I18N
+        },  
+        authoken:function(isInvalid=false)
+        {
+            return util.getAuthToken(isInvalid)
+        }
+    }
+}
+
+module.exports = org;

package/lib/js/REST_API/settings.js

@@ -0,0 +1,46 @@
+var util = require('../util');
+
+var settings = function settings()
+{
+    
+    return {
+        getFields : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/fields/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getLayouts : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/layouts/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getCustomViews : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/custom_views/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        updateCustomViews : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/custom_views/{id}", HTTP_METHODS.PUT, true));//No I18N
+        },
+        getModules : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/modules" + ((input && input.module) ? "/" + input.module : ""), HTTP_METHODS.GET, false));//No I18N
+        },
+        getRoles : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/roles/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getProfiles : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/profiles/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getRelatedLists : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/related_lists/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getInventoryTemplates : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "settings/inventory_templates/{id}", HTTP_METHODS.GET, false));//No I18N
+        }
+    }
+}
+
+module.exports = settings;

package/lib/js/REST_API/users.js

@@ -0,0 +1,19 @@
+var util = require('../util');
+
+var users = function users()
+{
+    
+    return {
+        get : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "users/{id}", HTTP_METHODS.GET, true));//No I18N
+        },
+        getUsersType : function (input)
+        {
+            return util.promiseResponse(util.constructRequestDetails(input, "users", HTTP_METHODS.GET, true));//No I18N
+        },
+    }
+}
+
+
+module.exports = users;

package/lib/js/ZCRMRestClient.js

@@ -0,0 +1,341 @@
+
+var OAuth = require('./OAuth');
+var path = require("path");
+
+
+
+var persistenceModule = path.dirname(__filename) + "/mysql/mysql_util";
+var iamurl = "accounts.zoho.com";
+var baseURL = "www.zohoapis.com";
+var version = "v2.1";
+var mysql_username = process.env.MYSQL_USER;
+var mysql_password = process.env.MYSQL_PASSWORD;
+var default_user_identifier = "zcrm_default_user";
+
+var client_id = process.env.CLIENT_ID;
+var client_secret = process.env.CLIENT_SECRET;
+var redirect_url = process.env.REDIRECT_URL;
+var user_identifier = process.env.USER_IDENTIFIER;
+
+var ZCRMRestClient = function () { };
+
+ZCRMRestClient.initialize = function (configJSON) {
+
+
+    return new Promise(function (resolve, reject) {
+
+        if (configJSON) {
+
+            ZCRMRestClient.initializeWithValues(configJSON);
+            resolve();
+
+        }
+
+        var PropertiesReader = require('properties-reader');
+        var properties = PropertiesReader('resources/oauth_configuration.properties');
+        var client_id = properties.get('zoho.crm.clientid');
+        var client_secret = properties.get('zoho.crm.clientsecret');
+        var redirect_url = properties.get('zoho.crm.redirecturl');
+        var iam_url = properties.get('zoho.crm.iamurl') ? properties.get('zoho.crm.iamurl') : iamurl;
+
+        var config_properties = PropertiesReader('resources/configuration.properties');
+
+        persistenceModule = config_properties.get('crm.api.tokenmanagement') ? config_properties.get('crm.api.tokenmanagement') : persistenceModule;
+
+        baseURL = config_properties.get('crm.api.url') ? config_properties.get('crm.api.url') : baseURL;
+
+        mysql_username = config_properties.get('mysql.username') ? config_properties.get('mysql.username') : mysql_username;
+
+        mysql_password = config_properties.get('mysql.password') ? config_properties.get('mysql.password') : mysql_password;
+
+
+        if (config_properties.get('crm.api.user_identifier')) {
+
+            ZCRMRestClient.setUserIdentifier(config_properties.get('crm.api.user_identifier'));
+        }
+        else {
+
+            ZCRMRestClient.setUserIdentifier(default_user_identifier);
+        }
+
+        if (!client_id || !client_secret || !redirect_url) {
+
+            throw new Error("Populate the oauth_configuration.properties file");
+
+        }
+
+        ZCRMRestClient.setClientId(client_id);
+        ZCRMRestClient.setClientSecret(client_secret);
+        ZCRMRestClient.setRedirectURL(redirect_url);
+        ZCRMRestClient.setIAMUrl(iam_url);
+
+
+        resolve();
+
+    })
+}
+
+ZCRMRestClient.initializeWithValues = function (configJSON) {
+
+    var mandatory_values = ['client_id', 'client_secret', 'redirect_url']
+    mandatory_values.forEach(function (key) {
+        if (!configJSON[key]) {
+            throw new Error('Missing configuration for Zoho OAuth service: ' + key);
+        }
+    })
+    var client_id = configJSON.client_id;
+    var client_secret = configJSON.client_secret;
+    var redirect_url = configJSON.redirect_url;
+    var iam_url = configJSON.iamurl ? configJSON.iamurl : iamurl;
+    var useridentifier = configJSON.user_identifier ? configJSON.user_identifier : default_user_identifier;
+
+    mysql_username = configJSON.mysql_username ? configJSON.mysql_username : mysql_username;
+    mysql_password = configJSON.mysql_password ? configJSON.mysql_password : mysql_password;
+    baseURL = configJSON.base_url ? configJSON.base_url : baseURL;
+    version = configJSON.version ? configJSON.version : version;
+    persistenceModule = configJSON.tokenmanagement ? configJSON.tokenmanagement : persistenceModule;
+
+    ZCRMRestClient.setClientId(client_id);
+    ZCRMRestClient.setClientSecret(client_secret);
+    ZCRMRestClient.setRedirectURL(redirect_url);
+    ZCRMRestClient.setIAMUrl(iam_url);
+    ZCRMRestClient.setUserIdentifier(useridentifier);
+
+}
+
+ZCRMRestClient.generateAuthTokens = function (user_identifier, grant_token) {
+
+    return new Promise(function (resolve, reject) {
+
+        if (!user_identifier) {
+
+            user_identifier = ZCRMRestClient.getUserIdentifier();
+        }
+
+        var config = ZCRMRestClient.getConfig(grant_token);
+        new OAuth(config, "generate_token");
+        var api_url = OAuth.constructurl("generate_token");
+
+        OAuth.generateTokens(api_url).then(function (response) {
+
+            if (response.statusCode != 200) {
+
+                throw new Error("Problem occured while generating access token from grant token. Response : " + JSON.stringify(response));
+
+            }
+
+            var persistence_module = require(persistenceModule);
+            var resultObj = ZCRMRestClient.parseAndConstructObject(response);
+            resultObj.user_identifier = user_identifier;
+
+            if (resultObj.access_token) {
+
+                persistence_module.saveOAuthTokens(resultObj).then(function (save_resp) {
+
+                    ZCRMRestClient.setUserIdentifier(user_identifier),
+
+                        resolve(resultObj)
+
+                }
+
+                );
+            }
+            else {
+
+                throw new Error("Problem occured while generating access token and refresh token from grant token.Response : " + JSON.stringify(response));
+            }
+        })
+    })
+}
+
+
+ZCRMRestClient.generateAuthTokenfromRefreshToken = function (user_identifier, refresh_token) {
+
+    return new Promise(function (resolve, reject) {
+
+        if (!user_identifier) {
+
+            user_identifier = ZCRMRestClient.getUserIdentifier();
+        }
+
+        var config = ZCRMRestClient.getConfig_refresh(refresh_token);
+        new OAuth(config, "refresh_access_token");
+        var api_url = OAuth.constructurl("generate_token");
+
+        OAuth.generateTokens(api_url).then(function (response) {
+
+            if (response.statusCode != 200) {
+
+                throw new Error("Problem occured while generating access token from refresh token . Response : " + JSON.stringify(response));
+
+            }
+            var persistence_module = require(persistenceModule);
+            var resultObj = ZCRMRestClient.parseAndConstructObject(response);
+
+            resultObj.user_identifier = user_identifier;
+            resultObj.refresh_token = refresh_token;
+
+            if (resultObj.access_token) {
+
+                persistence_module.saveOAuthTokens(resultObj).then(function (save_response) {
+
+                    ZCRMRestClient.setUserIdentifier(user_identifier),
+                        resolve(resultObj)
+
+                }
+
+                );
+            }
+            else {
+                throw new Error("Problem occured while generating access token from refresh token. Response : " + JSON.stringify(response));
+
+            }
+
+
+        })
+    })
+};
+
+
+ZCRMRestClient.getConfig = function (grant_token) {
+
+    var config = {};
+
+    config.client_id = ZCRMRestClient.getClientId();
+    config.client_secret = ZCRMRestClient.getClientSecret();
+    config.code = grant_token;
+    config.redirect_uri = ZCRMRestClient.getRedirectURL();
+    config.grant_type = "authorization_code";
+
+    return config;
+
+};
+
+ZCRMRestClient.getConfig_refresh = function (refresh_token) {
+
+    var config = {};
+
+    config.client_id = ZCRMRestClient.getClientId();
+    config.client_secret = ZCRMRestClient.getClientSecret();
+    config.refresh_token = refresh_token;
+    config.grant_type = "refresh_token";
+
+    return config;
+
+}
+
+ZCRMRestClient.setClientId = function (clientid) {
+
+    client_id = clientid;
+}
+
+ZCRMRestClient.setClientSecret = function (clientsecret) {
+
+    client_secret = clientsecret;
+
+}
+
+ZCRMRestClient.setRedirectURL = function (redirecturl) {
+
+    redirect_url = redirecturl;
+}
+
+ZCRMRestClient.setUserIdentifier = function (useridentifier) {
+
+    user_identifier = useridentifier;
+
+}
+
+ZCRMRestClient.setIAMUrl = function (iam_url) {
+
+    iamurl = iam_url;
+}
+
+ZCRMRestClient.setBaseURL = function (baseurl) {
+
+    baseURL = baseurl;
+}
+
+ZCRMRestClient.getClientId = function () {
+
+    return client_id;
+
+}
+
+ZCRMRestClient.getClientSecret = function () {
+
+    return client_secret;
+
+}
+
+ZCRMRestClient.getRedirectURL = function () {
+
+    return redirect_url;
+}
+
+ZCRMRestClient.getUserIdentifier = function () {
+
+    if (!user_identifier) {
+
+        return default_user_identifier;
+    }
+    return user_identifier;
+}
+
+ZCRMRestClient.getPersistenceModule = function () {
+
+    return persistenceModule;
+}
+
+ZCRMRestClient.getAPIURL = function () {
+
+    return baseURL;
+}
+
+ZCRMRestClient.getVersion = function (allrecord) {
+
+    return version;
+}
+ZCRMRestClient.getIAMUrl = function () {
+
+    return iamurl;
+}
+ZCRMRestClient.getMySQLUserName = function () {
+
+    return mysql_username;
+}
+ZCRMRestClient.getMYSQLPassword = function () {
+
+    return mysql_password;
+
+}
+ZCRMRestClient.parseAndConstructObject = function (response) {
+
+    var body = response["body"];
+    body = JSON.parse(body);
+
+    var date = new Date();
+    var current_time = date.getTime();
+
+    var resultObj = {};
+
+    if (body.access_token) {
+
+        resultObj.access_token = body.access_token;
+
+        if (body.refresh_token) {
+
+            resultObj.refresh_token = body.refresh_token;
+        }
+        if (!body.expires_in_sec) {
+            body.expires_in = body.expires_in * 1000;
+        }
+        resultObj.expires_in = body.expires_in + current_time;
+    }
+    return resultObj;
+
+}
+
+ZCRMRestClient.API = require('./crmapi');
+
+module.exports = ZCRMRestClient;

package/lib/js/crmapi.js

@@ -0,0 +1,33 @@
+
+var modules = require('./REST_API/Records');
+var settings = require('./REST_API/settings');
+var actions = require('./REST_API/actions');
+var users = require('./REST_API/users');
+var org = require('./REST_API/org');
+var attachments = require('./REST_API/attachments');
+var functions = require('./REST_API/functions');
+
+global.HTTP_METHODS
+
+global.HTTP_METHODS = {
+    GET : "GET",//No I18N
+    POST : "POST",//No I18N
+    PUT : "PUT",//No I18N
+    DELETE : "DELETE"//No I18N
+};
+
+var API = (function (argument) {
+	return {
+                
+                MODULES : new modules(),
+                SETTINGS : new settings(),
+                ACTIONS : new actions(),
+                USERS : new users(),
+                ORG : new org(),
+                ATTACHMENTS : new attachments(),
+                FUNCTIONS :new functions()
+			}
+		
+})(this)
+
+module.exports = API;

package/lib/js/mysql/mysql_util.js

@@ -0,0 +1,162 @@
+
+var mysql_util = {};
+var mysql = require('mysql');
+
+mysql_util.saveOAuthTokens = function(config_obj){
+
+return new Promise(function(resolve,reject){
+  
+    var con = getConnection();
+
+    var sql = "INSERT INTO oauthtokens (useridentifier, accesstoken,refreshtoken,expirytime) VALUES ('"+config_obj.user_identifier+"','"+config_obj.access_token+"','"+config_obj.refresh_token+"',"+config_obj.expires_in+")";
+
+    mysql_util.deleteOAuthTokens().then(function(){
+
+    con.connect(function(err){
+
+    if(err){
+        throw new Error(err);
+    }
+
+    con.query(sql,function(err,result){
+
+    if (err) {
+        throw new Error(err);
+        con.end();
+    }
+
+    con.end();
+
+    resolve();
+
+    })
+
+
+})
+    
+})
+    
+})
+}
+
+mysql_util.getOAuthTokens = function(){ 
+
+    return new Promise(function(resolve,reject){
+
+        var con = getConnection();
+
+        var crmclient = require('../ZCRMRestClient');
+        con.connect(function(err){
+
+            if(err) throw err;
+
+        var sql = "Select * from oauthtokens where useridentifier = '"+crmclient.getUserIdentifier()+"'";
+            
+        con.query(sql,function(err,result){
+
+            if(err) {
+                throw new Error(err);
+                con.end();
+            }
+
+            con.end();
+          
+            if(result != undefined && result.length != 0)
+            {
+                var modified_result ={};
+                modified_result["access_token"] = result[0].accesstoken;
+                modified_result["refresh_token"] = result[0].refreshtoken;
+                modified_result["expires_in"] = result[0].expirytime;
+                modified_result["user_identifier"] = result[0].useridentifier;
+                resolve(modified_result);
+            }
+            resolve(result);
+        });
+
+    });
+    })
+  
+}
+
+mysql_util.updateOAuthTokens = function(config_obj){
+
+    
+    return new Promise(function(resolve,reject){
+
+    var con = getConnection();
+    var crmclient = require('../ZCRMRestClient');
+    con.connect(function(err){
+
+        if(err) throw err;
+
+    var sql = `
+    update oauthtokens 
+    set accesstoken = '${config_obj.access_token}', 
+    expirytime=${config_obj.expires_in} 
+    where useridentifier = '${crmclient.getUserIdentifier()}'`;
+   
+    con.query(sql,function(err,result){
+        
+        if(err) {
+            throw new Error(err);
+            con.end();
+        }
+
+        con.end();
+
+        resolve(result);
+
+    })
+})  
+});
+}
+
+mysql_util.deleteOAuthTokens = function(){
+
+    return new Promise(function(resolve,reject){
+
+        var con = getConnection();
+
+        var crmclient = require('../ZCRMRestClient');
+
+        var sql = "delete from oauthtokens where useridentifier='"+crmclient.getUserIdentifier()+"'";
+
+        con.connect(function(err){
+
+            if(err) throw err;
+        
+        con.query(sql,function(err,result){
+
+            if(err) {
+                throw new Error(err);
+            }
+
+            con.end();
+            
+            resolve(result);
+        })
+
+
+    })
+})
+
+}
+
+
+function getConnection(){
+
+    var crmclient = require('../ZCRMRestClient');
+    var con = mysql.createConnection({
+
+            host: process.env.MYSQL_IP||"35.239.104.86",
+            user: crmclient.getMySQLUserName(),
+            password: crmclient.getMYSQLPassword(),
+            database: "zohooauth"
+
+        });
+
+        return con;
+
+}
+
+module.exports = mysql_util;

package/lib/js/util.js

@@ -0,0 +1,327 @@
+
+function promiseResponse(request) {
+
+    var crmclient = require('./ZCRMRestClient');
+    var OAuth = require('./OAuth');
+
+    return new Promise(function (resolve, reject) {
+        var persistenceModule = require(crmclient.getPersistenceModule());
+        getAuthToken().then(resp=>{
+            makeapicall(request).then(function (response) {
+
+                try {
+                    var isExpire = JSON.parse(response.body);
+                    if (isExpire.code == 'INVALID_TOKEN') {
+                        //Update Token 
+
+                        getAuthToken(true).then(resp=>{
+                            makeapicall(request).then(function (response) {
+        
+                                resolve(response);
+    
+                            })
+                        })
+                    }else{
+                        resolve(response);
+                    }
+                } catch (error) {
+                    resolve(response);
+                }
+
+            })
+        })
+       
+    })
+}
+
+
+function makeapicall(request) {
+
+    return new Promise(function (resolve, reject) {
+
+        var crmclient = require('./ZCRMRestClient');
+        var httpclient = require('request');
+        var OAuth = require('./OAuth');
+        var persistenceModule = require(crmclient.getPersistenceModule());
+        var qs = require('querystring');
+
+        persistenceModule.getOAuthTokens(crmclient.getUserIdentifier()).then(function (result_obj) {
+            var access_token = result_obj.access_token;
+            var allrecords = request.all || null
+            var baseUrl = "https://" + crmclient.getAPIURL() + "/crm/" + crmclient.getVersion(allrecords) + "/" + request.url;
+            if (request.params) {
+                baseUrl = baseUrl + '?' + request.params;
+            }
+
+            var api_headers = {};
+            var encoding = "utf8";
+            var req_body = null;
+            var formData = null;
+
+            if (request.download_file) {
+                encoding = "binary";//No I18N
+            }
+
+            var form_Data = null;
+
+            if (request.x_file_content) {
+                var FormData = require('form-data');
+                form_Data = new FormData();
+                form_Data.append('file', request.x_file_content);//No I18N           
+                req_body = form_Data;
+                api_headers = form_Data.getHeaders();
+            }
+            else {
+                req_body = request.body || null;
+            }
+
+            if (request.headers) {
+                var header_keys = Object.keys(request.headers);
+                for (i in header_keys) {
+                    api_headers[header_keys[i]] = request.headers[header_keys[i]];
+                }
+            }
+
+            api_headers.Authorization = 'Zoho-oauthtoken ' + access_token;
+            api_headers["User-Agent"] = 'Zoho CRM Node SDK';
+
+           /*  console.log({
+
+                uri: baseUrl,
+                method: request.type,
+                headers: api_headers,
+                body: req_body,
+                encoding: encoding
+
+            },crmclient.getVersion(allrecords)); */
+            httpclient({
+
+                uri: baseUrl,
+                method: request.type,
+                headers: api_headers,
+                body: req_body,
+                encoding: encoding
+
+            }, function (error, response, body) {
+
+                if (error) {
+                    resolve(error);
+                }
+                else if (response.statusCode == 204) {
+
+                    var respObj = {
+                        "message": "no data", //No I18N
+                        "status_code": "204" //No I18N
+                    }
+                    resolve(JSON.stringify(respObj));
+
+                } else {
+                    if (request.download_file) {
+
+                        var filename;
+                        var disposition = response.headers["content-disposition"];//No I18N
+                        if (disposition && disposition.indexOf('attachment') !== -1) {
+                            var filenameRegex = /filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/;
+                            var matches = filenameRegex.exec(disposition);
+                            if (matches != null && matches[1]) {
+                                filename = matches[1].replace(/['"]/g, '');
+                                filename = filename.replace('UTF-8', '');
+                            }
+                        }
+                        response.filename = filename;
+                        resolve(response);
+                    }
+                    else {
+                        resolve(response);
+                    }
+                }
+            });
+        })
+    })
+}
+function getAuthToken(isInvalid) {
+
+    var crmclient = require('./ZCRMRestClient');
+    var OAuth = require('./OAuth');
+
+    
+    return new Promise(function (resolve, reject) {
+
+        var persistenceModule = require(crmclient.getPersistenceModule());
+
+        persistenceModule.getOAuthTokens(crmclient.getUserIdentifier()).then(function (response) {
+
+            var date = new Date();
+            var current_time = date.getTime();
+            var access_token = response.access_token;
+            var expires_in = response.expires_in;
+            var refresh_token = response.refresh_token;
+            var result_obj = (response);
+
+            if ((current_time > expires_in) || isInvalid) {
+                if(isInvalid)console.info("==============  REGENERATE TOKEN BY INVALID =============");
+                if(!isInvalid)console.info("==============   REGENERATE TOKEN BY TIME  =============");
+
+                var config = crmclient.getConfig_refresh(refresh_token)
+                new OAuth(config, 'refresh_access_token');
+                var url = OAuth.constructurl('generate_token');
+                OAuth.generateTokens(url).then(function (response) {
+
+                    result_obj = crmclient.parseAndConstructObject(response);
+
+                    persistenceModule.updateOAuthTokens(result_obj).then(function (response) {
+                        resolve(result_obj);
+                    });
+                })
+            }
+            
+
+            else {
+                //console.info("==============  TOKEN NO EXPIRADO  =============")
+                resolve(result_obj);
+            }
+        })
+    })
+}
+
+function createParams(parameters) {
+
+    var params, key;
+    for (key in parameters) {
+        if (parameters.hasOwnProperty(key)) {
+            if (params) {
+                params = params + key + '=' + parameters[key] + '&';
+            }
+            else {
+                params = key + '=' + parameters[key] + '&';
+            }
+        }
+    }
+
+    return params;
+}
+
+function constructRequestDetails(input, url, type, isModuleParam) {
+
+    var requestDetails = {};
+
+    requestDetails.type = type;
+
+    if (input != undefined) {
+        if (input.id) {
+            url = url.replace("{id}", input.id);
+        }
+        else {
+            url = url.replace("/{id}", "");
+        }
+        if (input.api_name) {
+
+            url = url.replace("{api_name}", input.api_name);
+
+
+            var params = {};
+            if (input.params) {
+
+                params = input.params;
+            }
+            params.auth_type = "apikey";
+            input.params = params;
+        }
+        else {
+
+            url = url.replace("/{api_name}", "");
+
+        }
+        if (input.params) {
+            requestDetails.params = createParams(input.params) + (input.module && isModuleParam ? "module=" + input.module : "");//No I18N
+        }
+        if (!requestDetails.params && isModuleParam) {
+            requestDetails.params = "module=" + input.module;//No I18N
+        }
+        if (input.body && (type == HTTP_METHODS.POST || type == HTTP_METHODS.PUT)) {
+            requestDetails.body = JSON.stringify(input.body);
+        }
+        if (input.x_file_content) {
+            requestDetails.x_file_content = input.x_file_content;
+        }
+        if (input.download_file) {
+            requestDetails.download_file = input.download_file;
+        }
+        if (input.headers) {
+
+            requestDetails.headers = input.headers;
+        }
+    }
+
+    requestDetails.url = url;
+
+    return requestDetails;
+
+
+}
+function convertToCOQLQuery(inputText, fields, module,page,per_page) {
+    const conditions = inputText.split(/\b(and|or)\b/i);
+
+    const queryParts = [];
+    let operator = 'AND'; // Operador predeterminado
+    const operatorsWithGrouping = ['equals', 'starts_with', 'in', '>='];
+    let currentEqualsLikeGroup = [];
+    let currentBetweenGroup = [];
+
+    conditions.forEach(condition => {
+        const cleanCondition = condition.trim();
+        if (cleanCondition.match(/^(and|or)$/i)) {
+            operator = cleanCondition.toLowerCase();
+        } else {
+            const [field, op, value] = cleanCondition
+                .replace(/\(|\)/g, '')  // Eliminar paréntesis
+                .split(':');
+
+            if (op === 'between') {
+                const [start, end] = value.split(',');
+                currentBetweenGroup.push(`${field} between '${start}' and '${end}'`);
+            }
+            else if (op === 'in') {
+                const elements = value.split(',');
+                currentEqualsLikeGroup.push(`${field} in (${elements.map(el => `'${el.trim()}'`).join(', ')})`);
+            }
+            else if (op === 'is not null') {
+
+                currentBetweenGroup.push(`(${field} is not null)`);
+            }
+            else if (operatorsWithGrouping.includes(op)) {
+                currentEqualsLikeGroup.push(`(${field} ${op === 'equals' ? '=' : op} '${value}')`);
+            } else {
+                queryParts.push(currentEqualsLikeGroup.join(` ${operator} `));
+                currentEqualsLikeGroup = [];
+            }
+        }
+    });
+    if (currentEqualsLikeGroup.length > 0) {
+        queryParts.push(`(${currentEqualsLikeGroup.join(` ${operator} `)})`);
+    }
+    if (currentBetweenGroup.length > 0) {
+        queryParts.push(`(${currentBetweenGroup.join(` AND `)})`);
+    }
+
+    const finalQuery = `SELECT ${fields} FROM ${module} WHERE ${queryParts.join(` ${operator} `)} LIMIT ${[page*per_page,per_page]}`;
+   
+    return finalQuery;
+}
+function calculateLimit(pageNumber, resultsPerPage) {
+    if (pageNumber < 0) {
+      throw new Error('El número de página debe ser mayor o igual a 0.');
+    }
+    
+    const lowerLimit = pageNumber * resultsPerPage;
+    const upperLimit = (pageNumber + 1) * resultsPerPage;
+  
+    return [pageNumber, resultsPerPage];
+}
+module.exports = {
+
+    constructRequestDetails: constructRequestDetails,
+    promiseResponse: promiseResponse,
+    getAuthToken: getAuthToken,
+    convertToCOQLQuery: convertToCOQLQuery
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "zocrmsdkmiblu",
+  "version": "0.2.4",
+  "author": "IT Team",
+  "license": "MIT",
+  "dependencies": {
+    "fs": "0.0.1-security",
+    "mysql": "^2.18.1",
+    "properties-reader": "0.0.16",
+    "querystring": "^0.2.0",
+    "request": "^2.88.2",
+    "typescript": "^5.0.4"
+  },
+  "description": "Node SDK for Zoho CRM BY JB",
+  "keywords": [
+    "zoho crm",
+    "sdk zoho"
+  ],
+  "main": "lib/js/ZCRMRestClient",
+  "scripts": {
+    "test": "mocha --timeout 5000 test/dev.test.js"
+  },
+  "devDependencies": {
+    "@types/node": "^20.1.2",
+    "@types/request": "^2.48.8",
+    "mocha": "^10.2.0"
+  }
+}