@agung_dhewe/webapps 1.1.2

package/src/apis/generator.api.js

@@ -0,0 +1,226 @@
+import pgp from 'pg-promise'
+
+import * as path from 'path'
+import db from '../db.js'
+import Api from '../api.js'
+import * as helper from '../helper.js'
+import { runDetachedWorker } from '../workermanager.js'
+import context from '../context.js'
+import sqlUtil from '@agung_dhewe/pgsqlc'
+
+
+import jwt from 'jsonwebtoken';
+
+const MINUTES = 60 * 1000
+
+const moduleName = 'generator'
+const generateTimeoutMs = 5 * MINUTES 
+
+// api: account
+export default class extends Api {
+	constructor(req, res, next) {
+		super(req, res, next);
+		Api.cekLogin(req)
+
+	}
+
+	// dipanggil dengan model snake syntax
+	// contoh: header-list
+	//         header-open-data
+	async init(body) { return await generator_init(this, body) }
+	async list(body) { return await generator_list(this, body) }
+	async open(body) { return await generator_open(this, body) }
+	async save(body) { return await generator_save(this, body) }
+	async generate(body) { return await generator_generate(this, body) }
+
+}
+
+
+async function generator_init(self, body) {
+	const req = self.req
+
+	// set sid untuk session ini, diperlukan ini agar session aktif
+	req.session.sid = req.sessionID
+
+
+	try {
+		// ambil data app dari database
+		const sql = 'select apps_id, apps_url, apps_name, apps_directory from core."apps"'
+		const result = await db.any(sql)
+
+		const appsUrls = {}
+		for (let row of result) {
+			appsUrls[row.apps_id] = {
+				url: row.apps_url,
+				directory: row.apps_directory,
+				name: row.apps_name
+			}
+		}
+
+		return {
+			userId: req.session.user.userId,
+			userName: req.session.user.userName,
+			userFullname: req.session.userFullname,
+			sid: req.session.sid ,
+			notifierId: Api.generateNotifierId(moduleName, req.sessionID),
+			notifierSocket: req.app.locals.appConfig.notifierSocket,
+			targetDirectory: context.getRootDirectory(),
+			appsUrls: appsUrls
+		}
+
+	} catch (err) {
+		throw err
+	}
+
+
+}
+
+
+async function generator_list(self, body) {
+	const { criteria={}, limit=0, offset=0, columns=[], sort={} } = body
+	const searchMap = {
+		searchtext: `generator_modulename ILIKE '%' || \${searchtext} || '%' OR generator_id=try_cast_bigint(\${searchtext}, 0)`,
+		appname: `generator_appname=\${appname}`
+	};
+
+	try {
+	
+		// hilangkan criteria '' atau null
+		for (var cname in criteria) {
+			if (criteria[cname]==='' || criteria[cname]===null) {
+				delete criteria[cname]
+			}
+		}
+
+		// const orderby =  {
+		// 	_modifydate: 'desc',
+		// 	...sort
+		// }
+
+		sort._modifydate = 'desc'
+
+		var max_rows = limit==0 ? 50 : limit
+		const tablename = 'core."generator"'
+		const {whereClause, queryParams} = sqlUtil.createWhereClause(criteria, searchMap) 
+		const sql = sqlUtil.createSqlSelect({tablename, columns, whereClause, sort, limit:max_rows+1, offset, queryParams})
+		const rows = await db.any(sql, queryParams);
+
+		
+		var i = 0
+		const data = []
+		for (var row of rows) {
+			i++
+			if (i>max_rows) { break }
+			data.push(row)
+		}
+
+		var nextoffset = null
+		if (rows.length>max_rows) {
+			nextoffset = offset+max_rows
+		}
+
+		return {
+			criteria: criteria,
+			limit:  max_rows,
+			nextoffset: nextoffset,
+			data: data
+		}
+
+	} catch (err) {
+		throw err
+	}
+}
+
+async function generator_open(self, body) {
+	try {
+		const { id } = body 
+		const queryParams = {generator_id: id}
+		const sql = 'select * from core."generator" where generator_id = \${generator_id}'
+		const data = await db.one(sql, queryParams);
+
+		if (data==null) { throw new Error("data tidak ditemukan") }	
+
+		return data
+	} catch (err) {
+		throw err
+	}
+}
+
+async function generator_save(self, body) {
+	const { data } = body
+	const tablename = 'core."generator"'
+	const req = self.req
+	const user_id = req.session.user.userId
+
+
+	try {
+		sqlUtil.connect(db)
+
+
+
+		const id = `${data.id}`
+
+		delete data.id
+		const obj = {
+			generator_appname: data.appname,
+			generator_modulename: data.name,
+			generator_data: JSON.stringify(data),
+		}
+
+		let cmd
+		if (id=='') {
+			obj._createby = user_id
+			obj._createdate = (new Date()).toISOString()
+			cmd = sqlUtil.createInsertCommand(tablename, obj, ['generator_id'])
+		} else {
+			obj.generator_id = id
+			obj._modifyby = user_id
+			obj._modifydate = (new Date()).toISOString()
+			cmd = sqlUtil.createUpdateCommand(tablename, obj, ['generator_id'])
+		}
+		const result = await cmd.execute(obj)
+
+		return result
+	} catch (err) {
+		throw err
+	}
+}
+
+
+async function generator_generate(self, body) {
+	const req = self.req
+	const { data, clientId } = body
+	const id = `${data.id}`
+	const user_id = req.session.user.userId
+	const user_name = req.session.user.userFullname
+	const ipaddress = req.ip
+
+	try {
+		if (id=='') {
+			throw new Error('save data dahulu sebelum generate')
+		}
+
+		// sebelumnya save dahulu
+		const result = await generator_save(self, body)
+		const generator_id = result.generator_id
+
+		// generate di detached thread
+		const generatorWorker = path.join(context.getWebappsDirectory(), 'src', 'generator', 'worker.js')
+		const notifierServer = req.app.locals.appConfig.notifierServer
+		runDetachedWorker(generatorWorker, notifierServer, clientId, {
+			generator_id: generator_id,
+			user_id: user_id,
+			user_name: user_name,
+			ipaddress: ipaddress,
+			timeout: generateTimeoutMs,
+			jeda: 0.5, // jeda 1 detik per masing-masing generate
+		})
+
+
+		return {
+			generator_id: generator_id
+		}
+	} catch (err) {
+		throw err
+	}
+}

package/src/apis/login.api.js

@@ -0,0 +1,109 @@
+import pgp from 'pg-promise';
+
+import sqlUtil from '@agung_dhewe/pgsqlc'
+import context from '../context.js'
+import db from '../db.js'
+import Api from '../api.js'
+import bcrypt from 'bcrypt';
+
+
+
+export default class extends Api {
+	constructor(req, res, next) {
+		super(req, res, next);
+
+		this.currentState = {}
+		try {
+			Api.cekLogin(req)
+			this.currentState.isLogin = true
+		} catch (err) {
+			// tidak perlu throw error, karna hanya untuk cek sudah login apa belum
+			this.currentState.isLogin = false
+		}
+
+	}
+
+	// dipanggil dengan model snake syntax
+	// contoh: header-list
+	//         header-open-data
+	async init(body) { return await login_init(this, body) }	
+	async doLogin(body) { return await login_doLogin(this, body) }	
+	async doLogout(body) { return await login_doLogout(this, body) }
+}
+
+
+async function login_init(self, body) {
+	const req = self.req
+	if (self.currentState.isLogin) {
+		req.session.sid = req.sessionID
+	}
+
+	return {
+		isLogin: self.currentState.isLogin
+	}
+}
+
+async function login_doLogin(self, body) {
+	try {
+		const {username, password} = body
+		
+		const sql = 'select * from core.user where user_name = ${username}'
+		const param = { username }
+		const row = await db.oneOrNone(sql, param)
+
+		if (row==null) {
+			return null
+		}
+
+
+		const userId = row.user_id
+		const userName = row.user_name
+		const userFullname = row.user_fullname
+		const hashedPassword = row.user_password
+		const developerAccess = row.user_isdev
+
+		const match = await bcrypt.compare(password, hashedPassword);
+		if (!match) {
+			return null
+		} 
+
+
+		// simpan di session
+		self.req.session.user = {
+			userId,
+			userName,
+			userFullname,
+			developerAccess,
+			isLogin: true
+		}
+
+		return self.req.session.user
+
+		// // dummy login dulu
+		// if (username=='agung') {
+		// 	// setup session
+		// 	const user_id = '2590000000000000001'
+		// 	self.req.session.user = {
+		// 		userId: user_id,
+		// 		userName: 'agung',
+		// 		userFullname: 'Agung Nugroho',
+		// 		isLogin: true
+		// 	}
+
+		// 	return self.req.session.user
+		// } else {
+		// 	return null
+		// }
+	} catch (err) {
+		throw err
+	}
+}
+
+async function login_doLogout(self, body) {
+	try {
+		self.req.session.user = null
+		return true
+	} catch (err) {
+		throw err
+	}
+}

package/src/bucket.js

@@ -0,0 +1,24 @@
+import dotenv from 'dotenv';
+import { Client } from 'minio';
+
+dotenv.config();
+
+
+const bucketHost = process.env.BUCKET_HOST
+const bucketPort = process.env.BUCKET_PORT
+const bucketSecure = process.env.BUCKET_SECURE === 'true'
+const bucketUsername = process.env.BUCKET_USERNAME
+const bucketSecret = process.env.BUCKET_SECRET
+
+
+const minioClient = new Client({
+	endPoint: bucketHost,
+	port: bucketPort,
+	useSSL: bucketSecure,
+	accessKey: bucketUsername,
+	secretKey: bucketSecret,
+});
+
+
+export default minioClient
+

package/src/context.js

@@ -0,0 +1,26 @@
+let __dir
+let __rootDirectory
+
+
+
+let fnParseModuleRequest
+
+export default {
+	setWebappsDirectory: (dirname)=>{ __dir=dirname },
+	getWebappsDirectory: () => { return __dir },
+
+	setRootDirectory: (rootdir) => { __rootDirectory=rootdir },
+	getRootDirectory: () => { return __rootDirectory },
+
+
+	setFnParseModuleRequest: (fn) => {
+		fnParseModuleRequest = fn
+	},
+	getFnParseModuleRequest: (fn) => {
+		return fnParseModuleRequest
+	}
+}
+
+
+
+

package/src/datalog.sql

@@ -0,0 +1,22 @@
+create table datalog (
+    log_time timestamptz not null,
+    log_user_id text,
+	log_user_name text,
+    log_action text,
+    log_ipaddress text,
+	log_module text,
+	log_table text,
+	log_id text,
+	log_remark text,
+	log_executiontime int,
+    log_metadata JSONB
+);
+
+CREATE INDEX idx_datalog_module_table_id
+ON datalog (log_module, log_table, log_id);
+
+
+-- buat jadi hyper table
+SELECT create_hypertable('datalog', 'log_time');
+
+

package/src/db.js

@@ -0,0 +1,61 @@
+import dotenv from 'dotenv';
+import pgp from 'pg-promise';
+
+dotenv.config();
+
+const initOptions = {
+    // Misalnya, event untuk memantau query atau error
+    // query: (e) => {
+    //     console.log('QUERY:', e.query);
+    // },
+    // error: (err, e) => {
+    //     console.log('ERROR:', err, e.query);
+    // }
+};
+
+const pgpInstance = pgp(initOptions); // <-- Panggil pgp() hanya satu kali di sini
+
+
+const configDb = {
+    port: process.env.DB_PORT,
+    host:  process.env.DB_HOST,
+    database: process.env.DB_NAME,
+    user: process.env.DB_USER,
+    password: process.env.DB_PASS,
+}
+
+const configDbLog = {
+    port: process.env.LOGGER_DB_PORT,
+    host:  process.env.LOGGER_DB_HOST,
+    database: process.env.LOGGER_DB_NAME,
+    user: process.env.LOGGER_DB_USER,
+    password: process.env.LOGGER_DB_PASS,
+}
+
+
+const db = pgpInstance(configDb);
+export default db
+
+export const dblog = pgpInstance(configDbLog);
+
+
+
+db.connect()
+	.then(obj => {
+		console.log('Connected to Primary Database!');
+		obj.done(); // Klien dikembalikan ke pool
+	})
+	.catch(error => {
+		console.error("\n\x1b[31mError!\x1b[0m\ncannot connect to Database:", error.message || error, "\n");
+		process.exit(1);
+	});
+
+dblog.connect()
+	.then(obj => {
+		console.log('Connected to Logger Database!');
+		obj.done(); // Klien dikembalikan ke pool
+	})
+	.catch(error => {
+		console.error('\n\x1b[31mError!\x1b[0m cannot\nconnect to Logger Database:', error.message || error, "\n");
+		process.exit(1);
+	});

package/src/generator/createApiExtenderModule.js

@@ -0,0 +1,54 @@
+import { kebabToCamel, isFileExist, getSectionData } from './helper.js'
+import { fileURLToPath } from 'url';
+import path from 'path'
+import fs from 'fs/promises'
+import ejs from 'ejs'
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function createApiExtenderModule(context, options) {
+	const overwrite = options.overwrite===true
+	const moduleName = context.moduleName
+	const title = context.title
+	const targetFile = path.join(context.apiExtenderDir, `${moduleName}.apiext.js`)
+
+	try {
+		// cek dulu apakah file ada
+		var fileExists = await isFileExist(targetFile)
+		if (fileExists && !overwrite) {
+			context.postMessage({message: `skip file: '${targetFile}`})
+			return
+		}
+
+		// reporting progress to parent process
+		context.postMessage({message: `generating file: '${targetFile}`})
+
+
+		// start geneate program code
+		let sections = []
+		for (var entityName in context.entities) {
+			// console.log(context.entities[entityName])
+			sections.push(getSectionData(moduleName, entityName, context.entities[entityName], 'list'))
+			sections.push(getSectionData(moduleName, entityName, context.entities[entityName], 'edit'))
+		}
+
+		const variables = {
+			timeGenerated: context.timeGenerated,
+			title: title,
+			moduleName: moduleName,
+			sections: sections
+		}
+		
+		
+		const tplFilePath = path.join(__dirname, 'templates', 'api-extender-module.js.ejs')
+		const template = await fs.readFile(tplFilePath, 'utf-8');
+		const content = ejs.render(template, variables)
+				
+		
+		await fs.writeFile(targetFile, content, 'utf8');
+	} catch (err) {
+		throw err
+	}
+
+}