mm_os 1.3.4 → 1.3.6

package/lib/actions.js

@@ -0,0 +1,50 @@
+const Ref = require("./ref.js");
+
+class Action {
+	constructor(obj) {
+		return this.init(obj);
+	}
+}
+
+/**
+ * 实例对象
+ * @param {Object} obj
+ */
+Action.prototype.ref = function(obj) {
+	return new Ref(obj);
+}
+
+/**
+ * 初始化
+ * @param {Object} obj
+ */
+Action.prototype.init = function(obj) {
+	var act = this.ref(obj);
+	return new Proxy(act, {
+		get: (target, prop) => {
+			var value = target[prop];
+			if (value !== undefined) {
+				return value;
+			}
+			value = target.data[prop];
+			if (value !== undefined) {
+				return value;
+			}
+			return target.methods[prop];
+		},
+		set: function(target, prop, value) {
+			if (target[prop] !== undefined) {
+				target[prop] = value;
+			} else if (target.data[prop] !== undefined) {
+				target.data[prop] = value;
+			} else if (target.methods[prop] !== undefined) {
+				target.methods[prop] = value;
+			} else {
+				target[prop] = value;
+			}
+			return true
+		}
+	});
+}
+
+module.exports = Action;

package/lib/app.js

@@ -0,0 +1,73 @@
+const Base = require("./base.js");
+
+/**
+ * 应用管理器
+ */
+class App extends Base {
+	constructor() {
+		super();
+		this.path = "/app".fullname();
+		// 文件拓展名
+		this.extension = "app.json";
+		// 文件存放目录
+		this.dir = "/app";
+		// 重新加载
+		this.reload = false;
+		this.init();
+	}
+}
+
+/**
+ * 补全脚本
+ * @param {Object} action
+ */
+App.prototype.fullAction = function(action) {
+	if (action.data.state === undefined) {
+		action.data.state = 1;
+	}
+	if (!action.methods.init_before) {
+		action.init_before = function() {
+			// 创建插件
+			this.plugin = $.plugin_admin(action.key, action.name + "插件");
+			this.plugin.update(action.jsonFile.dirname());
+		}
+	}
+	return action;
+}
+
+/**
+ * 应用管理器初始化后
+ */
+App.prototype.init_after = function() {
+	for (var k in this.dict) {
+		var cs = this.dict[k];
+		var key = cs.jsonFile.dirname().basename();
+		cs.key = key;
+		this[key] = cs;
+	}
+}
+
+/**
+ * 初始化应用
+ */
+App.prototype.initApp = async function() {
+	for (var k in this.dict) {
+		var o = this.dict[k];
+		if (o.state) {
+			try {
+				await o.run('init');
+			} catch (e) {
+				$.log.error("初始化应用错误", e);
+			}
+		}
+	}
+}
+
+/**
+ * 安装应用
+ */
+App.prototype.install = async function(name, ...args) {
+	return await this.exec(name, 'install', ...args);
+}
+
+module.exports = App;

package/lib/base.js

@@ -0,0 +1,355 @@
+const conf = require("mm_config");
+const Actions = require("./actions.js");
+const fs = require('fs');
+const path = require('path');
+
+function rmdir(dir) {
+	var list = fs.readdirSync(dir);
+	for (var i = 0; i < list.length; i++) {
+		var filename = path.join(dir, list[i]);
+		var stat = fs.statSync(filename);
+
+		if (filename == "." || filename == "..") {
+			// pass these files
+		} else if (stat.isDirectory()) {
+			// rmdir recursively
+			rmdir(filename);
+		} else {
+			// rm fiilename
+			fs.unlinkSync(filename);
+		}
+	}
+	fs.rmdirSync(dir);
+};
+
+/**
+ * 系统基础类
+ */
+class Base {
+	/**
+	 * 构造函数
+	 */
+	constructor() {
+		// 字典
+		this.dict = {};
+		// 检索路径
+		this.path = "";
+		// 文件拓展名
+		this.extension = "*.json";
+		// 检索路径
+		this.dir = "/data";
+		// 重新加载
+		this.reload = true;
+		// 识别用的主键
+		this.key = "name";
+	}
+}
+
+Base.prototype.init_after = function() {
+
+}
+
+/**
+ * 初始化地区
+ * @param {Boolean} reset 是否重新初始化，true则全部重新初始化
+ */
+Base.prototype.init = function(reset = false) {
+	var files = this.getFiles();
+	for (var i = 0; i < files.length; i++) {
+		var file = files[i];
+		this.load(file, reset);
+	}
+	this.init_after(reset);
+}
+
+/**
+ * 获取文件
+ */
+Base.prototype.getFiles = function() {
+	var files = [];
+	if (this.path) {
+		// 模块自带路径
+		var path = "../core".fullname(__dirname);
+		files = $.file.getAll(path, this.extension);
+		// 自定义路径
+		var path_2 = this.path.fullname(__dirname);
+		path_2.addDir();
+		var files_2 = $.file.getAll(path_2, this.extension);
+		files.addList(files_2);
+	}
+	return files;
+}
+
+/**
+ * 脚本实例
+ * @param {Object} obj 对象
+ */
+Base.prototype.script = function(obj) {
+	return new Actions(obj);
+}
+
+/**
+ * 补全脚本
+ * @param {Object} action
+ */
+Base.prototype.fullAction = function(action) {
+	return action;
+}
+
+/**
+ * 加载配置及脚本程序
+ * @param {String} jsonFile 配置文件名
+ * @param {Boolean} reload 是否重载，true为重载
+ */
+Base.prototype.load = function(jsonFile, reload = false) {
+	if (jsonFile.indexOf($.slash + "tpl") !== -1) {
+		return
+	}
+	// 加载json配置
+	var m = this.loadJson(jsonFile);
+	if (m) {
+		var cache = {};
+		var methods = {};
+		var jsFile;
+		// 加载脚本
+		if (m.script) {
+			if (m.script.indexOf(this.dir) === 0) {
+				jsFile = ("." + m.script).fullname($.gamePath);
+			} else {
+				jsFile = m.script.fullname(jsonFile.dirname());
+			}
+			if (!jsFile.hasFile()) {
+				jsFile = "";
+			}
+			var js;
+			if (reload) {
+				js = this.reLoadJS(jsFile);
+			} else {
+				js = this.loadJS(jsFile);
+			}
+			cache = js.cache;
+			methods = js.methods;
+		}
+		var action = this.script({
+			data: m,
+			methods
+		});
+		for (var k in cache) {
+			action[k] = cache[k]
+		}
+		action.jsonFile = jsonFile;
+		this.dict[m[this.key]] = this.fullAction(action);
+		return this.dict[m[this.key]];
+	}
+	return null;
+}
+
+/**
+ * 加载JSON配置
+ * @param {String} file 文件名
+ */
+Base.prototype.loadJson = function(file) {
+	return conf(file.loadJson(), file);
+}
+
+/**
+ * 加载JS
+ * @param {String} file 文件名
+ */
+Base.prototype.loadJS = function(file) {
+	var cache = {};
+	var methods = {};
+	if (file && file.hasFile()) {
+		try {
+			var js = require(file);
+			if (js) {
+				for (var k in js) {
+					var val = js[k];
+					if (typeof(val) == "function") {
+						methods[k] = val
+					} else {
+						cache[k] = val
+					}
+				}
+				cache.jsFile = file;
+			}
+		} catch (err) {
+			console.error("loadJS error", file);
+			console.error(err);
+		}
+	}
+	return {
+		cache,
+		methods
+	}
+}
+
+/**
+ * 卸载JS
+ * @param {String} file 文件名
+ */
+Base.prototype.unLoadJS = function(file) {
+	// 用完后卸载模块
+	var name = require.resolve(file);
+	delete require.cache[name];
+}
+
+/**
+ * 重新加载JS
+ * @param {String} file 文件名
+ */
+Base.prototype.reLoadJS = function(file) {
+	// 先卸载
+	this.unLoadJS(file);
+	// 再加载
+	return this.loadJS(file);
+}
+
+/**
+ * 查询索引
+ */
+Base.prototype.index = function() {
+	var arr = [];
+	var rx = /[\u4e00-\u9fa5]/g;
+	for (var k in this.dict) {
+		if (rx.test(k)) {
+			arr.push(k);
+		}
+	}
+	return arr;
+}
+
+/**
+ * 查询
+ * @param {String} name 名称或ID
+ * @param {Object} model 默认对象
+ */
+Base.prototype.get = function(name, model) {
+	var obj = this.dict[name];
+	if (!obj) {
+		if (model) {
+			return this.add(name, model);
+		} else {
+			return null;
+		}
+	}
+	return obj;
+}
+
+/**
+ * 获取类
+ * @param {String} query 查询条件
+ */
+Base.prototype.getClass = function(query) {
+	var cs;
+	for (var k in this.dict) {
+		var o = this.dict[k];
+		if ($.as(o, query)) {
+			cs = o;
+			break;
+		}
+	}
+	return cs;
+}
+
+/**
+ * 运行脚本
+ * @param {String} name 名称
+ * @param {String} func_name 执行方法
+ * @param {Object} args 参数集合
+ * @returns {Object} 返回执行结果
+ */
+Base.prototype.run = function(name, func_name, ...args) {
+	var tip;
+	var cs = this.dict[name];
+	if (cs) {
+		if (!cs.jsFile) {
+			return "执行错误！原因：脚本文件不存在！\n" + cs.script;
+		}
+		try {
+			// var act = Object.assign({}, cs);
+			tip = cs.run(func_name, ...args);
+		} catch (e) {
+			console.error(e);
+			tip = "执行错误！原因：" + e.message;
+		}
+
+		if (this.reload) {
+			if (process.env.NODE_ENV == "development" || $.config.mode == "dev") {
+				// 用完后重载模块
+				var {
+					methods,
+					cache
+				} = this.reLoadJS(cs.jsFile);
+				cs.methods = methods;
+				for (var k in cache) {
+					cs[k] = cache[k]
+				}
+			}
+		}
+	} else {
+		tip = `【${name}】不存在！`
+	}
+	return tip;
+}
+
+/**
+ * 创建
+ * @param {String} name 名称
+ * @param {Object} model 数据模型
+ */
+Base.prototype.add = function(name, model) {
+	var file = ("./" + name + "/" + this.extension).fullname(this.path);
+	file.addDir();
+	var f = file.replace($.slash + name + $.slash, $.slash + 'tpl' + $.slash);
+	var m = f.loadJson();
+	if (model) {
+		model = Object.assign(m || {}, model, {
+			name
+		});
+	} else {
+		model = Object.assign(m || {}, {
+			name
+		});
+	}
+	file.saveJson(model);
+	return this.load(file);
+};
+
+/**
+ * 删除
+ * @param {String} idOrName
+ */
+Base.prototype.del = function(idOrName) {
+	var obj = this.dict[idOrName];
+	if (!obj) {
+		return idOrName + " 不存在！";
+	}
+	try {
+		var dir = obj.jsonFile.dirname();
+		rmdir(dir);
+		delete this.dict[idOrName];
+	} catch (err) {
+		$.log.error("删除应用失败", err);
+	}
+}
+
+/**
+ * 修改
+ * @param {String} idOrName 唯一标识或名称
+ * @param {Object} model 模型
+ * @returns 返回true或false
+ */
+Base.prototype.set = function(idOrName, model) {
+	if (model) {
+		var obj = this.dict[idOrName];
+		if (obj) {
+			Object.assign(obj, model);
+			return null;
+		}
+		return `【${idOrName}】不存在！`;
+	}
+	return "要修改的数据不能为空！";
+}
+
+module.exports = Base;

package/lib/com.js

@@ -0,0 +1,31 @@
+const Base = require("./base.js");
+
+/**
+ * 公共开发
+ */
+class Com extends Base {
+	constructor() {
+		super();
+		this.path = "/com".fullname();
+		// 文件拓展名
+		this.extension = "com.json";
+		// 文件存放目录
+		this.dir = "/com";
+		// 重新加载
+		this.reload = false;
+		this.init();
+	}
+}
+
+/**
+ * 公共初始化后
+ */
+Com.prototype.init_after = function() {
+	for (var k in this.dict) {
+		var cs = this.dict[k];
+		var key = cs.jsonFile.dirname().basename();
+		this[key] = cs;
+	}
+}
+
+module.exports = Com;

package/lib/game.js

@@ -0,0 +1,31 @@
+const Base = require("./base.js");
+
+/**
+ * 游戏管理器
+ */
+class Game extends Base {
+	constructor() {
+		super();
+		this.path = "/game".fullname();
+		// 文件拓展名
+		this.extension = "game.json";
+		// 文件存放目录
+		this.dir = "/game";
+		// 重新加载
+		this.reload = false;
+		this.init();
+	}
+}
+
+/**
+ * 游戏管理器初始化后
+ */
+Game.prototype.init_after = function() {
+	for (var k in this.dict) {
+		var cs = this.dict[k];
+		var key = cs.jsonFile.dirname().basename();
+		this[key] = cs;
+	}
+}
+
+module.exports = Game;

package/lib/ref.js

@@ -0,0 +1,121 @@
+const {
+	types
+} = require("util");
+
+/**
+ * 行为器
+ */
+class Ref {
+	/**
+	 * 构造函数
+	 * @param {Object} obj 对象
+	 */
+	constructor(obj) {
+		this.msg = [];
+		this._init(obj);
+	}
+}
+
+/**
+ * 初始化
+ * @param {Object} config 配置参数
+ * @returns {Object} 执行结果
+ */
+Ref.prototype._init = function(obj) {
+	Object.assign(this, obj);
+	this.data = this.data || {};
+	this.methods = this.methods || {};
+	return this;
+}
+
+/**
+ * 运行当前类函数
+ * @param {String} name 函数名
+ * @param {Object} args 参数集合
+ * @returns {Object} 执行结果
+ */
+Ref.prototype.run = async function(name, ...args) {
+	var ret;
+	var key = name + "_before";
+	if (this[key]) {
+		ret = this[key](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+	}
+	key = name + "_check";
+	if (this[key]) {
+		ret = this[key](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+		if (ret) {
+			return ret;
+		}
+	}
+	
+	if (this[name]) {
+		ret = this[name](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+		if (ret) {
+			key = name + "_after";
+			if (this[key]) {
+				ret = this[key](...args);
+				if (types.isPromise(ret)) {
+					ret = await ret
+				}
+			}
+		}
+	}
+	return ret;
+}
+
+/**
+ * 执行子脚本函数
+ * @param {String} name 名称
+ * @param {String} func_name 执行方法
+ * @param {Object} args 参数集合
+ * @returns {Object} 返回执行结果
+ */
+Ref.prototype.exec = async function(name, func_name, ...args) {
+	var cs = this.dict[name];
+	var ret;
+	var key = func_name + "_before";
+	if (cs[key]) {
+		ret = cs[key](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+	}
+	key = func_name + "_check";
+	if (cs[key]) {
+		ret = cs[key](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+		if (ret) {
+			return ret;
+		}
+	}
+	
+	if (cs[func_name]) {
+		ret = cs[func_name](...args);
+		if (types.isPromise(ret)) {
+			ret = await ret
+		}
+		if (ret) {
+			key = func_name + "_after";
+			if (cs[key]) {
+				ret = cs[key](...args);
+				if (types.isPromise(ret)) {
+					ret = await ret
+				}
+			}
+		}
+	}
+	return ret;
+}
+
+module.exports = Ref;

package/middleware/cors/index.js

@@ -0,0 +1,57 @@
+/**
+ * 应用
+ * @param {Object} server 服务
+ * @param {Object} config 配置参数
+ */
+module.exports = function(server, config) {
+	/* 跨域限制（web防火墙） */
+	server.use(async (ctx, next) => {
+		var req = ctx.request;
+
+		// 允许来自所有域名请求
+		ctx.set('Access-Control-Allow-Origin', '*');
+		// 这样就能只允许 http://localhost:8080 这个域名的请求了
+		// ctx.set("Access-Control-Allow-Origin", "http://localhost:8080");
+
+		// 设置所允许的HTTP请求方法OPTIONS,GET,PUT,POST,DELETE
+		ctx.set('Access-Control-Allow-Methods', 'PUT, POST, GET, DELETE, HEAD, OPTIONS')
+
+
+		// 字段是必需的。它也是一个逗号分隔的字符串，表明服务器支持的所有头信息字段.
+		ctx.set('Access-Control-Allow-Headers',
+			'Content-Type, Content-Length, Authorization, Accept, X-Requested-With, x-auth-token, token, client_id, appid, apikey, user_id,x-forwarded-for,x-real-ip,user-agent,cache-control,pragma,accept-encoding,connection,host'
+			);
+
+		// 服务器收到请求以后，检查了Origin、Access-Control-Request-Method和Access-Control-Request-Headers字段以后，确认允许跨源请求，就可以做出回应。
+
+		// Content-Type表示具体请求中的媒体类型信息
+		// ctx.set("Content-Type", "application/json;charset=utf-8");
+
+		// 该字段可选。它的值是一个布尔值，表示是否允许发送Cookie。默认情况下，Cookie不包括在CORS请求之中。
+		// 当设置成允许请求携带cookie时，需要保证"Access-Control-Allow-Origin"是服务器有的域名，而不能是"*";
+		ctx.set("Access-Control-Allow-Credentials", 'false');
+
+		// 该字段可选，用来指定本次预检请求的有效期，单位为秒。
+		// 当请求方法是PUT或DELETE等特殊方法或者Content-Type字段的类型是application/json时，服务器会提前发送一次请求进行验证
+		// 下面的的设置只本次验证的有效时间，即在该时间段内服务端可以不用进行验证
+		ctx.set("Access-Control-Max-Age", '3600');
+		/*
+		CORS请求时，XMLHttpRequest对象的getResponseHeader()方法只能拿到6个基本字段：
+		    Cache-Control、
+		    Content-Language、
+		    Content-Type、
+		    Expires、
+		    Last-Modified、
+		    Pragma。
+		*/
+		// 需要获取其他字段时，使用Access-Control-Expose-Headers，
+		// getResponseHeader('myData')可以返回我们所需的值
+		// ctx.set("Access-Control-Expose-Headers", "myData");
+		if (req.method === 'OPTIONS') {
+			ctx.status = 204;
+		} else {
+			await next();
+		}
+	});
+	return server;
+};