linker-api 1.0.0

package/src/lib/database/prepared-stmt.ts

@@ -0,0 +1,65 @@
+export class PreparedStmt {    
+    constructor(private stmt:any, private query:string, private provider:any){        
+    }
+    async execute(input:any, types?:any){        
+        try{
+			let logQuery:any = this.query;
+            Object.keys(input).forEach((key:string)=>{
+                let dataType = this.findDataType(input[key]);
+				if(!['attributes'].includes(key) && this.query.indexOf(`@${key}`) > -1 && dataType != -1){
+                    if(dataType === -2){
+                        var paramsObj = input[key].reduce((obj, val, idx) => {
+                            obj[`id${idx}`] = val;
+                            input[`id${idx}`] = val;
+                            this.stmt.input(`id${idx}`, this.provider.VarChar(200));
+                            return obj;
+                        }, {});
+                        let inQuery = `${Object.keys(paramsObj).map((o) => {return `@${o}`}).join(',')}`;
+                        let sQuery:any = this.query;
+                        this.query = sQuery.replaceAll(`@${key}`, inQuery);
+                        //logQuery = this.query;
+                    }else
+					    this.stmt.input(key, dataType);
+                    new Promise((resolve, reject)=>{
+                        let regEx = new RegExp(`@${key}`, "g")
+						logQuery = logQuery.replaceAll(regEx, `'${input[key]}'`);
+					});
+				}
+            });
+			new Promise((resolve, reject)=>{
+				console.log(logQuery);
+			});
+            await this.stmt.prepare(this.query);
+            let resultset = await this.stmt.execute(input);
+            return resultset.recordset;
+        }catch(err){
+            console.log(err.toString());
+			if(err.originalError?.errors){
+				err.originalError?.errors.forEach((item:any)=>{
+					console.log(item.toString());
+					throw new Error(item);
+				});				
+			}
+            throw err;
+        }finally{
+            try{
+                await this.stmt.unprepare();
+            }catch(iErr){
+                //Do Nothing
+            }
+        }
+    }
+    findDataType(data:any){
+        let resultType = this.provider.VarChar;
+        if(data instanceof Number){
+            resultType = this.provider.Decimal
+        }else if(typeof data === 'number'){
+            resultType = this.provider.Decimal
+        }else if(data instanceof Array){
+            resultType = -2;
+		}else if(data != null && typeof data === 'object'){
+			resultType = -1;
+        }
+        return resultType;
+    }
+}

package/src/lib/database/schema/common-schema.ts

@@ -0,0 +1,77 @@
+export const CommonSchema = [
+    {
+        id: 'FIND_FIN_YR',
+        Query: `SELECT FinYear FIND_FIN_YR FROM Mst_AccYear WHERE OpenStatus='O' AND CurrentFinancialYear='Y'`
+    },
+    {
+        id: 'USP_GENERATE_DOCNO',        
+        Query: `DECLARE @RESULT VARCHAR(100);EXEC USP_GENERATECOUNT @DOCREFNO, @CLNGCODE, @RESULT OUTPUT SELECT @RESULT RESULT`
+    },
+    {
+        id: 'ADD_NOTIFY',
+        Query: `insert into TM_NOTIFICATIONS(CLNORGCODE, TRNUMBER, NOTIFICATION, READSTATUS, STATUS, CREATED_ON, MOBILE)  values(@clnorgcode, @trnumber, @message,'0','0', getdate(), @mobile)`
+    },
+    {
+        id: 'USP_GENERATE_DOCNO_RESULT',        
+        Query: `DECLARE @RESULT VARCHAR(100);EXEC USP_GENERATECOUNT @DOCREFNO, @CLNGCODE, @RESULT OUTPUT SELECT @RESULT RESULT`
+    },
+    {
+        id: 'sendSMSTransport',
+        url: `https://sms.zestwings.com/smpp.sms?`,
+    },
+    {
+        id: 'getStoredProcDetails',
+        Query: `SELECT SUBSTRING(p.name, 2, LEN(p.name)) AS ParameterName, t.name AS ParameterType, p.max_length AS ParameterLength, p.is_output 
+                FROM sys.parameters AS p
+                JOIN sys.types AS t ON t.user_type_id = p.user_type_id
+                WHERE object_id = OBJECT_ID(@table)`
+    },
+    {
+        id: 'getTableDetails',
+        Query: `select cl.COLUMN_NAME, cl.DATA_TYPE,
+                CASE
+                WHEN COLUMNPROPERTY(object_id(TABLE_SCHEMA+'.'+TABLE_NAME), cl.COLUMN_NAME, 'IsIdentity') = 1
+                    THEN 1
+                ELSE 0
+                END AS IS_IDENTITY_KEY,
+                ISNULL(cu.IS_PRIMARY_KEY, 0) IS_PRIMARY_KEY
+                from INFORMATION_SCHEMA.COLUMNS cl
+                left join (select C.COLUMN_NAME, 1 as IS_PRIMARY_KEY FROM
+                      INFORMATION_SCHEMA.TABLE_CONSTRAINTS T
+                      JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE C
+                      ON C.CONSTRAINT_NAME=T.CONSTRAINT_NAME
+                      WHERE
+                      C.TABLE_NAME=@table
+                      and T.CONSTRAINT_TYPE='PRIMARY KEY') cu on cu.COLUMN_NAME = cl.COLUMN_NAME
+                where TABLE_NAME = @table`,
+        //postProcessor: CommonService.addPrimaryKeys.bind(CommonService)        
+    },
+    /*{
+        id: 'getTableData',
+        executor: CommonService.getTableData.bind(CommonService)
+    }*/,
+    /*{
+    id: 'insertTableData',
+    executor: CommonService.insertTableData.bind(CommonService)
+    }*/,
+    /*{
+    id: 'updateTableData',
+    executor: CommonService.updateTableData.bind(CommonService)
+    },
+    {
+    id: 'deleteTableData',
+    executor: CommonService.deleteTableData.bind(CommonService)
+    }*/,
+    {
+        id: 'status-filter',
+        filter: `STATUS='A'`
+    },
+    {
+        id: 'rec-status-filter',
+        filter: `REC_STATUS='A'`
+    },
+    {
+        id: 'hims-filter',
+        filter: `CLNORGCODE = @Hospital_Id and STATUS='A'`
+    }
+]

package/src/lib/database/schema/common-service.ts

@@ -0,0 +1,204 @@
+import { CommonSchema } from "./common-schema";
+
+import { Schema, PostProcessor, Executor } from "tharak-api";
+import { TableCatelog } from "./table-catelog";
+@Schema({
+        id: 'common',
+        table: CommonSchema 
+    })
+export class CommonService {
+   static async fileStore(input, results){
+
+    }
+    static async transVisits(input, results){
+        results.filter((item:any)=>{
+          item.masterData = ['Assigned', 'UnAssigned'];
+          if(item.ASSIGNED_STATUS === 'Assigned'){
+            item.masterData.push('Start');
+          }
+        })
+        return results;
+    }
+    static async exStoredProcData(input, table, trans, provider){
+        
+    }
+    static async getQueryData(input, table, trans, provider){
+        let tableQuery = {Query: input.Query}
+        return await provider.executeQuery(input, tableQuery, trans);
+    }
+    private countWords(str) {
+        return str.trim().split(/\s+/).length;
+    }
+    private createFilter(input){
+        let filter=''
+        Object.keys(input).forEach((key, index)=>{
+            if(!['attributes', 'table', 'NOFILTER', 'fetchId'].includes(key)){
+                if(index > 0){
+                    filter += ` and `    
+                }
+                filter += `${key}=@${key}`
+            }
+        })
+        if(filter)
+        return {filter: filter};
+    }
+    @Executor('getTableData')
+    async getTableData(input, table, trans, provider){
+        let context = input.attributes['context'];
+        let tableQuery;
+        if(input.fetchId){
+            tableQuery = table.find((item:any)=>item.id === input.fetchId);
+        }
+        if(!tableQuery && this.countWords(input.table) === 1){
+            let selects = input.selects || '*';
+            let basicQuery = `select TOP (1000) ${selects.toString()} from ${input.table} `;
+            let filter = table.find((item:any)=>item?.id === input.filterId);
+            if(!filter)
+                filter = table.find((item:any)=>item?.id === 'status-filter' && !input.NOFILTER);
+            if(!filter){
+                filter = this.createFilter(input);
+            }
+            if(filter)
+                basicQuery += ` where ${filter.filter}`;
+            let tTable = table.find((item:any)=>item?.id === 'getTableData');
+            if(tTable){
+                tableQuery = tTable;
+                tableQuery.Query = basicQuery;
+            }else
+                tableQuery = {Query: basicQuery}
+        }
+        for(let ctxtKey in context){
+            if(!input[ctxtKey])
+                input[ctxtKey] = context[ctxtKey];
+        }
+        if(tableQuery){
+            //delete input.attributes;
+            return await provider.executeQuery(input, tableQuery, trans);
+        }else{
+            throw new Error('No Query Found');
+        }
+    }
+    @Executor('insertTableData')
+    async insertTableData(input, table, trans, provider){
+        let tableName = input.table;        
+        let index = 0;
+        let tokens = '';
+        let elems = ''
+        let attributes = input.attributes;
+        delete input['attributes'];
+        delete input['table'];
+        delete input['files'];
+        for(let item in input){
+            if(['attributes','table', 'files', ''].includes(item))
+                continue;
+            if(!input[item] && attributes && attributes['context']){
+                input[item] = attributes['context'][item];
+            }
+            if(!input[item])
+                continue;
+            if(index !== 0){
+                tokens += ',';
+                elems += ',';
+            }
+            tokens += `@${item}`;
+            elems += `${item}`;            
+            index++;
+            
+        }
+        if(this.countWords(tableName) === 1){
+            let basicQuery = `insert into ${tableName} (${elems}) values (${tokens})`;        
+            let tableQuery = {Query: basicQuery}
+            return await provider.executeQuery(input, tableQuery, trans);
+        }
+    }
+    @Executor('updateTableData')
+    async updateTableData(input, table, trans, provider){
+        let tableName = input.table;        
+        let index = 0;
+        let tokens = '';   
+        delete input['attributes'];
+        delete input['table'];
+        delete input['files'];
+        //delete input['filter'];
+        if(this.countWords(tableName) === 1){     
+            for(let item in input){
+                if(['attributes','table', 'files', 'filter', 'FILTER_CLOUMNS'].includes(item))
+                    continue;
+                /*if(input.FILTER_CLOUMNS.includes(item)){
+                    continue;
+                }*/
+                if(index !== 0){
+                    tokens += ',';                
+                }
+                tokens += `${item}=@${item}`;
+                index++;
+            }
+            let filter = '';
+            let basicQuery = `update ${tableName} set ${tokens}`;
+            if(input.filterId){
+                filter = table.find((item:any)=>item.id === input.filterId);
+            }else{
+                filter = this.findFilter(tableName, input);
+            }
+            basicQuery += ` where ${filter}`;        
+            let tableQuery = {Query: basicQuery}
+            return await provider.executeQuery(input, tableQuery, trans);
+        }
+    }
+    @Executor('deleteTableData')
+    async deleteTableData(input, table, trans, provider){
+        for(let ctxtKey in input.attributes['context']){
+            input[ctxtKey] = input.attributes['context'][ctxtKey];
+        }
+        let tableName = input.table;
+        if(this.countWords(input.table) === 1){
+            let basicQuery = `delete from ${tableName}`;
+            let filter = this.findFilter(tableName, input);
+            if(filter){
+                basicQuery += ` where ${filter}`;
+            }       
+            let tableQuery = {Query: basicQuery}
+            return await provider.executeQuery(input, tableQuery, trans);
+        }
+    }
+    findFilter(tableName:string, input:any){
+        let filter = ''
+        if(input.filterId){
+            
+        }
+        let pKeys:any = this.findPrimaryKeys(tableName);
+        pKeys.forEach((col, index)=>{
+            if(index > 0){
+                filter += ` and `    
+            }
+            filter += `${col.COLUMN_NAME}=@${col.COLUMN_NAME}`
+        })
+        return filter;
+    }
+    findPrimaryKeys(tableName){
+        let table:any = TableCatelog.find((table:any)=>table.id === tableName);
+        if(table && table.primaryKeys?.length > 0){
+            return table.primaryKeys;
+        }
+        return [];
+    }
+    @PostProcessor('getTableData')
+    async addPrimaryKeys(input, results){
+        let table:any = TableCatelog.find((table:any)=>table.id === input.table);
+        if(table && table.primaryKeys?.length > 0){
+            for(let primaryKey of table.primaryKeys){
+                let found = results.find((col:any)=>col.COLUMN_NAME === primaryKey.COLUMN_NAME);
+                if(found){
+                    found.IS_PRIMARY_KEY = 1;
+                }
+            }
+        }
+        return results;
+    }
+    @PostProcessor('getTableData')
+    async postGetData(input, results){  
+        console.log('Hi')      
+        //tableQuery = table.find((item:any)=>item.id === input.fetchId);   
+        return results;     
+    }
+}

package/src/lib/database/schema/table-catelog.ts

@@ -0,0 +1,70 @@
+export const TableCatelog  = [
+    {
+        id: 'MST_SERVGROUPS',
+        primaryKeys: [
+          {COLUMN_NAME: 'SRVGRPCODE'}
+        ],
+    },
+    {
+        id: 'MST_SERVSUBGRP',
+        primaryKeys: [
+          {COLUMN_NAME: 'SUBGRPCODE'}
+        ],
+    },
+    {
+        id: 'Mst_ChargeSheet',
+        primaryKeys: [
+          {COLUMN_NAME: 'TARIFFID'},
+          {COLUMN_NAME: 'CONS_TYPE'},
+          {COLUMN_NAME: 'Doctor_ID'}
+        ],
+    },
+    {
+        id: 'HospitalsList',
+        primaryKeys: [
+          {COLUMN_NAME: 'Hospital_Id'},
+        ],
+    },
+    {
+        id: 'MST_REFERRAL',
+        primaryKeys: [
+          {COLUMN_NAME: 'REFERRAL_ID'},
+        ],
+    },
+    {
+        id: 'SECURITY_USERS',
+        primaryKeys: [
+          {COLUMN_NAME: 'USERID'},
+        ],
+    },
+    {
+        id: 'WL_EMP_MAST',
+        primaryKeys: [
+          {COLUMN_NAME: 'MOBILE'},
+        ],
+    },
+    {
+        id: 'TM_PATIENTPREFERENCES',
+        primaryKeys: [
+          {COLUMN_NAME: 'USERID'},
+        ],
+    },
+    {
+        id: 'MST_REFERRALSOURCE',
+        primaryKeys: [
+          {COLUMN_NAME: 'SOURCE_ID'},
+        ],
+    },
+    {
+        id: 'Mst_DoctorMaster',
+        primaryKeys: [
+          {COLUMN_NAME: 'Code'},
+        ],
+    },
+    {
+        id: 'Speciality_Master',
+        primaryKeys: [
+          {COLUMN_NAME: 'Speciality_ID'},
+        ],
+    },
+];

package/src/lib/database/transaction.ts

@@ -0,0 +1,12 @@
+export class Transaction {
+    constructor(private transact:any){        
+    }
+    commit(){
+        if(!this.transact._aborted)
+            return this.transact.commit();
+    }
+    rollback(){
+        if(!this.transact._aborted)
+            return this.transact.rollback();
+    }
+}

package/src/lib/dispatcher/health-service.ts

@@ -0,0 +1,83 @@
+import { Api, GET, POST, UnSecured } from "tharak-api";
+import { IDispatcher } from "./i-dispatcher";
+import { Database } from "../database/database";
+
+@Api('/')
+export class HealthService extends IDispatcher{   
+    @POST('/:service/:operation')        
+    async postData(request, response){
+        let resultset: any;
+        let params = request.params;
+        let input: any = request.body;
+        let files:any = request?.files;
+        if(files && !Array.isArray(files)){
+            input.files = [files.file];
+        }else{
+            input.files = files;
+        }
+        input.attributes = request.attributes;
+        input.method = request.method;
+        let trans:any = await Database.findTransaction();
+        try{
+            resultset = await this.execute(params, input, trans);
+            response.send(resultset);
+            trans.commit();
+        }catch(err){
+            trans.rollback();
+            response.status(500).send({ status: 1, message: err.message });    
+        }
+    }
+    @GET('/i18n/:operation')
+    @UnSecured()
+    async loadi18nData(request, response){
+        request.params.service = 'i18n';
+        await this.getQueryData(request, response);
+    }
+    @GET('/customer/:operation')
+    @UnSecured()
+    async loadCustData(request, response){
+        request.params.service = 'customer';
+        await this.getQueryData(request, response);
+    }
+    @GET('/master/getCountryCodes')
+    @UnSecured()
+    async findUnsecureCountry(request, response){
+        request.params = {
+            operation: "getCountryCodes",
+            service: "master"
+        }
+        await this.getQueryData(request, response);
+    }
+    @GET('/registration/checkPatientByMobile')
+    @UnSecured()
+    async checkPatientByMobile(request, response){
+        request.params = {
+            operation: "checkPatientByMobile",
+            service: "registration"
+        }
+        await this.getQueryData(request, response);
+    }
+    @GET('/registration/genOTPByMobile')
+    @UnSecured()
+    async genOTPByMobile(request, response){
+        request.params = {
+            operation: "genOTPByMobile",
+            service: "registration"
+        }
+        await this.getQueryData(request, response);
+    }
+    @GET('/:service/:operation')        
+    async getQueryData(request, response){
+        let params = request.params;
+        let input: any = request.query;
+        let resultset: any;
+        input.attributes = request.attributes;
+        try{
+            resultset = await this.execute(params, input, undefined);
+            response.send(resultset);
+        }catch(err){
+            console.log(err.toString())
+            response.status(500).send({ status: 1, message: err.message }); 
+        }
+    }
+}

package/src/lib/dispatcher/i-dispatcher.ts

@@ -0,0 +1,165 @@
+
+import { Database } from "../database/database";
+
+export abstract class IDispatcher {          
+    getSchemaConfig(){
+        return null;
+    };
+    async findSchema(params:any){
+        let schema:any = this.getSchemaConfig().find((item:any)=>item.id === params.service);
+        if(!schema){
+            throw new Error('Schema not found.');
+        }
+        schema.table = schema.table || [];
+        if(!schema.isLoaded){
+            let common:any = this.getSchemaConfig().find((item:any)=>item.id === 'common');
+            schema.table = schema.table.concat(common.table);
+            schema.isLoaded = true;
+        }
+        return schema;
+    }
+    async findTable(params:any, schema:any){        
+        let table = schema.table.find((item:any)=>item?.id === params.operation);
+        
+        return table;
+    }
+    async execute(params, input, trans){
+        let result;
+        let resultset: any = [];
+        let schema = await this.findSchema(params);
+        let table = await this.findTable(params, schema);
+        
+        if(table?.executor){            
+            resultset = await table.executor(input, schema.table, trans, this);
+            result = { status: 0, results: resultset };
+        }else if(table?.executorSet){
+            resultset = await this.executeSet(input, table, trans);
+            result = { status: 0, results: resultset };
+        }else if(table?.url){
+            resultset = await this.executeUrl(input, table, trans);
+            result = { status: 0, results: resultset };
+        }else if(table?.Query){
+            resultset = await this.executeQuery(input, table, trans);
+            result = { status: 0, results: resultset };
+        }else if(table?.results){
+            resultset = table?.results;
+            result = { status: 0, results: resultset };
+        }else if(table?.data){
+            result = table.data
+        }else{
+            throw new Error('Query not found.');
+        }
+        return result;
+    }
+    async executeSet(input:any, table:any, trans:any){
+            for(let executorId of table.executorSet){
+                let executor = table.find(
+                    (item: any) => item.id === executorId
+                  );
+                  let uspGenDocNo = await this.executeQuery(
+                    input,
+                    executor,
+                    trans
+                  );
+                  input.appNo = uspGenDocNo[0]["RESULT"];
+            }
+        }
+        async executeUrl(input:any, table:any, trans:any){
+            let result;
+            input.headers = {
+                'Content-type': 'application/json; charset=UTF-8'
+            };
+            if(table.preProcessor){
+                await table.preProcessor(input, []);
+            }
+            if(input.method === 'POST'){
+                let req:any = {
+                    method: 'POST',                
+                    headers: input.headers
+                };
+                if(input.headers){
+                    delete input.headers;
+                }
+                if(input.files){
+                    delete input.files;
+                }
+                delete input.attributes;
+                req.body = JSON.stringify(input);
+                result = await fetch(table?.url, req)            
+            }else{
+                let req = {                
+                    headers: input.headers
+                };
+                let params = this.convert2Url(input);
+                result = await fetch(`${table?.url}${params}`, req)           
+        }
+            let posts = await result.json();
+            if(table.postProcessor){
+                posts = await table.postProcessor(input, posts);
+            }
+            return posts;
+        }
+    
+        async executeProcedure(input:any, output:any, table:any, trans:any){        
+            let stmt = await Database.preparedCall(table.Query, trans);
+            return stmt.execute(input, output);
+        }
+        async executeQuery(input:any, table:any, trans?:any){            
+            let resultset: any = [];
+            try{
+                let stmt;
+                if(trans)
+                    stmt = await Database.preparedStatement(table.Query, trans);
+                else
+                    stmt = await Database.preparedStatement(table.Query);
+                this.parseParams(input, table);
+                if(table.preProcessors){
+                    for(let processor of table.preProcessors){
+                        resultset = await processor(input, resultset);
+                    }
+                }        
+                resultset = await stmt.execute(input);
+                if(table.postProcessors){
+                    for(let processor of table.postProcessors){
+                        let pResult = await processor(input, resultset);
+                        if(pResult){
+                            resultset = pResult;
+                        }
+                    }
+                }
+            }catch(err){
+                console.log(err.toString());
+                throw new Error(err.message);
+            }
+            return resultset;
+        }
+    parseParams(input:any, table:any){
+        if(table.params && table.params.length > 0){
+            table.params.forEach((param:any)=>{
+                if(param.opr.toLowerCase() === 'in'){
+                    input[param.name] = input[param.name].split(",")//JSON.parse(input[param.name]);
+                }
+                if(param.opr === 'like'){
+                    input[param.name] = `%${input[param.name]}%`;
+                }
+                if(param.opr === 'decode'){
+                    input[param.name] = `${btoa(input[param.name])}`;
+                }
+                if(param.opr === 'default'){
+                    input[param.name] = `${input[param.name] || param.value}`;
+                }
+            })
+        }
+    }
+    convert2Url(input){
+        let elements = '';
+        let idx=0;
+        for(let [key, value] of Object.entries(input)){
+            if(idx > 0)
+            elements += '&';
+            elements += key+'='+value;
+            idx++;
+        }
+        return elements;
+    }
+}