mm_os 4.3.6 → 5.0.0

package/com/event/index.js

@@ -1,438 +0,0 @@
-const Manager = require("mm_machine").Manager;
-const Drive = require("./drive");
-
-/**
- * Event事件类
- * @augments {Manager}
- * @class
- */
-class Event extends Manager {
-  /**
-   * 配置参数
-   * @type {object}
-   */
-  static config = {
-    /**
-     * 名称
-     * @type {string}
-     */
-    name: "",
-    /**
-     * 标题
-     * @type {string}
-     */
-    title: "事件管理",
-    /**
-     * 描述
-     * @type {string}
-     */
-    description: "这是事件管理器",
-    /**
-     * 检索文件名
-     * @type {string}
-     */
-    filename: "event.json",
-    /**
-     * 模板目录
-     * @type {string}
-     */
-    tpl_dir: __dirname,
-    /**
-     * 基础目录
-     * @type {string}
-     */
-    base_dir: "../common/event".fullname(__dirname),
-    /**
-     * 自定义目录，加载项目自定义资源
-     * @type {string}
-     */
-    dir: "./app".fullname(),
-    /**
-     * 搜索模式 dir按目录搜索 | file按文件名搜索
-     * @type {string}
-     */
-    search_way: "dir",
-    /**
-     * 是否懒加载
-     * @type {boolean}
-     */
-    lazy_load: true,
-    /**
-     * 模式
-     * 1.生产模式，改变文件不会重新加载
-     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
-     * 3.热重载模式，改变配置文件都会加载配置和脚本
-     * 4.重载模式，执行完后重新加载脚本，避免变量污染
-     * 5.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
-     * @type {number}
-     */
-    mode: process.env.NODE_ENV === "production" ? 1 : 3,
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父级模块
-   */
-  constructor(config, parent) {
-    super({ ...Event.config, ...config }, parent);
-  }
-}
-
-/**
- * 预设事件
- */
-Event.prototype._preset = function () {
-  // 验证前
-  this.list_before = [];
-  // 验证
-  this.list_check = [];
-  // 执行
-  this.list_main = [];
-  // 渲染
-  this.list_render = [];
-  // 渲染后
-  this.list_after = [];
-};
-
-/**
- * 事件驱动类
- * @type {Drive}
- */
-Event.prototype.Drive = Drive;
-
-/**
- * 更新配置，注册模块后重建事件列表
- * @param {string} dir 检索路径
- * @param {boolean} clear 是否清除缓存
- */
-Event.prototype.update = async function (dir, clear = true) {
-  try {
-    if (clear) {
-      this.clearMods();
-    }
-    var search_dir = dir || this.config.dir;
-    var files = await this._findFiles(search_dir);
-    this.regMods(files);
-    this.updateInfo();
-    if (!this.config.lazy_load) {
-      await this.loadMods();
-    }
-    this._is_loaded = true;
-  } catch (err) {
-    this.log("error", "更新配置失败", err);
-  }
-};
-
-/**
- * 清除事件
- * @param {string} stage 阶段
- */
-Event.prototype.clear = function (stage) {
-  if (stage) {
-    if (this["list_" + stage]) {
-      this["list_" + stage] = [];
-    } else {
-      this.log(
-        "debug",
-        "清空失败，事件发展阶段{0}不存在！".replace("{0}", stage),
-      );
-    }
-  } else {
-    this.list_before = [];
-    this.list_check = [];
-    this.list_main = [];
-    this.list_render = [];
-    this.list_after = [];
-  }
-};
-
-/**
- * 更新模块信息
- */
-Event.prototype.updateInfo = function () {
-  this._preset();
-  this.infos = [];
-  for (let name in this.mods) {
-    let o = this.mods[name];
-    let info = {
-      name: o.config.name,
-      sort: o.config.sort,
-      state: o.config.state,
-      config_file: o.config_file,
-    };
-    this.infos.push(info);
-    this.pushList(o.config.stage, info);
-  }
-  this._sort();
-};
-
-/**
- * 推送事件信息
- * @param {string} stage 阶段
- * @param {object} info 事件信息
- */
-Event.prototype.pushList = function (stage, info) {
-  switch (stage) {
-    case "before":
-      this.list_before.push(info);
-      break;
-    case "check":
-      this.list_check.push(info);
-      break;
-    case "main":
-      this.list_main.push(info);
-      break;
-    case "render":
-      this.list_render.push(info);
-      break;
-    case "after":
-      this.list_after.push(info);
-      break;
-    default:
-      break;
-  }
-};
-
-/**
- * 事件排序
- */
-Event.prototype._sort = function () {
-  this._sortSub(this.list_before);
-  this._sortSub(this.list_check);
-  this._sortSub(this.list_main);
-  this._sortSub(this.list_render);
-  this._sortSub(this.list_after);
-};
-
-/**
- * 事件排序
- * @param {Array} list 列表
- */
-Event.prototype._sortSub = function (list) {
-  var sort_key = this.config.sort_key || "sort";
-  list.sort((o1, o2) => {
-    let s1 = o1[sort_key] || 100;
-    let s2 = o2[sort_key] || 100;
-    var cha = s1 - s2;
-    if (cha === 0) {
-      let mod1 = this.getMod(o1.name);
-      let mod2 = this.getMod(o2.name);
-      if (mod1 && mod2) {
-        cha = mod2.config.target.length - mod1.config.target.length;
-      }
-    }
-    return cha;
-  });
-};
-
-/**
- * 执行事件
- * @param {object} mod 模块
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.doing = async function (mod, ctx, db) {
-  if (!mod.isLoaded()) {
-    await mod.do("load");
-  }
-  var ret = await mod.run(ctx, db);
-  if (this.mode > 4) {
-    mod.do("reload");
-  }
-  return ret;
-};
-
-/**
- * 匹配目标
- * @param {string} str 目标
- * @param {string} pattern 模式
- * @returns {boolean} 是否匹配
- */
-Event.prototype.isMatch = function (str, pattern) {
-  if (str === pattern) {
-    return true;
-  } else if (pattern.startsWith("*")) {
-    let clean = pattern.replaceAll("*", "");
-    if (pattern.endsWith("*")) {
-      return str.indexOf(clean) !== -1;
-    } else {
-      return str.endsWith(clean);
-    }
-  } else if (pattern.endsWith("*")) {
-    let clean = pattern.replaceAll("*", "");
-    return str.startsWith(clean);
-  } else {
-    return false;
-  }
-};
-
-/**
- * 执行函数
- * @param {Array} list 列表
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.runSub = async function (list, target, ctx, db) {
-  for (var i = 0, info; (info = list[i++]);) {
-    if (info.state === 1) {
-      let mod = this.getMod(info.name);
-      if (mod && this.isMatch(target, mod.config.target)) {
-        try {
-          let ret = await this.doing(mod, ctx, db);
-          if (ret) {
-            db.ret = ret;
-            if (mod.config.end) {
-              break;
-            }
-          }
-        } catch (error) {
-          // 事件执行异常时继续执行下一个事件
-          this.log("error", `事件${info.name}执行失败`, error);
-        }
-      }
-    }
-  }
-  return db.ret;
-};
-
-/**
- * 之前
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.before = async function (target, ctx, db) {
-  return await this.runSub(this.list_before, target, ctx, db);
-};
-
-/**
- * 验证
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.check = async function (target, ctx, db) {
-  return await this.runSub(this.list_check, target, ctx, db);
-};
-
-/**
- * 主要
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.main = async function (target, ctx, db) {
-  return await this.runSub(this.list_main, target, ctx, db);
-};
-
-/**
- * 渲染
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.render = async function (target, ctx, db) {
-  return await this.runSub(this.list_render, target, ctx, db);
-};
-
-/**
- * 之后
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.after = async function (target, ctx, db) {
-  return await this.runSub(this.list_after, target, ctx, db);
-};
-
-/**
- * 执行事件
- * @param {string} target 目标
- * @param {object} ctx 请求上下文
- * @param {object} db 数据管理器
- * @returns {object} 执行结果
- */
-Event.prototype.run = async function (target, ctx, db = {}) {
-  var ret = await this.before(target, ctx, db);
-  if (!ret) {
-    ret = await this.check(target, ctx, db);
-    if (!ret) {
-      ret = await this.main(target, ctx, db);
-    }
-    ret = await this.render(target, ctx, db);
-    if (ret) {
-      ret = await this.after(target, ctx, db);
-    }
-  }
-  return ret;
-};
-
-/**
- * 获取事件
- * @param {string} name 名称
- * @param {string} stage 阶段
- * @returns {object} 返回单项配置
- */
-Event.prototype.get = function (name, stage = "main") {
-  var obj;
-  var lt = this["list_" + stage];
-  var len = lt.length;
-  for (var i = 0; i < len; i++) {
-    var o = lt[i];
-    if (name === o.config.name) {
-      obj = o;
-      break;
-    }
-  }
-  return obj;
-};
-
-/**
- * @module 导出Event类
- */
-exports.Event = Event;
-
-/**
- * Event事件池
- */
-if (!$.pool.event) {
-  $.pool.event = {};
-}
-
-/**
- * Event事件池
- * @param {string} scope 作用域
- * @param {string} title 标题
- * @returns {object} 返回一个事件类
- */
-function eventAdmin(scope, title) {
-  var sc = scope || $.val.scope + "";
-  var obj = $.pool.event[sc];
-  if (!obj) {
-    $.pool.event[sc] = new Event({
-      name: sc,
-      title: title,
-    });
-    obj = $.pool.event[sc];
-  }
-  return obj;
-}
-
-/**
- * Event管理器，用于创建缓存
- * @param {string} scope 作用域
- * @param {string} title 标题
- * @returns {object} 返回一个缓存类
- */
-if ($.admin) {
-  $.admin.event = eventAdmin;
-}

package/com/event/script.tpl.js

@@ -1,23 +0,0 @@
-exports = {
-  async init(options) {
-    // 使用api管理器
-    var api = $.admin.api('${name}_api', '${title}客户端');
-    // 首次启动更新api接口;
-    await api.call('update', 'app/');
-  },
-  /**
-   * 接口主函数
-   * @param {object} ctx HTTP上下文
-   * @param {object} db 数据管理器,如: { next: async function{}, ret: {} }
-   * @returns {object} 执行结果
-   */
-  async main(ctx, db) {
-    var sql = $.admin.sql('sys');
-    // 使用模板引擎
-    db.tpl = new $.Tpl();
-
-    // 在这定义要访问的数据库 (分布式开发时设置不同的数据库名)
-    $.push(db, sql.db(), true);
-    return api.run(ctx, db);
-  }
-};

package/com/mqtt/README.md

@@ -1,47 +0,0 @@
-# websocket 开发说明
-
-## 简介
-Websocket 是用于与浏览器客户端实现双向通讯的协议，可用来实现即时通讯、交易所、消息推送等。
-
-## 关于mm websocket的使用
-前端和服务端均已集成webstock功能，前端使用mm_sdk，后端使用com/websocket框架机制
-
-## websocket 使用规范
-为了让前后端通讯更加稳定、可控，前后端均采用json-rpc2.0的方式进行通讯，采用以下传参规范 ↓
-
-在客户端给服务端发送消息时，或在服务端给客户端发送消息时（响应格式）:
-`
-	{
-		// 消息ID (用于识别对应请求)
-		id: "",
-		// 调用方法 (例如聊天时为chat、请求获取联系人时为get_contact)
-		method: "",
-		// 请求参数
-		params: {}
-	}
-`
-
-如果需要在某一端接收到消息后，告诉对方已收到消息或返回内容，可以给对方端推送一条消息（响应格式）:
-`
-	{
-		// 消息ID (用于响应对应请求)
-		id: "",
-		// 错误提示 (错误时必须返回)
-		error: {
-			// 错误码
-			code: -32602,
-			// 错误提示
-			message: ""
-		},
-		// 响应结果 (成功时必须返回)
-		result: {}
-	}
-`
-
-## mm websocket 通讯json-rpc2.0协议原理
-	1. 首先websocket给客户端和服务端提供了一个接收消息的接口，可以收到来自对方的消息
-	2. 然后双方可以通过收到的json数据中是否含有method属性来判断对方端是请求查询，还是提交数据
-	3. 如果是提交数据，则接收数据处理并存储
-	4. 如果是请求查询，则给请求做处理，并回推送一条消息
-	5. 为了能够识别消息是否成功推送，通过响应格式中的ID属性来判断
-	6. 如果非请求或响应, 只是单向推送数据, 那么可以通过id属性值0或空进行识别

package/com/mqtt/com.json

@@ -1,5 +0,0 @@
-{
-    "name": "MQTT",
-    "title": "MQTT管理器",
-    "state": 1
-}

package/com/mqtt/config.tpl.json

@@ -1,42 +0,0 @@
-{
-	// 名称, 由中英文和下“_”组成, 用于修改或卸载 例如: demo
-	"name": "${name || 'mqtt'}",
-	// mqtt 服务标题
-	"title": "${title || '示例mqtt服务'}",
-	// mqtt 服务介绍
-	"description": "${description || '描述mqtt服务使用方法'}",
-	// 状态 0未启用，1启用
-	"state": 1,
-	// 订阅的主题 {产品类型}/{设备ID}/{数据类型}/{子类型}
-	// 接收设备状态、事件、命令回复、设备请求
-	"topic": [
-		"face/+/status",
-		"face/+/event/recognition",
-		"face/+/cmd/+/response",
-		"face/+/request/+"
-	],
-	// 回复订阅主题
-	"topic_receive": [
-		"face/${clientid}/response/${method}"
-	],
-	// 给客户端推送的主题
-	"topic_push": "face/${clientid}/cmd/${method}",
-	// 接收方式
-	"qos": 2,
-	// 保持接收
-	"retain": true,
-	// 超时反馈
-	"longtime": 60000,
-	// 客户端ID
-	"clientid": "clientid",
-	// 消息ID
-	"msgid": "msgid",
-	// 请求方法
-	"method": "method",
-	// 参数
-	"params": "params",
-	// 结果
-	"result": "result",
-	// 回复方法
-	"method_receive": "${method}_ask"
-}