will-core
Version:
core module
539 lines (538 loc) • 24.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ActivateHandler = void 0;
const uuid_1 = require("uuid");
const will_db_1 = require("will-db");
const will_sql_1 = require("will-sql");
const will_api_1 = require("will-api");
const will_util_1 = require("will-util");
const VerifyError_1 = require("../models/VerifyError");
const SchemeHandler_1 = require("./SchemeHandler");
const EnvironmentVariable_1 = require("../utils/EnvironmentVariable");
class ActivateHandler extends SchemeHandler_1.SchemeHandler {
constructor() {
super(...arguments);
this.model = {
name: "tactivate",
alias: { privateAlias: this.section },
fields: {
activatekey: { type: "STRING", key: true },
activateuser: { type: "STRING", created: true },
transtime: { type: "BIGINT", created: true },
senddate: { type: "DATE", created: true },
sendtime: { type: "TIME", created: true },
expiredate: { type: "DATE" },
activatedate: { type: "DATE" },
activatetime: { type: "TIME" },
activatestatus: { type: "STRING" },
activatecount: { type: "INTEGER" },
activatetimes: { type: "INTEGER" },
activatecategory: { type: "STRING" },
activatelink: { type: "STRING" },
activatepage: { type: "STRING" },
activateremark: { type: "STRING" },
activateparameter: { type: "STRING" },
activatemessage: { type: "STRING" },
activatecontents: { type: "STRING" },
},
};
this.activateCategory = "ACTIVATE";
this.handlers = [{ name: "invalidate" }, { name: "activate" }, { name: "inactivate" }, { name: "removal" }];
}
async invalidate(context) {
return this.callFunctional(context, { operate: "invalidate", raw: false }, this.doInvalidate);
}
async activate(context) {
return this.callFunctional(context, { operate: "activate", raw: false }, this.doActivate);
}
async inactivate(context) {
return this.callFunctional(context, { operate: "inactivate", raw: false }, this.doInactivate);
}
async removal(context) {
return this.callFunctional(context, { operate: "removal", raw: false }, this.doRemoval);
}
createActivateKey() {
return (0, uuid_1.v4)();
}
createActivateInfo(data, invalidatetimes = EnvironmentVariable_1.DEFAULT_INVALIDATE_TIMES) {
let keyid = this.createActivateKey();
let transtime = data?.transtime || will_util_1.Utilities.now().getTime();
this.activateInfo = {
activatekey: data?.activatekey || keyid,
activateuser: data?.activateuser || keyid,
transtime: transtime,
expiretime: transtime + invalidatetimes,
activatecount: data?.activatecount || 0,
activatetimes: data?.activatetimes || 3,
expiredate: data?.expiredate,
activatecategory: data?.activatecategory || this.activateCategory,
activatestatus: data?.activatestatus,
activatelink: data?.activatelink,
activatepage: data?.activatepage,
activateremark: data?.activateremark,
activateparameter: data?.activateparameter,
activatemessage: data?.activatemessage,
activatecontents: data?.activatecontents
};
return this.activateInfo;
}
assignParameters(context, sql, action, mode) {
if (will_db_1.Operation.CREATE == action) {
sql.set("senddate", will_util_1.Utilities.now(), "DATE");
sql.set("sendtime", will_util_1.Utilities.now(), "TIME");
sql.set("transtime", will_util_1.Utilities.now().getTime());
sql.set("activatestatus", null);
}
}
validateActivateInfo(info) {
let valid = { valid: true };
if (!info.activatekey || info.activatekey.trim().length == 0) {
valid = { valid: false, info: "activatekey" };
}
if (!info.activateuser || info.activateuser.trim().length == 0) {
valid = { valid: false, info: "activateuser" };
}
return valid;
}
async doCreate(context, model, invalidatetimes = EnvironmentVariable_1.DEFAULT_INVALIDATE_TIMES) {
let activateuser = undefined;
let info = this.activateInfo;
if (!info) {
let userInfo = await this.getUserTokenInfo(context, true);
activateuser = userInfo?.useruuid || context.params.activateuser;
}
if (!info) {
info = this.createActivateInfo(context.params, invalidatetimes);
info.activateuser = activateuser;
}
let vi = this.validateActivateInfo(info);
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
await this.createActivation(db, info, context);
return await this.createCipherData(context, will_db_1.Operation.CREATE, info);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async createActivation(db, info, context) {
let now = will_util_1.Utilities.now();
let knsql = new will_sql_1.KnSQL();
knsql.append("insert into tactivate (activatekey, activateuser, transtime, expiretime, ");
knsql.append("senddate, sendtime, expiredate, activatecount, activatetimes, ");
knsql.append("activatecategory, activatelink, activatepage, activateremark, ");
knsql.append("activateparameter, activatemessage, activatecontents) ");
knsql.append("values (?activatekey,?activateuser,?transtime,?expiretime,");
knsql.append("?senddate,?sendtime,?expiredate,?activatecount,?activatetimes,");
knsql.append("?activatecategory,?activatelink,?activatepage,?activateremark,");
knsql.append("?activateparameter,?activatemessage,?activatecontents) ");
knsql.set("activatekey", info.activatekey);
knsql.set("activateuser", info.activateuser);
knsql.set("transtime", info.transtime);
knsql.set("expiretime", info.expiretime);
knsql.set("senddate", now, "DATE");
knsql.set("sendtime", now, "TIME");
knsql.set("expiredate", info.expiredate, "DATE");
knsql.set("activatecount", info.activatecount);
knsql.set("activatetimes", info.activatetimes);
knsql.set("activatecategory", info.activatecategory);
knsql.set("activatelink", info.activatelink);
knsql.set("activatepage", info.activatepage);
knsql.set("activateremark", info.activateremark);
knsql.set("activateparameter", info.activateparameter);
knsql.set("activatemessage", info.activatemessage);
knsql.set("activatecontents", info.activatecontents);
return await knsql.executeUpdate(db, context);
}
validateKeyFields(context) {
let vi = this.validateParameters(context.params, "id");
if (!vi.valid) {
vi = this.validateParameters(context.params, "activatekey");
}
return vi;
}
async doRetrieve(context, model) {
let vi = this.validateKeyFields(context);
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let rs = await this.doRetrieving(context, db);
return await this.createCipherData(context, will_db_1.Operation.RETRIEVE, rs);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doRetrieving(context, db) {
let activatekey = context.params.id || context.params.activatekey;
let info = this.createActivateInfo(context.params);
info.activatekey = activatekey;
return await this.performRetrieving(db, info, context);
}
async performRetrieving(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("select * from tactivate ");
knsql.append("where activatekey = ?activatekey ");
knsql.append("and activateuser = ?activateuser ");
knsql.append("and activatestatus is null ");
knsql.set("activatekey", info.activatekey);
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeQuery(db, context);
let result = this.createRecordSet(rs);
if (result.records <= 0) {
knsql.clear();
knsql.append("select * from tactivate ");
knsql.append("where activatekey = ?activatekey ");
knsql.append("and activatestatus is null ");
knsql.set("activatekey", info.activatekey);
rs = await knsql.executeQuery(db, context);
result = this.createRecordSet(rs);
}
return result;
}
async getActivateInfo(db, info, context) {
let rs = await this.performRetrieving(db, info, context);
if (rs && rs.rows.length > 0) {
return rs.rows[0];
}
return undefined;
}
async doActivate(context, model) {
let vi = this.validateKeyFields(context);
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let ainfo = await this.doActivating(context, db);
return await this.createCipherData(context, "activate", ainfo);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doActivating(context, db) {
let activatekey = context.params.id || context.params.activatekey;
let info = this.createActivateInfo(context.params);
info.activatekey = activatekey;
let ainfo = await this.getActivateInfo(db, info, context);
if (ainfo) {
await this.performActivating(db, ainfo, context);
return ainfo;
}
return this.recordNotFound();
}
async performActivating(db, info, context) {
let rs = await this.updateActivation(db, info, context);
await this.deleteActivation(db, info, context);
return rs;
}
async updateActivation(db, info, context) {
let result = await this.updateActivateByKeyAndUser(db, info, context);
if (result.records <= 0) {
result = await this.updateActivateByKey(db, info, context);
}
return result;
}
async updateActivateByKeyAndUser(db, info, context) {
let now = will_util_1.Utilities.now();
info.activatedate = now;
info.activatetime = now;
info.activatecount = info.activatecount || 1;
info.activatestatus = info.activatestatus || "A";
let knsql = new will_sql_1.KnSQL();
knsql.append("update tactivate ");
knsql.append("set activatestatus=?activatestatus, ");
knsql.append("activatedate=?activatedate, ");
knsql.append("activatetime=?activatetime, ");
knsql.append("activatecount=?activatecount ");
knsql.append("where activatekey=?activatekey ");
knsql.append("and activateuser=?activateuser ");
knsql.set("activatestatus", info.activatestatus);
knsql.set("activatedate", info.activatedate, "DATE");
knsql.set("activatetime", info.activatetime, "TIME");
knsql.set("activatecount", info.activatecount);
knsql.set("activatekey", info.activatekey);
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async updateActivateByKey(db, info, context) {
let now = will_util_1.Utilities.now();
info.activatedate = now;
info.activatetime = now;
info.activatecount = info.activatecount || 1;
info.activatestatus = info.activatestatus || "A";
let knsql = new will_sql_1.KnSQL();
knsql.append("update tactivate ");
knsql.append("set activatestatus=?activatestatus, ");
knsql.append("activatedate=?activatedate, ");
knsql.append("activatetime=?activatetime, ");
knsql.append("activatecount=?activatecount ");
knsql.append("where activatekey=?activatekey ");
knsql.set("activatestatus", info.activatestatus);
knsql.set("activatedate", info.activatedate, "DATE");
knsql.set("activatetime", info.activatetime, "TIME");
knsql.set("activatecount", info.activatecount);
knsql.set("activatekey", info.activatekey);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async deleteActivateUser(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("delete from tactivate ");
knsql.append("where activateuser = ?activateuser ");
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async deleteActivateUserCategory(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("delete from tactivate ");
knsql.append("where activateuser = ?activateuser ");
knsql.append("and activatecategory = ?activatecategory ");
knsql.set("activateuser", info.activateuser);
knsql.set("activatecategory", info.activatecategory);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async deleteActivateUserKey(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("delete from tactivate ");
knsql.append("where activatekey = ?activatekey ");
knsql.append("and activateuser = ?activateuser ");
knsql.set("activatekey", info.activatekey);
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async deleteActivateKey(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("delete from tactivate ");
knsql.append("where activatekey = ?activatekey ");
knsql.set("activatekey", info.activatekey);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async deleteExpiration(db, curtime = will_util_1.Utilities.now().getTime(), context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("insert into tactivatehistory ");
knsql.append("select * from tactivate ");
knsql.append("where expiretime < ?curtime ");
knsql.set("curtime", curtime);
await knsql.executeUpdate(db, context);
knsql.clear();
knsql.append("delete from tactivate ");
knsql.append("where expiretime < ?curtime ");
knsql.set("curtime", curtime);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async moveToHistoryByUser(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("insert into tactivatehistory ");
knsql.append("select * from tactivate ");
knsql.append("where activateuser = ?activateuser ");
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async moveToHistoryByKey(db, info, context) {
let knsql = new will_sql_1.KnSQL();
knsql.append("insert into tactivatehistory ");
knsql.append("select * from tactivate ");
knsql.append("where activatekey = ?activatekey ");
knsql.set("activatekey", info.activatekey);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
async doInvalidate(context, model) {
let vi = this.validateKeyFields(context);
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let ainfo = await this.doInvalidating(context, db);
return await this.createCipherData(context, "invalidate", ainfo);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doInvalidating(context, db) {
let activatekey = context.params.id || context.params.activatekey;
let info = this.createActivateInfo(context.params);
info.activatekey = activatekey;
let ainfo = await this.performInvalidating(db, info);
if (ainfo)
return ainfo;
return this.recordNotFound();
}
async performInvalidating(db, info, invalidatetimes = EnvironmentVariable_1.DEFAULT_INVALIDATE_TIMES) {
let ainfo = await this.getActivateInfo(db, info);
if (ainfo) {
if (ainfo.expiredate) {
let comparator = will_util_1.Utilities.compareDate(will_util_1.Utilities.now(), ainfo.expiredate);
if (comparator > 0) {
return Promise.reject(new VerifyError_1.VerifyError("Activate Expired", will_api_1.HTTP.NOT_ALLOWED, -18801, "expiredate"));
}
}
if (ainfo.activatetimes > 0 && ((ainfo.activatecount + 1) > ainfo.activatetimes)) {
return Promise.reject(new VerifyError_1.VerifyError("Over Activate", will_api_1.HTTP.NOT_ALLOWED, -18802, "activatetimes"));
}
let difftimes = will_util_1.Utilities.now().getTime() - ainfo.expiretime;
if (difftimes > 0) {
return Promise.reject(new VerifyError_1.VerifyError("Activate Expired", will_api_1.HTTP.NOT_ALLOWED, -18805, "expiretime"));
}
if ("D" == ainfo.activatestatus) {
return Promise.reject(new VerifyError_1.VerifyError("Already removed", will_api_1.HTTP.NOT_ALLOWED, -18806, "activatestatus"));
}
}
return ainfo;
}
async doInactivate(context, model) {
let vi = this.validateKeyFields(context);
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let ainfo = await this.doInactivating(context, db);
return await this.createCipherData(context, "inactivate", ainfo);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doInactivating(context, db) {
let activatekey = context.params.id || context.params.activatekey;
let info = this.createActivateInfo(context.params);
info.activatekey = activatekey;
let ainfo = await this.performInactivating(db, info, EnvironmentVariable_1.DEFAULT_INVALIDATE_TIMES, context);
if (ainfo)
return ainfo;
return this.recordNotFound();
}
/**
* To invalidate and activate transaction
*/
async performInactivating(db, info, invalidatetimes = EnvironmentVariable_1.DEFAULT_INVALIDATE_TIMES, context) {
let ainfo = await this.performInvalidating(db, info, invalidatetimes);
if (ainfo) {
await this.performActivating(db, ainfo, context);
}
return ainfo;
}
async doUpdate(context, model) {
let vi = this.validateParameters(context.params, "activatekey");
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let rs = await super.doUpdating(context, model);
return await this.createCipherData(context, will_db_1.Operation.REMOVE, this.createRecordSet(rs));
}
async doRemove(context, model) {
let vi = this.validateParameters(context.params, "activatekey");
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let rs = this.doRemoving(context, db);
return await this.createCipherData(context, will_db_1.Operation.REMOVE, rs);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doRemoving(context, db) {
let rs = this.createRecordSet();
let info = this.createActivateInfo(context.params);
let ainfo = await this.getActivateInfo(db, info, context);
if (ainfo) {
rs = await this.deleteActivation(db, ainfo, context);
}
return rs;
}
async deleteActivation(db, info, context) {
await this.moveToHistoryByUser(db, info, context);
return this.deleteActivateUser(db, info, context);
}
async doRemoval(context, model) {
let vi = this.validateParameters(context.params, "activateuser");
if (!vi.valid) {
return Promise.reject(new VerifyError_1.VerifyError("Parameter not found (" + vi.info + ")", will_api_1.HTTP.NOT_ACCEPTABLE, -16061));
}
let db = this.getPrivateConnector(model);
try {
let rs = await this.doRemovaling(context, db);
return await this.createCipherData(context, will_db_1.Operation.RETRIEVE, rs);
}
catch (ex) {
this.logger.error(this.constructor.name, ex);
return Promise.reject(this.getDBError(ex));
}
finally {
if (db)
db.close();
}
}
async doRemovaling(context, db) {
let activateuser = context.params.activateuser;
let info = this.createActivateInfo(context.params);
info.activateuser = activateuser;
return await this.performRemovaling(db, info, context);
}
async performRemovaling(db, info, context) {
let rs = await this.performRemoval(db, info, context);
await this.deleteActivation(db, info, context);
return rs;
}
async performRemoval(db, info, context) {
info.activatestatus = "D";
let knsql = new will_sql_1.KnSQL();
knsql.append("update tactivate set activatestatus = 'D' ");
knsql.append("where activateuser = ?activateuser ");
knsql.append("and activatestatus is null ");
knsql.set("activateuser", info.activateuser);
let rs = await knsql.executeUpdate(db, context);
return this.createRecordSet(rs);
}
}
exports.ActivateHandler = ActivateHandler;