mm_os 4.3.6 → 5.0.0

package/com/socket/index.js

@@ -1,402 +0,0 @@
-const Manager = require('mm_machine').Manager;
-const Drive = require('./drive');
-
-/**
- * 任务类
- * @augments {Manager}
- * @class
- */
-class Socket extends Manager {
-  /**
-   * 配置参数
-   * @type {object}
-   */
-  static config = {
-    /**
-     * 名称
-     * @type {string}
-     */
-    name: '',
-    /**
-     * 标题
-     * @type {string}
-     */
-    title: 'socket管理',
-    /**
-     * 描述
-     * @type {string}
-     */
-    description: '这是socket管理器',
-    /**
-     * 检索文件名
-     * @type {string}
-     */
-    filename: 'socket.json',
-    /**
-     * 模板目录
-     * @type {string}
-     */
-    tpl_dir: __dirname,
-    /**
-     * 基础目录
-     * @type {string}
-     */
-    base_dir: '../common/socket'.fullname(__dirname),
-    /**
-     * 自定义目录，加载项目自定义资源
-     * @type {string}
-     */
-    dir: './app'.fullname(),
-    /**
-     * 搜索模式 dir按目录搜索 | file按文件名搜索
-     * @type {string}
-     */
-    search_way: 'file',
-    /**
-     * 是否懒加载
-     * @type {boolean}
-     */
-    lazy_load: false,
-    /**
-     * 模式
-     * 1.生产模式，改变文件不会重新加载
-     * 2.热更新模式，改变配置文件会重新加载配置，不重新加载脚本
-     * 3.热重载模式，改变配置文件都会加载配置和脚本
-     * 4.重载模式，执行完后重新加载脚本，避免变量污染
-     * 5.热更新+重载模式，改变配置文件重新加载配置和脚本，执行完后重新加载脚本
-     * @type {number}
-     */
-    mode: process.env.NODE_ENV === 'production' ? 1 : 3,
-    /**
-     * 最大深度
-     * @type {number}
-     */
-    max_depth: 6
-  };
-
-  /**
-   * 构造函数
-   * @param {object} config 配置参数
-   * @param {object} parent 父级模块
-   */
-  constructor(config, parent) {
-    super({ ...Socket.config, ...config }, parent);
-    this.dict = {};
-
-    /**
-     * 消息ID索引 (id => message对象), 用于O(1)查找
-     */
-    this.dict_msg = {};
-
-    /**
-     * 消息队列
-     */
-    this.list_msg = [
-      /*
-      {
-        // 消息ID
-        id: "",
-        // 请求方法
-        method: "",
-        // 消息参数
-        params: {},
-        // 回调函数
-        func: function(res){},
-        // 时间戳
-        timestamp: 0,
-        // 超时时间
-        timeout: 0,
-        // 定时器
-        timer: null
-      }
-      */
-    ];
-  }
-}
-
-/**
- * socket驱动类
- * @type {Drive}
- */
-Socket.prototype.Drive = Drive;
-
-/**
- * 处理socket请求
- * @param {object} ctx 请求上下文
- * @param {Function} next 跳过当前, 然后继续执行函数
- */
-Socket.prototype.run = async function (ctx, next) {
-  if (typeof next === 'function') {
-    await next();
-  }
-  if (!ctx || !ctx.path) {
-    return;
-  }
-  let path = ctx.path.toLocaleLowerCase();
-  var mods = this.getMods();
-  for (var name in mods) {
-    var mod = mods[name];
-    var mod_path = mod.config && mod.config.path;
-    if (mod.config && mod.config.state === 1 && mod_path) {
-      if (path === mod_path) {
-        if (!mod.isLoaded()) {
-          await mod.do('load');
-        }
-        mod.add(ctx);
-        break;
-      }
-    }
-  }
-};
-
-/**
- * 发送消息到指定客户端
- * @param {string} clientid 客户端ID
- * @param {string} method 方法名称
- * @param {object} params 请求参数
- * @returns {boolean} 发送是否成功
- */
-Socket.prototype.send = function (clientid, method, params) {
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    if (o.config.state === 1 && o.send) {
-      // 设置管理器引用，用于消息回复处理
-      o.manager = this;
-      return o.send(clientid, method, params);
-    }
-  }
-  return false;
-};
-
-/**
- * 发送消息到所有连接的客户端
- * @param {string} method 方法名称
- * @param {object} params 请求参数
- */
-Socket.prototype.sendAll = function (method, params) {
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    if (o.config.state === 1 && o.sendAll) {
-      // 设置管理器引用，用于消息回复处理
-      o.manager = this;
-      o.sendAll(method, params);
-    }
-  }
-};
-
-/**
- * 发送请求到指定客户端
- * @param {string} clientid 客户端ID
- * @param {string} method 方法名称
- * @param {object} params 请求参数
- * @param {Function} func 回调函数
- * @param {number} timeout 超时时间（毫秒）
- * @returns {boolean} 发送是否成功
- */
-Socket.prototype.req = function (clientid, method, params, func, timeout = 0) {
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    if (o.config.state === 1 && o.req) {
-      // 设置管理器引用，用于消息回复处理
-      o.manager = this;
-      return o.req(clientid, method, params, func, timeout);
-    }
-  }
-  return false;
-};
-
-/**
- * 发送请求到所有连接的客户端
- * @param {string} method 方法名称
- * @param {object} params 请求参数
- * @param {Function} func 回调函数
- * @param {number} timeout 超时时间（毫秒）
- */
-Socket.prototype.reqAll = function (method, params, func, timeout = 0) {
-  var mods = this.getMods();
-  for (var k in mods) {
-    var o = mods[k];
-    if (o.config.state === 1 && o.reqAll) {
-      // 设置管理器引用，用于消息回复处理
-      o.manager = this;
-      o.reqAll(method, params, func, timeout);
-    }
-  }
-};
-
-/**
- * 同步请求到指定客户端 - 可及时取回消息
- * @param {string} clientid 客户端ID
- * @param {string} method 请求方法
- * @param {object} params 传递参数
- * @param {number} timeout 超时时间（毫秒）
- * @returns {Promise} 返回响应结果的Promise
- */
-Socket.prototype.reqAsync = function (clientid, method, params, timeout = 0) {
-  var _this = this;
-  var timeout_ms = timeout || 3000;
-  return new Promise((resolve, reject) => {
-    var has_res = false;
-    var timer = setTimeout(() => {
-      if (!has_res) {
-        reject(new Error('Socket请求超时'));
-      }
-    }, timeout_ms);
-    _this.req(
-      clientid,
-      method,
-      params,
-      (res) => {
-        if (!has_res) {
-          has_res = true;
-          clearTimeout(timer);
-          resolve(res);
-        }
-      },
-      timeout,
-    );
-  });
-};
-
-/**
- * 同步请求到所有客户端 - 可及时取回消息
- * @param {string} method 请求方法
- * @param {object} params 传递参数
- * @param {number} timeout 超时时间（毫秒）
- * @returns {Promise} 返回响应结果的Promise
- */
-Socket.prototype.reqAsyncAll = function (method, params, timeout = 0) {
-  var _this = this;
-  var timeout_ms = timeout || 3000;
-  return new Promise((resolve, reject) => {
-    var timer = setTimeout(() => {
-      reject(new Error('Socket广播请求超时'));
-    }, timeout_ms);
-    _this.reqAll(
-      method,
-      params,
-      (res) => {
-        clearTimeout(timer);
-        resolve(res);
-      },
-      timeout,
-    );
-  });
-};
-
-/**
- * 生成消息ID
- * @returns {string} 消息ID
- * @private
- */
-Socket.prototype._genId = function () {
-  return (
-    'socket_' +
-    Date.parse(new Date()) +
-    '_' +
-    Math.random().toString(36).substr(2, 9)
-  );
-};
-
-/**
- * 根据ID移除消息
- * @param {string} msg_id 消息ID
- * @private
- */
-Socket.prototype._delMsgById = function (msg_id) {
-  var o = this.dict_msg[msg_id];
-  if (!o) {
-    return;
-  }
-  // 清除定时器
-  if (o.timer) {
-    clearTimeout(o.timer);
-  }
-  delete this.dict_msg[msg_id];
-
-  // 从数组中移除 (保持list_msg与dict_msg同步)
-  for (var i = 0; i < this.list_msg.length; i++) {
-    if (this.list_msg[i].id === msg_id) {
-      this.list_msg.splice(i, 1);
-      break;
-    }
-  }
-};
-
-/**
- * 处理消息回复
- * @param {object} msg 回复消息
- * @private
- */
-Socket.prototype._handleResponse = function (msg) {
-  if (!msg || !msg.id) {
-    return;
-  }
-
-  var o = this.dict_msg[msg.id];
-  if (o && o.func) {
-    try {
-      // 执行回调函数
-      o.func(msg);
-    } catch (error) {
-      console.error('Socket回调函数执行错误:', error);
-    }
-
-    // 从列表中移除已处理的消息
-    this._delMsgById(o.id);
-  }
-};
-
-/**
- * 更新加载插件
- * @param {string} path 检索路径
- */
-Socket.prototype.updateConfigAll = async function (path) {
-  var p = path || './app/';
-  // 获取所有应用路径
-  var list_scope = $.dir.getAll(p, 'socket');
-
-  // 遍历目录路径
-  for (var i = 0, f; (f = list_scope[i++]);) {
-    var list_file = $.file.getAll(f, '*' + this.type + '.json');
-    await this.loadList(list_file);
-  }
-};
-
-exports.Socket = Socket;
-
-/**
- * Socket组件池
- */
-if (!$.pool.socket) {
-  $.pool.socket = {};
-}
-
-/**
- * Socket管理器，用于创建缓存
- * @param {string} scope 作用域
- * @param {string} title 标题
- * @returns {object} 返回一个缓存类
- */
-function socketAdmin(scope, title) {
-  var sc = scope || $.val.scope + '';
-  var obj = $.pool.socket[sc];
-  if (!obj) {
-    $.pool.socket[sc] = new Socket({
-      name: sc,
-      title: title,
-    });
-    obj = $.pool.socket[sc];
-  }
-  return obj;
-}
-
-/**
- * @module 导出Socket管理器
- */
-if ($.admin) {
-  $.admin.socket = socketAdmin;
-}

package/com/socket/script.tpl.js

@@ -1,41 +0,0 @@
-/**
- * 主函数, 用于处理未定义函数的消息
- * @param {object} body 正文参数
- * @param {object} ws Websocket服务
- * @param {object} request 请求协议头
- * @returns {object} 返回执行结果
- */
-exports.main = async function(body, ws, request) {
-  this.log('debug', '收到客户端推送数据', body);
-};
-
-/**
- * 同步消息, 用于定时给前端推送数据
- * @param {object} ws websocket通讯器
- */
-exports.sync = async function(ws) {
-  ws.send([]);
-};
-
-/**
- * 初始化函数, 用于定义开放给前端的函数
- */
-exports.init = async function() {
-  var m = this.methods;
-
-  /**
-   * 获取所有方法
-   * @returns {Array} 返回所有方法名数组
-   */
-  m.getMethods = function() {
-    return Object.keys(m);
-  };
-
-  /**
-   * 测试方法
-   * @returns {string} 返回测试字符串
-   */
-  m.test = function() {
-    return '你好';
-  };
-};

package/com/sql/README.md

@@ -1,3 +0,0 @@
-## sql框架
-实现了前端传参便捷生成sql语句，通过sql模板和前端所传参数，合并成sql语句对数据库进行增、删、改、查，
-快速的构建了前后端于数据库通讯的通道。

package/com/sql/com.json

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

package/com/sql/config.tpl.json

@@ -1,74 +0,0 @@
-{
-	// SQL模板名称
-	"name": "${name}",
-	// SQL模板标题
-	"title": "${title || 'sql模板'}",
-	// 状态，1表示启用，0表示禁用
-	"state": 1,
-	// 调用的数据表
-	"table": "${table || 'user_account'}",
-	// 表主键，用于getObj查询时
-	"key": "${key || 'user_id'}",
-	// 排序方式，{0}表示支持前端传值来排序，传值方式例如：orderby=user_id
-	"orderby": "{0}",
-	// 默认排序方式，当前端没有传值的情况下，采用默认传值方式
-	"orderby_default": "${orderby_default || 'user_id desc'}",
-	// 查询列表时返回的字段，{0}表示支持前端传值
-	"field": "{0}",
-	// 查询对象时返回的字段
-	"field_obj": "${field_obj || '*'}",
-	// 默认返回字段
-	"field_default": "${field_default || 'username,phone'}",
-	// 需要过滤的字段，*代表泛匹配 前面*表示以xxx结尾，后面*表示以xxx开头，前后*表示包含xxx的过滤
-	"field_hide": ["*password*", "*token*", "*apikey*"],
-	// 传值分隔符，如果允许多个值，可以通过这个来分割，如果不允许传多个值则设置为空
-	"separator": "|",
-	// 关键词，用于过滤掉这些值不会写到查询条件中，同时用来识别传的参数
-	"keyword": {
-		// 数据表名，当"table":"{0}", 允许识别表明
-		"table": "table",
-		// 排序方式
-		"orderby": "orderby",
-		// 查询的字段
-		"field": "field",
-		// 页码
-		"page": "page",
-		// 页面大小
-		"size": "size",
-		// 总计，返回查询结果总数
-		"count": "count",
-		// 调用方式
-		"method": "method"
-	},
-	// 调用方式 add增 del删 set改 get查 get_obj查一条 import导入 export导出, 支持什么方式就传什么值，支持多个用空格分隔
-	"method": "add del set get get_obj import export del_repeat sum count update",
-	// 查询条件转换
-	"query": {
-		// 当username=xx时，转为`username` like '%xxx%'的SQL语法
-		"username": "`username` like '%{0}%'"
-	},
-	// 修改时的查询条件
-	"where": {
-		// 当修改查询条件出现user_id=xx时，转为`user_id` = 'xxx'的SQL语法
-		"user_id": "`user_id` = '{0}'"
-	},
-	// 修改时值转换
-	"update": {
-		// 当修改的正文中出现username是转换为指定格式
-		"username": "`username` = '{0}'"
-	},
-	// 默认查询条件
-	"query_default": {
-		
-	},
-	// 默认添加项
-	"body_default": {
-		
-	},
-	// SQL执行脚本，当设置js文件名后, 执行该SQL还将调用这个脚本
-	"main": "",
-	// 导入导出格式，转换导入、导出Eexcel时字段名和字段值
-	"format": [],
-	// 去重条件，需要查重、并去重的字段在这里写
-	"del_repeat": {}
-}