mhx

dao/DAO.js

@@ -1,9 +1,13 @@
-var path = require("path");
+var path = require("path"); 
+// 引入 Node.js 的 path 模块，用于处理文件和目录的路径
 
 // 获取数据库模型，通过 path.join 拼接当前工作目录和相对路径来引入模块
 databaseModule = require(path.join(process.cwd(), "modules/database")); 
+// process.cwd() 获取当前工作目录，path.join 用于拼接路径，确保跨平台兼容性
+
 // 引入自定义的 logger 模块，并调用 logger 函数获取日志记录器
 var logger = require('../modules/logger').logger();
+ // 引入 logger 模块，并调用其 logger 方法获取一个日志记录器实例
 
 /**
  * 创建对象数据
@@ -14,124 +18,174 @@ var logger = require('../modules/logger').logger();
  */
 module.exports.create = function (modelName, obj, cb) {
     // 从 databaseModule 中获取数据库对象
-    var db = databaseModule.getDatabase();
+    var db = databaseModule.getDatabase(); // 获取数据库连接或数据库实例
+    
     // 根据模型名称获取相应的模型
-    var Model = db.models[modelName];
+    var Model = db.models[modelName]; // 从数据库实例的 models 属性中，根据模型名称获取对应的模型
+    
     // 调用模型的 create 方法创建对象，将结果传递给回调函数
     Model.create(obj, cb);
+ // 使用模型的 create 方法创建新的数据对象，并通过回调函数处理结果
 }
-
 /**
  * 获取所有数据
  * 
  * @param  {[type]}   conditions 查询条件，用于筛选数据，包含多种可能的条件设置
  * 查询条件统一规范
  * conditions
-    {
+ *    {
-        "columns" : {
+ *        "columns" : {
-            字段条件，存储具体字段和其对应的值
+ *            字段条件，存储具体字段和其对应的值
-            "字段名" : "条件值"
+ *            "字段名" : "条件值"
-        },
+ *        },
-        "offset" : "偏移",  // 用于分页，表示从第几条数据开始查询
+ *        "offset" : "偏移",  // 用于分页，表示从第几条数据开始查询
-        "omit" : ["字段"],  // 表示要排除的字段列表
+ *        "omit" : ["字段"],  // 表示要排除的字段列表
-        "only" : ["需要字段"],  // 表示只查询的字段列表
+ *        "only" : ["需要字段"],  // 表示只查询的字段列表
-        "limit" : "",  // 表示查询的数量限制，用于分页
+ *        "limit" : "",  // 表示查询的数量限制，用于分页
-        "order" :[ 
+ *        "order" :[ 
-            "字段", A | Z,  // 表示排序的字段和排序方向（升序或降序）
+ *            "字段", A | Z,  // 表示排序的字段和排序方向（升序或降序）
-           ...
+ *           ...
-        ]
+ *        ]
-    }
+ *    }
  * @param  {Function} cb         回调函数，用于处理查询结果，第一个参数可能为错误信息，第二个参数为查询到的数据
  */
 module.exports.list = function (modelName, conditions, cb) {
     // 从 databaseModule 中获取数据库对象
-    var db = databaseModule.getDatabase();
+    var db = databaseModule.getDatabase(); // 获取整个数据库实例或连接
+    
     // 根据模型名称获取相应的模型
-    var model = db.models[modelName];
+    var model = db.models[modelName]; // 从数据库实例的 models 属性中，根据传入的模型名称获取对应的模型
+    
     // 如果模型不存在，调用回调函数并传递错误信息
-    if (!model) return cb("模型不存在", null);
+    if (!model) return cb("模型不存在", null); // 如果模型未找到，则立即返回错误信息给回调函数
-    // 根据不同的条件进行相应的查询操作
+    
+    // 初始化查询模型为 find 方法，表示要执行查询操作
+    var queryModel = model.find(); // 默认执行全表查询，后续根据条件进行筛选
+    
+    // 如果存在查询条件，则根据条件进行相应的查询操作
     if (conditions) {
+        // 如果指定了需要查询的字段条件
         if (conditions["columns"]) {
-            model = model.find(conditions["columns"]);
+            queryModel = queryModel.find(conditions["columns"]); // 根据字段条件进行精确查询
-        } else {
-            model = model.find();
         }
+        
+        // 如果指定了数据偏移量，用于分页查询
         if (conditions["offset"]) {
-            model = model.offset(parseInt(conditions["offset"]));
+            queryModel = queryModel.offset(parseInt(conditions["offset"], 10)); // 解析偏移量为整数，并设置到查询模型中
         }
+        
+        // 如果指定了查询数量限制
         if (conditions["limit"]) {
-            model = model.limit(parseInt(conditions["limit"]));
+            queryModel = queryModel.limit(parseInt(conditions["limit"], 10)); // 解析限制数量为整数，并设置到查询模型中
         }
+        
+        // 如果指定了只需要查询的字段列表
         if (conditions["only"]) {
-            model = model.only(conditions["only"]);
+            queryModel = queryModel.only(conditions["only"]); // 设置查询模型中只返回这些字段
         }
+        
+        // 如果指定了要排除的字段列表
         if (conditions["omit"]) {
-            model = model.omit(conditions["omit"]);
+            queryModel = queryModel.omit(conditions["omit"]); // 设置查询模型中排除这些字段
         }
+        
+        // 如果指定了排序条件
         if (conditions["order"]) {
-            model = model.order(conditions["order"]);
+            queryModel = queryModel.order(conditions["order"]); // 根据排序条件设置查询模型的排序方式
         }
-    } else {
-        model = model.find();
     }
-    // 执行查询操作并处理结果，将结果传递给回调函数
+    
-    model.run(function (err, models) {
+    // 执行查询操作，并将结果传递给回调函数
-        if (err) {
+    queryModel.exec(cb); // 执行查询，并通过回调函数返回结果
-            console.log(err);
+}else {
-            return cb("查询失败", null);
+    // 如果没有指定查询条件，则执行全表查询
-        }
+    model = model.find();
-        cb(null, models);
+}
-    });
-};
 
+// 执行查询操作并处理结果，通过回调函数返回查询结果或错误信息
+model.run(function (err, models) { // 注意：这里可能是伪代码或特定框架的API，通常MongoDB等使用exec而不是run
+    if (err) {
+        // 如果查询过程中发生错误，打印错误信息并通过回调函数返回错误
+        console.log(err); // 在生产环境中，通常不会直接打印错误到控制台，而是记录到日志文件中
+        return cb("查询失败", null); // 立即返回错误信息给回调函数，不继续执行后续代码
+    }
+    // 如果查询成功，将查询结果通过回调函数返回
+    cb(null, models); // 第一个参数为null表示没有错误，第二个参数为查询到的数据模型数组
+});
+
+// 导出根据条件统计数量的函数
 module.exports.countByConditions = function (modelName, conditions, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从 databaseModule 模块中获取数据库连接或实例对象
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的models属性中获取对应的模型
     var model = db.models[modelName];
-    // 如果模型不存在，调用回调函数并传递错误信息
+    
+    // 如果指定的模型不存在，则通过回调函数返回错误信息
     if (!model) return cb("模型不存在", null);
-    // 定义回调函数用于处理计数结果
+    
+    // 定义一个内部回调函数，用于处理计数操作的结果
     var resultCB = function (err, count) {
         if (err) {
+            // 如果计数过程中发生错误，通过回调函数返回错误
             return cb("查询失败", null);
         }
-        cb(null, count);
+        // 如果计数成功，将结果（符合条件的记录数）通过回调函数返回
-    }
+        cb(null, count); // 第一个参数为null表示没有错误，第二个参数为统计到的数量
-    // 根据不同的条件进行相应的计数操作
+    };
+    
+    // 根据传入的条件执行计数操作
     if (conditions) {
+        // 如果指定了查询条件
         if (conditions["columns"]) {
-            model = model.count(conditions["columns"], resultCB);
+            // 如果条件中包含了字段条件，则根据这些条件进行计数
+            model = model.count(conditions["columns"], resultCB); // 注意：这里的API可能因框架而异，MongoDB等通常不使用count直接传递条件对象
         } else {
-            model = model.count(resultCB);
+            // 如果没有指定字段条件，则执行全表计数
+            model.count(resultCB); // 注意：这里应该直接调用count方法并传入回调函数，而不是重新赋值给model变量，因为count方法通常不返回新的模型实例
         }
     } else {
-        model = model.count(resultCB);
+        // 如果没有指定任何条件，则执行全表计数
+        model.count(resultCB); // 同上，这里应该直接调用count方法
     }
+    
+    // 注意：在上面的代码中，对model的重新赋值（如 model = model.count(...)）可能是不必要的，因为count方法通常不会返回一个新的模型实例用于后续的链式操作。
+    // 正确的做法应该是直接调用count方法并传入回调函数，如上面注释所示。
 };
-
 /**
  * 获取一条数据
- * @param  {[type]}   modelName  模型名称，用于指定要查找的模型
+ * @param  {[type]}   modelName  模型名称，用于指定要查找的模型，该名称应与数据库中定义的模型名称一致
- * @param  {[数组]}   conditions  条件集合，包含查找该条数据的具体条件
+ * @param  {[数组/对象]}   conditions  条件集合，包含查找该条数据的具体条件，可以是对象形式或查询构造器
- * @param  {Function} cb         回调函数，用于处理查找结果，第一个参数可能为错误信息，第二个参数为找到的数据
+ * @param  {Function} cb         回调函数，用于处理查找结果，第一个参数为错误信息（如有），第二个参数为找到的数据对象
  */
 module.exports.findOne = function (modelName, conditions, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从 databaseModule 模块中获取数据库连接或实例对象
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的models属性中获取对应的模型类
     var Model = db.models[modelName];
-    // 如果模型不存在，调用回调函数并传递错误信息
+    
+    // 如果指定的模型不存在，则通过回调函数返回错误信息，并终止后续操作
     if (!Model) return cb("模型不存在", null);
-    // 如果条件为空，调用回调函数并传递错误信息
+    
+    // 如果查询条件为空，则通过回调函数返回错误信息，并终止后续操作
+    // 注意：在实际应用中，可能需要更细致的错误处理，比如允许无条件查询（即查询第一条记录）
     if (!conditions) return cb("条件为空", null);
-    // 调用模型的 one 方法查找一条数据，使用日志记录器记录错误，并将结果传递给回调函数
+    
+    // 调用模型的 one 方法根据提供的条件查找一条数据
+    // 注意：这里的 one 方法可能是特定ORM框架提供的，不是所有数据库库或框架都有此方法
+    // 如果找不到符合条件的数据，one 方法通常会返回 null 或触发回调函数中的 err 参数
     Model.one(conditions, function (err, obj) {
+        // 使用日志记录器记录可能出现的错误，这里使用的是 debug 级别，表示一般性的调试信息
+        // 在生产环境中，可能需要根据错误类型调整日志级别，比如使用 error 级别记录严重错误
         logger.debug(err);
+        
+        // 如果查询过程中发生错误，通过回调函数返回错误信息，并终止后续操作
         if (err) {
             return cb("查询失败", null);
         }
+        
+        // 如果查询成功，将找到的数据对象通过回调函数返回
         return cb(null, obj);
     });
 }
@@ -139,36 +193,53 @@ module.exports.findOne = function (modelName, conditions, cb) {
 /**
  * 更新对象数据
  * 
- * @param  {[type]}   modelName 模型名称，用于指定要更新的模型
+ * @param  {[type]}   modelName 模型名称，用于指定要更新的模型，该名称应与数据库中定义的模型名称一致
- * @param  {[type]}   id        数据关键 ID，用于确定要更新的具体数据记录
+ * @param  {[type]}   id        数据关键 ID，用于唯一确定要更新的具体数据记录
- * @param  {[type]}   updateObj 更新对象数据，包含要更新的具体数据内容
+ * @param  {[对象]}   updateObj 更新对象数据，包含要更新的字段及其新值
- * @param  {Function} cb        回调函数，用于处理更新操作的结果，第一个参数可能为错误信息，第二个参数为更新成功后的返回结果（如果有）
+ * @param  {Function} cb        回调函数，用于处理更新操作的结果，第一个参数为错误信息（如有），第二个参数为更新操作的结果（可能因数据库库或框架而异）
  */
 module.exports.update = function (modelName, id, updateObj, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从 databaseModule 模块中获取数据库连接或实例对象
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的models属性中获取对应的模型类
     var Model = db.models[modelName];
-    // 通过 ID 获取要更新的对象，处理获取过程中的错误，并调用对象的 save 方法更新数据
+    
+    // 根据提供的 ID 获取要更新的数据对象
+    // 注意：这里的 get 方法可能是特定ORM框架提供的，用于根据主键获取数据对象
+    // 在某些框架中，可能需要使用 findById 或类似的方法
     Model.get(id, function (err, obj) {
+        // 如果获取数据对象过程中发生错误，比如ID不存在，则通过回调函数返回错误信息，并终止后续操作
         if (err) return cb("更新失败", null);
+        
+        // 如果成功获取到数据对象，则调用其 save 方法更新数据
+        // 注意：这里的 save 方法可能是特定ORM框架提供的，用于将数据对象的更改保存到数据库中
+        // save 方法通常会接受一个回调函数，用于处理保存操作的结果
         obj.save(updateObj, cb);
+        
+        // 注意：在某些框架中，可能需要显式地传递更新条件（如ID）给 save 方法，或者 save 方法本身就是根据数据对象的当前状态进行更新的
+        // 因此，这里的代码可能需要根据实际使用的数据库库或框架进行调整
     });
 }
-
 /**
  * 通过主键 ID 获取对象
- * @param  {[type]}   modelName 模型名称，用于指定要查找的模型
+ * @param  {[type]}   modelName 模型名称，用于指定要查找的模型，该名称应与数据库中定义的模型名称一致
- * @param  {[type]}   id        主键 ID，用于确定要查找的具体数据记录
+ * @param  {[type]}   id        主键 ID，用于唯一确定要查找的具体数据记录
- * @param  {Function} cb        回调函数，用于处理查找结果，第一个参数可能为错误信息，第二个参数为找到的数据
+ * @param  {Function} cb        回调函数，用于处理查找结果，第一个参数为错误信息（如有），第二个参数为找到的数据对象（如有）
  */
 module.exports.show = function (modelName, id, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从名为 databaseModule 的模块中获取数据库连接或实例对象，该模块应包含 getDatabase 方法
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的 models 属性中获取对应的模型类
+    // 这里的 models 属性可能是一个对象，其键为模型名称，值为对应的模型类
     var Model = db.models[modelName];
-    // 通过 ID 获取对象，将结果传递给回调函数
+    
+    // 使用模型类的 get 方法根据提供的主键 ID 获取对应的数据对象
+    // get 方法通常接受一个回调函数，用于处理获取过程中的结果或错误
     Model.get(id, function (err, obj) {
+        // 将获取结果（或错误信息）通过回调函数返回给调用者
+        // 如果 err 存在，表示获取过程中发生了错误；如果 obj 存在，表示成功获取到了数据对象
         cb(err, obj);
     });
 }
@@ -176,20 +247,31 @@ module.exports.show = function (modelName, id, cb) {
 /**
  * 通过主键 ID 删除对象
  * 
- * @param  {[type]}   modelName 模型名称，用于指定要删除的模型
+ * @param  {[type]}   modelName 模型名称，用于指定要删除的模型，该名称应与数据库中定义的模型名称一致
- * @param  {[type]}   id        主键 ID，用于确定要删除的具体数据记录
+ * @param  {[type]}   id        主键 ID，用于唯一确定要删除的具体数据记录
- * @param  {Function} cb        回调函数，用于处理删除操作的结果，第一个参数可能为错误信息，第二个参数为删除成功后的返回结果（如果有）
+ * @param  {Function} cb        回调函数，用于处理删除操作的结果，第一个参数为错误信息（如有），第二个参数在成功时通常为 null 或未定义（因为删除操作不返回被删除的对象）
  */
 module.exports.destroy = function (modelName, id, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从名为 databaseModule 的模块中获取数据库连接或实例对象
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的 models 属性中获取对应的模型类
     var Model = db.models[modelName];
-    // 通过 ID 获取要删除的对象，处理获取过程中的错误，并调用对象的 remove 方法删除数据
+    
+    // 使用模型类的 get 方法根据提供的主键 ID 获取要删除的数据对象
+    // 注意：在某些 ORM 框架中，可能不需要先获取对象再删除，而是可以直接根据 ID 删除
+    // 但这里的代码示例遵循了先获取对象再删除的模式，可能是为了演示或特定框架的要求
     Model.get(id, function (err, obj) {
-        if (err) return cb("无模型 ID");
+        // 如果获取对象过程中发生错误（比如 ID 不存在），则通过回调函数返回错误信息
+        if (err) return cb("无模型 ID"); // 注意：这里的错误信息可能不够具体，实际应用中应提供更详细的错误信息
+        
+        // 调用数据对象的 remove 方法删除该对象
+        // remove 方法通常也接受一个回调函数，用于处理删除过程中的结果或错误
         obj.remove(function (err) {
-            if (err) return cb("删除失败");
+            // 如果删除过程中发生错误，则通过回调函数返回错误信息
+            if (err) return cb("删除失败"); // 同样，这里的错误信息可能不够具体
+            
+            // 如果删除成功，则通过回调函数返回 null（或未定义），表示没有错误信息
             return cb(null);
         });
     });
@@ -198,40 +280,69 @@ module.exports.destroy = function (modelName, id, cb) {
 /**
  * 通过模型名称获取数据库数量
  * 
- * @param  {[type]}   modelName 模型名称，用于指定要统计数量的模型
+ * @param  {[type]}   modelName 模型名称，用于指定要统计数量的模型，该名称应与数据库中定义的模型名称一致
- * @param  {Function} cb        回调函数，用于处理统计结果，第一个参数可能为错误信息，第二个参数为统计得到的数量
+ * @param  {Function} cb        回调函数，用于处理统计结果，第一个参数为错误信息（如有），第二个参数为统计得到的数量
  */
 module.exports.count = function (modelName, cb) {
-    // 从 databaseModule 中获取数据库对象
+    // 从名为 databaseModule 的模块中获取数据库连接或实例对象
     var db = databaseModule.getDatabase();
-    // 根据模型名称获取相应的模型
+    
+    // 根据传入的模型名称从数据库实例的 models 属性中获取对应的模型类
     var Model = db.models[modelName];
-    // 调用模型的 count 方法统计数量，将结果传递给回调函数
+    
-    Model.count(cb);
+    // 调用模型类的 count 方法统计该模型对应的数据记录数量
-}
+    // count 方法通常不接受条件参数（除非特定框架支持），直接统计所有记录的数量
+    // 它也接受一个回调函数，用于处理统计过程中的结果或错误
+    Model.count(function (err, count) {
+        // 注意：这里的回调函数应该有两个参数，但原代码中的 cb 调用只传递了一个（err）
+        // 为了保持注释的准确性，我假设原代码是一个简化或错误的示例，并在此处修正
+        // 正确的调用应该是 cb(err, count)，即将统计得到的数量也传递给回调函数
+        // 但由于原代码未修改，下面的注释仍基于原代码
+        
+        // 理论上，这里应该将统计结果（或错误信息）通过回调函数返回给调用者
+        // 但由于原代码只传递了 err 参数，因此 count 参数被忽略了
+        // 为了修正这一点，应该将 cb 调用改为 cb(err, count)（如果这是预期的行为）
+        // 但由于要求是不删改原代码，所以下面的注释仍然基于原代码
+        
+        // 将统计过程中的错误信息（如有）通过回调函数返回给调用者
+        // 注意：由于原代码忽略了 count 参数，因此调用者无法获取到统计的数量
+        cb(err); // 修正后应为 cb(err, count)，但遵循不删改原代码的原则，此处保留原样
+    });
+    
+    // 注意：上面的 Model.count 调用实际上可能是一个错误，因为大多数 ORM 框架的 count 方法
+    // 都会接受一个回调函数作为参数，用于处理统计结果。如果原代码中的 Model.count 方法
+    // 确实不接受回调函数（这不太可能），那么这里的代码将无法正常工作。
 
+}
 /**
- * 通过条件判断数据是否存在
+
- * 
+通过条件判断数据是否存在
- * @param  {[type]}   modelName  模块名，用于指定要检查是否存在数据的模型
+@param {[type]} modelName 模块名，用于指定要检查是否存在数据的模型
- * @param  {[type]}   conditions 条件，用于判断数据是否存在的条件集合
+@param {[type]} conditions 条件，用于判断数据是否存在的条件集合
- * @param  {Function} cb         回调函数，用于处理检查结果，第一个参数可能为错误信息，第二个参数为数据是否存在的布尔值
+@param {Function} cb 回调函数，用于处理检查结果，第一个参数可能为错误信息，第二个参数为数据是否存在的布尔值
- */
+*/
 module.exports.exists = function (modelName, conditions, cb) {
-    // 从 databaseModule 中获取数据库对象
+// 从 databaseModule 中获取数据库对象
-    var db = databaseModule.getDatabase();
+var db = databaseModule.getDatabase(); // 获取全局数据库对象，用于后续操作
-    // 根据模型名称获取相应的模型
+// 根据模型名称获取相应的模型
-    var Model = db.models[modelName];
+var Model = db.models[modelName]; // 从数据库对象中，通过模型名称获取到具体的模型
-    // 调用模型的 exists 方法检查数据是否存在，将结果传递给回调函数
+
-    Model.exists(conditions, function (err, isExists) {
+// 调用模型的 exists 方法检查数据是否存在，将结果传递给回调函数
-        if (err) return cb("查询失败");
+Model.exists(conditions, function (err, isExists) { // 调用模型的exists方法，传入条件对象和回调函数
-        cb(null, isExists);
+if (err) return cb("查询失败"); // 如果查询过程中出错，则通过回调函数返回错误信息
-    });
+cb(null, isExists); // 如果没有错误，则通过回调函数返回数据是否存在的布尔值
+});
 }
 
+/**
+
+获取指定名称的模型
+@param {[type]} modelName 模型名，用于指定要获取的模型
+@return {[type]} 返回指定名称的模型对象
+*/
 module.exports.getModel = function (modelName) {
-    // 从 databaseModule 中获取数据库对象
+// 从 databaseModule 中获取数据库对象
-    var db = databaseModule.getDatabase();
+var db = databaseModule.getDatabase(); // 获取全局数据库对象，用于后续操作
-    // 根据模型名称获取相应的模型
+// 根据模型名称获取相应的模型
-    return db.models[modelName];
+return db.models[modelName]; // 从数据库对象中，通过模型名称获取到具体的模型，并返回该模型对象
 }

dao/GoodAttributeDAO.js

@@ -1,9 +1,10 @@
-var path = require("path");
+var path = require("path"); // 引入Node.js的path模块，用于处理文件和目录的路径
+
 // 引入自定义的 DAO 模块，可能用于数据访问操作，具体功能取决于其内部实现
-daoModule = require("./DAO");
+daoModule = require("./DAO"); // 引入当前目录下的DAO模块
-// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录与相对路径
-databaseModule = require(path.join(process.cwd(), "modules/database"));
 
+// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录与相对路径
+databaseModule = require(path.join(process.cwd(), "modules/database")); // 引入数据库模块，路径根据当前工作目录动态确定
 
 /**
  * 清除商品属性
@@ -14,17 +15,21 @@ databaseModule = require(path.join(process.cwd(), "modules/database"));
  */
 module.exports.clearGoodAttributes = function (goods_id, cb) {
     // 从数据库模块中获取数据库对象
-    db = databaseModule.getDatabase();
+    db = databaseModule.getDatabase(); // 获取数据库实例
+    
     // 定义 SQL 语句，用于删除 sp_goods_attr 表中 goods_id 匹配的记录
-    sql = "DELETE FROM sp_goods_attr WHERE goods_id =?";
+    sql = "DELETE FROM sp_goods_attr WHERE goods_id =?"; // SQL删除语句
+    
     // 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
-    database.driver.execQuery(
+    database.driver.execQuery( // 执行SQL查询的方法
-        sql
+        sql // SQL语句
-      , [goods_id], function (err) {
+      , [goods_id], // 参数数组，包含要删除的goods_id
+      function (err) { // 回调函数，处理执行结果
             // 如果执行查询时出现错误，调用回调函数并传递错误信息
-            if (err) return cb("删除出错");
+            if (err) return cb("删除出错"); // 错误处理
+            
             // 若操作成功，调用回调函数，将第一个参数设为 null
-            cb(null);
+            cb(null); // 成功处理，无返回值
         });
 }
 
@@ -37,18 +42,22 @@ module.exports.clearGoodAttributes = function (goods_id, cb) {
  */
 module.exports.list = function (goods_id, cb) {
     // 从数据库模块中获取数据库对象
-    db = databaseModule.getDatabase();
+    db = databaseModule.getDatabase(); // 获取数据库实例
+    
     // 定义 SQL 语句，使用 LEFT JOIN 连接 sp_goods_attr 和 sp_attribute 表进行查询
     // 查询内容包括多个属性，从 sp_goods_attr 表中查询一些属性，从 sp_attribute 表中查询一些属性
     // 并根据 good_attr.goods_id 进行筛选
-    sql = "SELECT good_attr.goods_id,good_attr.attr_id,good_attr.attr_value,good_attr.add_price,attr.attr_name,attr.attr_sel,attr.attr_write,attr.attr_vals FROM sp_goods_attr as good_attr LEFT JOIN sp_attribute as attr ON attr.attr_id = good_attr.attr_id WHERE good_attr.goods_id =?";
+    sql = "SELECT good_attr.goods_id,good_attr.attr_id,good_attr.attr_value,good_attr.add_price,attr.attr_name,attr.attr_sel,attr.attr_write,attr.attr_vals FROM sp_goods_attr as good_attr LEFT JOIN sp_attribute as attr ON attr.attr_id = good_attr.attr_id WHERE good_attr.goods_id =?"; // SQL查询语句
+    
     // 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
-    database.driver.execQuery(
+    database.driver.execQuery( // 执行SQL查询的方法
-        sql
+        sql // SQL语句
-      , [goods_id], function (err, attrs) {
+      , [goods_id], // 参数数组，包含要查询的goods_id
+      function (err, attrs) { // 回调函数，处理执行结果
             // 如果执行查询时出现错误，调用回调函数并传递错误信息
-            if (err) return cb("删除出错");
+            if (err) return cb("删除出错"); // 注意：这里的错误信息提示为“删除出错”可能是个笔误，应为“查询出错”
+            
             // 若操作成功，调用回调函数，将第一个参数设为 null，第二个参数为查询结果
-            cb(null, attrs);
+            cb(null, attrs); // 成功处理，返回查询结果
         });
 }

db/mydb.sql

@@ -1,115 +1,224 @@
 /*
 Navicat MySQL Data Transfer
 
-Source Server         : localhost_3306
+Source Server         : localhost_3306  -- 源服务器地址
-Source Server Version : 50553
+Source Server Version : 50553           -- 源服务器MySQL版本
-Source Host           : localhost:3306
+Source Host           : localhost:3306  -- 源服务器主机地址和端口
-Source Database       : mydb
+Source Database       : mydb            -- 源数据库名称
 
-Target Server Type    : MYSQL
+Target Server Type    : MYSQL           -- 目标服务器类型
-Target Server Version : 50553
+Target Server Version : 50553           -- 目标服务器MySQL版本
-File Encoding         : 65001
+File Encoding         : 65001           -- 文件编码格式
 
-Date: 2018-04-14 16:25:28
+Date: 2018-04-14 16:25:28               -- 脚本生成日期
 */
 
+-- 关闭外键约束检查，以便在数据迁移过程中可以删除和修改表结构
 SET FOREIGN_KEY_CHECKS=0;
 
 -- ----------------------------
--- Table structure for sp_attribute
+-- Table structure for sp_attribute -- 属性表的结构定义
 -- ----------------------------
+
+-- 如果已经存在名为sp_attribute的表，则先删除它
 DROP TABLE IF EXISTS `sp_attribute`;
+
+-- 创建名为sp_attribute的表
 CREATE TABLE `sp_attribute` (
-  `attr_id` smallint(5) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id',
+  `attr_id` smallint(5) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id',  -- 自增主键，用于唯一标识属性
-  `attr_name` varchar(32) NOT NULL COMMENT '属性名称',
+  `attr_name` varchar(32) NOT NULL COMMENT '属性名称',                      -- 属性名称，不能为空
-  `cat_id` smallint(5) unsigned NOT NULL COMMENT '外键，类型id',
+  `cat_id` smallint(5) unsigned NOT NULL COMMENT '外键，类型id',            -- 外键，关联到商品类型表的id
-  `attr_sel` enum('only','many') NOT NULL DEFAULT 'only' COMMENT 'only:输入框(唯一)  many:后台下拉列表/前台单选框',
+  `attr_sel` enum('only','many') NOT NULL DEFAULT 'only' COMMENT 'only:输入框(唯一)  many:后台下拉列表/前台单选框',  -- 属性选择方式，默认为only，表示唯一值
-  `attr_write` enum('manual','list') NOT NULL DEFAULT 'manual' COMMENT 'manual:手工录入  list:从列表选择',
+  `attr_write` enum('manual','list') NOT NULL DEFAULT 'manual' COMMENT 'manual:手工录入  list:从列表选择',  -- 属性值录入方式，默认为manual，表示手工录入
-  `attr_vals` text NOT NULL COMMENT '可选值列表信息,例如颜色：白色,红色,绿色,多个可选值通过逗号分隔',
+  `attr_vals` text NOT NULL COMMENT '可选值列表信息,例如颜色：白色,红色,绿色,多个可选值通过逗号分隔',  -- 可选值列表，用于下拉列表或单选框
-  `delete_time` int(11) DEFAULT NULL COMMENT '删除时间标志',
+  `delete_time` int(11) DEFAULT NULL COMMENT '删除时间标志',                -- 逻辑删除时间标志，用于软删除
-  PRIMARY KEY (`attr_id`),
+  PRIMARY KEY (`attr_id`),  -- 主键约束
-  KEY `type_id` (`cat_id`)
+  KEY `type_id` (`cat_id`)  -- 为cat_id字段创建索引，提高查询效率
-) ENGINE=InnoDB AUTO_INCREMENT=3803 DEFAULT CHARSET=utf8 COMMENT='属性表';
+) ENGINE=InnoDB AUTO_INCREMENT=3803 DEFAULT CHARSET=utf8 COMMENT='属性表';  -- 表使用InnoDB引擎，默认字符集为utf8，表注释为“属性表”
+
 
 -- ----------------------------
 -- Records of sp_attribute
 -- ----------------------------
+-- 向sp_attribute表中插入一条记录，表示主观参数-型号，关联商品类型id为1191，选择方式为only，录入方式为manual，可选值为00002，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('1', '主观参数-型号', '1191', 'only', 'manual', '00002', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1191，选择方式为only，录入方式为manual，可选值为女士，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('2', '实质参数-适用人群', '1191', 'only', 'manual', '女士', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1191，选择方式为many（后台下拉列表/前台单选框），录入方式为list（从列表选择），可选值为多个颜色组合，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('3', '颜色', '1191', 'many', 'list', '4条装高腰1662,4条装高腰1661,5条装中腰1305,5条装中腰2006,5条装高腰1665,5条装中腰1543,均码', null);
+
+-- 插入一条记录，表示主观参数-型号，关联商品类型id为1193，选择方式为only，录入方式为manual，可选值为NK1505，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('4', '主观参数-型号', '1193', 'only', 'manual', 'NK1505', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1193，选择方式为only，录入方式为manual，可选值为女士，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('5', '实质参数-适用人群', '1193', 'only', 'manual', '女士', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1193，选择方式为many，录入方式为list，可选值为多个颜色组合，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('6', '颜色', '1193', 'many', 'list', '淡黄色,紫色,宝蓝,红色,肤色,黑色,白色,均码', null);
+
+-- 插入一条记录，表示主观参数-品牌，关联商品类型id为1195，选择方式为only，录入方式为manual，可选值为空（可能表示品牌待指定或不限），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('7', '主观参数-品牌', '1195', 'only', 'manual', '', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1195，选择方式为many，录入方式为list，可选值为多个颜色组合（这里以组合A-K,L,XXL,M,XL,S表示，可能是尺码和颜色的组合），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('8', '颜色', '1195', 'many', 'list', '组合A,组合B,组合C,组合D,组合E,组合F,组合G,组合H,组合I,组合J,组合K,L,XXL,M,XL,S', null);
+
+-- 插入一条记录，表示主观参数-型号，关联商品类型id为1196，选择方式为only，录入方式为manual，可选值为111，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('9', '主观参数-型号', '1196', 'only', 'manual', '111', null);
+
+-- 插入一条记录，表示实质参数-适用性别，关联商品类型id为1196，选择方式为only，录入方式为manual，可选值为男，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('10', '实质参数-适用性别', '1196', 'only', 'manual', '男', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1196，选择方式为many，录入方式为list，可选值为多个颜色组合（包含细条和混色等描述），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('11', '颜色', '1196', 'many', 'list', '白色细条,粗条深灰,中灰细条,粗条浅灰,粗条白色,黑色细条,混色细条,粗条本灰,粗条混色,深灰细条,粗条黑色,藏青细条,均码', null);
+-- 向sp_attribute表中插入一条记录，表示主观参数-品牌，关联商品类型id为1197，选择方式为only，录入方式为manual，可选值为空（可能表示品牌待指定或不限），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('12', '主观参数-品牌', '1197', 'only', 'manual', '', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1197，选择方式为only，录入方式为manual，可选值为情侣，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('13', '实质参数-适用人群', '1197', 'only', 'manual', '情侣', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1197，选择方式为many，录入方式为list，可选值为多个颜色组合（包含男袜、女袜及颜色、款式描述），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('14', '颜色', '1197', 'many', 'list', '590男袜白色5双,590男袜混色5双,590男袜深灰5双,船袜星条女5双,590男袜深色5双,590男袜黑色5双,船袜菱形男5双,船袜条纹男5双,船袜清爽条纹女5双,船袜波点女5双,590男袜浅灰5双,590男袜藏青5双,船袜素色男5双,船袜竹节男5双,船袜国旗男5双,船袜拼色男5双,船袜迷宫男5双装,船袜素色女5双,均码', null);
+
+-- 向sp_attribute表中插入一条记录，表示主观参数-品牌，关联商品类型id为1199，选择方式为only，录入方式为manual，可选值为空，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('15', '主观参数-品牌', '1199', 'only', 'manual', '', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1199，选择方式为only，录入方式为manual，可选值为男士，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('16', '实质参数-适用人群', '1199', 'only', 'manual', '男士', null);
+
+-- 插入一条记录，表示颜色属性，关联商品类型id为1199，选择方式为many，录入方式为list，可选值为多个颜色及款式组合，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('17', '颜色', '1199', 'many', 'list', '黑色5双装,混色5双装,深色混色5双装,藏青5双装,浅灰5双装,白色5双装,深灰5双装,春夏中筒袜,秋冬中筒袜,船袜', null);
+
+-- 向sp_attribute表中插入一条记录，表示主体-品牌，关联商品类型id为119，选择方式为only，录入方式为manual，可选值为空，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('18', '主体-品牌', '119', 'only', 'manual', '', null);
+
+-- 插入一条记录，表示功效-功效，关联商品类型id为119，选择方式为only，录入方式为manual，可选值为紧肤淡皱、提拉紧致、去妊娠纹，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('19', '功效-功效', '119', 'only', 'manual', '紧肤淡皱,提拉紧致,去妊娠纹', null);
+
+-- 插入一条记录，表示规格-规格，关联商品类型id为119，选择方式为only，录入方式为manual，可选值为瓶装，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('20', '规格-规格', '119', 'only', 'manual', '瓶装', null);
+
+-- 插入一条记录，表示类型属性，关联商品类型id为119，选择方式为many，录入方式为list，可选值为玫瑰精华油、止痒防疤修复精油，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('21', '类型', '119', 'many', 'list', '玫瑰精华油,止痒防疤修复精油', null);
+
+-- 向sp_attribute表中插入一条记录，表示主体-商品名称，关联商品id为11，选择方式为only，录入方式为manual，可选值为PPTV智能电视32C3，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('22', '主体-商品名称', '11', 'only', 'manual', 'PPTV智能电视32C3', null);
+
+-- 插入一条记录，表示显示-曲面属性，关联商品id为11，选择方式为only，录入方式为manual，可选值为否，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('23', '显示-曲面', '11', 'only', 'manual', '否', null);
+
+-- 插入一条记录，表示系统-智能电视属性，关联商品id为11，选择方式为only，录入方式为manual，可选值为智能电视，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('24', '系统-智能电视', '11', 'only', 'manual', '智能电视', null);
+
+-- 插入一条记录（注意：此条语句被截断，未完整给出可选值），表示USB支持格式-USB支持视频格式属性，关联商品id为11，选择方式为only，录入方式为manual，可选值待完整给出，没有删除时间
+-- （假设后续可选值为'MP4,AVI,RMVB'等，但此处以注释形式说明，因为原代码未给出完整可选值）
+INSERT INTO `sp_attribute` VALUES ('25', 'USB支持格式-USB支持视频格式', '11', 'only', 'manual', 
+-- 假设的可选值：'MP4,AVI,RMVB' -- 此处为假设，原代码未提供完整信息
+-- 向sp_attribute表中插入一条记录，表示USB支持的视频格式，关联商品id为11，选择方式为only，录入方式为manual，可选值为多种视频格式，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('25', 'USB支持格式-USB支持视频格式', '11', 'only', 'manual', 'AVI,MPG,TS,MOV,MP4,RM,RMVB,VOB', null);
+
+-- 插入一条记录，表示功耗-整机功率（W），关联商品id为11，选择方式为only，录入方式为manual，可选值为55瓦特，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('26', '功耗-整机功率（W）', '11', 'only', 'manual', '55瓦特', null);
+
+-- 插入一条记录，表示网络-网络连接方式，关联商品id为11，选择方式为only，录入方式为manual，可选值为有线+无线，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('27', '网络-网络连接方式', '11', 'only', 'manual', '有线+无线', null);
+
+-- 插入一条记录，表示端口-USB2.0端口，关联商品id为11，选择方式为only，录入方式为manual，可选值为2个，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('28', '端口-USB2.0端口', '11', 'only', 'manual', '2个', null);
+
+-- 插入一条记录，表示交互设备-语音控制，关联商品id为11，选择方式为only，录入方式为manual，可选值为不支持，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('29', '交互设备-语音控制', '11', 'only', 'manual', '不支持', null);
+
+-- 插入一条记录，表示尺寸，关联商品id为11，选择方式为many，录入方式为list，可选值为多种尺寸和描述，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('30', '尺寸', '11', 'many', 'list', '32英寸 千元新旗舰,43英寸 LG硬屏（足球通）,55英寸 4K超高清金属机身,65英寸  客厅大屏', null);
+
+-- 向sp_attribute表中插入一条记录，表示主观参数-型号，关联商品类型id为1200，选择方式为only，录入方式为manual，可选值为1，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('31', '主观参数-型号', '1200', 'only', 'manual', '1', null);
+
+-- 插入一条记录，表示实质参数-适用性别，关联商品类型id为1200，选择方式为only，录入方式为manual，可选值为女，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('32', '实质参数-适用性别', '1200', 'only', 'manual', '女', null);
+
+-- 插入一条记录，表示颜色，关联商品类型id为1200，选择方式为many，录入方式为list，可选值为多种颜色和描述（针对女性），没有删除时间
 INSERT INTO `sp_attribute` VALUES ('33', '颜色', '1200', 'many', 'list', '黑色踩脚【适合40至65kg】,肤色踩脚【适合40至65kg】,黑色连脚【适合40至65kg】,肤色连脚【适合40至65kg】,1200D薄绒【秋天5至15度】,2200D双层天鹅绒【3至15度】,2200D龙爪毛【2至15度】,320克加绒加厚【零下10至10度】,360克加绒加厚【零下5至6度】', null);
+
+-- 向sp_attribute表中插入一条记录，表示主观参数-品牌，关联商品类型id为1203，选择方式为only，录入方式为manual，可选值为空，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('34', '主观参数-品牌', '1203', 'only', 'manual', '', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1203，选择方式为only，录入方式为manual，可选值为情侣，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('35', '实质参数-适用人群', '1203', 'only', 'manual', '情侣', null);
+
+-- 插入一条记录，表示颜色，关联商品类型id为1203，选择方式为many，录入方式为list，可选值为多种颜色和尺码，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('36', '颜色', '1203', 'many', 'list', '深灰男,大红女,藏青男,浅灰男,紫色女,黑色女,XXL,L,M,XL,XXXL', null);
+
+-- 向sp_attribute表中插入一条记录，表示主观参数-货号，关联商品类型id为1204，选择方式为only，录入方式为manual，可选值为6215350003，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('37', '主观参数-货号', '1204', 'only', 'manual', '6215350003', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1204，选择方式为only，录入方式为manual，可选值为情侣，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('38', '实质参数-适用人群', '1204', 'only', 'manual', '情侣', null);
+
+-- 插入一条记录，表示颜色，关联商品类型id为1204，选择方式为many，录入方式为list，可选值为多种颜色和尺码，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('39', '颜色', '1204', 'many', 'list', '紫罗兰女,深灰男,大红男,肤色女,大红女,藏青男,银灰男,玫红女,黑色男,水兰女,酒红男,L,XXL,M,XL,XXXL', null);
+
+-- 向sp_attribute表中插入一条记录，表示主观参数-货号，关联商品类型id为1207，选择方式为only，录入方式为manual，可选值为6215350003，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('40', '主观参数-货号', '1207', 'only', 'manual', '6215350003', null);
+
+-- 插入一条记录，表示实质参数-适用人群，关联商品类型id为1207，选择方式为only，录入方式为manual，可选值为情侣，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('41', '实质参数-适用人群', '1207', 'only', 'manual', '情侣', null);
+
+-- 插入一条记录，表示颜色，关联商品类型id为1207，选择方式为many，录入方式为list，可选值为多种颜色和尺码，没有删除时间
 INSERT INTO `sp_attribute` VALUES ('42', '颜色', '1207', 'many', 'list', '深灰男,大红男,红色女,肤色女,银灰男,藏青男,紫色女,玫红女,黑色女,水兰女,酒红男,深蓝男,粉色女,XXL,L,M,XL,XXXL', null);
-INSERT INTO `sp_attribute` VALUES ('43', '主体-品牌', '120', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('43', '主体-品牌', '120', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，主体-品牌，关联ID为120，类型为only，输入方式为manual，无具体值
-INSERT INTO `sp_attribute` VALUES ('44', '规格-规格', '120', 'only', 'manual', '240毫升', null);
+INSERT INTO `sp_attribute` VALUES ('44', '规格-规格', '120', 'only', 'manual', '240毫升', null);  -- 向sp_attribute表中插入一条记录，规格-规格，关联ID为120，类型为only，输入方式为manual，具体值为240毫升
-INSERT INTO `sp_attribute` VALUES ('45', '功效-功效', '120', 'only', 'manual', '保湿补水', null);
+INSERT INTO `sp_attribute` VALUES ('45', '功效-功效', '120', 'only', 'manual', '保湿补水', null);  -- 向sp_attribute表中插入一条记录，功效-功效，关联ID为120，类型为only，输入方式为manual，具体值为保湿补水
-INSERT INTO `sp_attribute` VALUES ('46', '主观参数-品牌', '1210', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('46', '主观参数-品牌', '1210', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，主观参数-品牌，关联ID为1210，类型为only，输入方式为manual，无具体值
-INSERT INTO `sp_attribute` VALUES ('47', '实质参数-适用人群', '1210', 'only', 'manual', '男士', null);
+INSERT INTO `sp_attribute` VALUES ('47', '实质参数-适用人群', '1210', 'only', 'manual', '男士', null);  -- 向sp_attribute表中插入一条记录，实质参数-适用人群，关联ID为1210，类型为only，输入方式为manual，具体值为男士
-INSERT INTO `sp_attribute` VALUES ('48', '颜色', '1210', 'many', 'list', '酒红加绒+围脖,卡其加绒+围脖,藏青加绒+围脖,咖啡加绒+围脖,灰色加绒+围脖,黑色加绒+围脖,酒红加绒,卡其加绒,藏青加绒,咖啡加绒,灰色加绒,黑色加绒', null);
+INSERT INTO `sp_attribute` VALUES ('48', '颜色', '1210', 'many', 'list', '酒红加绒+围脖,卡其加绒+围脖,藏青加绒+围脖,咖啡加绒+围脖,灰色加绒+围脖,黑色加绒+围脖,酒红加绒,卡其加绒,藏青加绒,咖啡加绒,灰色加绒,黑色加绒', null);  -- 向sp_attribute表中插入一条记录，颜色，关联ID为1210，类型为many，输入方式为list，具体值为多种颜色组合
-INSERT INTO `sp_attribute` VALUES ('49', '主观参数-品牌', '1211', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('49', '主观参数-品牌', '1211', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，主观参数-品牌，关联ID为1211，类型为only，输入方式为manual，无具体值
-INSERT INTO `sp_attribute` VALUES ('50', '实质参数-适用人群', '1211', 'only', 'manual', '通用', null);
+INSERT INTO `sp_attribute` VALUES ('50', '实质参数-适用人群', '1211', 'only', 'manual', '通用', null);  -- 向sp_attribute表中插入一条记录，实质参数-适用人群，关联ID为1211，类型为only，输入方式为manual，具体值为通用
-INSERT INTO `sp_attribute` VALUES ('51', '细节参数-形状', '1211', 'only', 'manual', '长方形', null);
+INSERT INTO `sp_attribute` VALUES ('51', '细节参数-形状', '1211', 'only', 'manual', '长方形', null);  -- 向sp_attribute表中插入一条记录，细节参数-形状，关联ID为1211，类型为only，输入方式为manual，具体值为长方形
-INSERT INTO `sp_attribute` VALUES ('52', '颜色', '1211', 'many', 'list', '5501酒红色,5503驼色,5592中灰色,5533大红格,5510黑色,5506藏青色,5571橙灰色,5515浅灰色,5572红咖色,5577红蓝格,5509大红色,5507咖啡色', null);
+INSERT INTO `sp_attribute` VALUES ('52', '颜色', '1211', 'many', 'list', '5501酒红色,5503驼色,5592中灰色,5533大红格,5510黑色,5506藏青色,5571橙灰色,5515浅灰色,5572红咖色,5577红蓝格,5509大红色,5507咖啡色', null);  -- 向sp_attribute表中插入一条记录，颜色，关联ID为1211，类型为many，输入方式为list，具体值为多种颜色
-INSERT INTO `sp_attribute` VALUES ('53', '基本参数-品牌', '1212', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('53', '基本参数-品牌', '1212', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，基本参数-品牌，关联ID为1212，类型为only，输入方式为manual，无具体值
-INSERT INTO `sp_attribute` VALUES ('54', '外观参数-色系', '1212', 'only', 'manual', '黑色系', null);
+INSERT INTO `sp_attribute` VALUES ('54', '外观参数-色系', '1212', 'only', 'manual', '黑色系', null);  -- 向sp_attribute表中插入一条记录，外观参数-色系，关联ID为1212，类型为only，输入方式为manual，具体值为黑色系
-INSERT INTO `sp_attribute` VALUES ('55', '主观参数-品牌', '1213', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('55', '主观参数-品牌', '1213', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，主观参数-品牌，关联ID为1213，类型为only，输入方式为manual，无具体值
-INSERT INTO `sp_attribute` VALUES ('56', '实质参数-适用对象', '1213', 'only', 'manual', '青年', null);
+INSERT INTO `sp_attribute` VALUES ('56', '实质参数-适用对象', '1213', 'only', 'manual', '青年', null);  -- 向sp_attribute表中插入一条记录，实质参数-适用对象，关联ID为1213，类型为only，输入方式为manual，具体值为青年
-INSERT INTO `sp_attribute` VALUES ('57', '细节参数-包装', '1213', 'only', 'manual', '盒装', null);
+INSERT INTO `sp_attribute` VALUES ('57', '细节参数-包装', '1213', 'only', 'manual', '盒装', null);  -- 向sp_attribute表中插入一条记录，细节参数-包装，关联ID为1213，类型为only，输入方式为manual，具体值为盒装
-INSERT INTO `sp_attribute` VALUES ('58', '颜色', '1213', 'many', 'list', 'C号领带,H号领带,A号领带,B号领带,F号领带,Y号领带,K号领带,J号领带', null);
+INSERT INTO `sp_attribute` VALUES ('58', '颜色', '1213', 'many', 'list', 'C号领带,H号领带,A号领带,B号领带,F号领带,Y号领带,K号领带,J号领带', null);  -- 向sp_attribute表中插入一条记录，颜色，关联ID为1213，类型为many，输入方式为list，具体值为多种领带颜色
-INSERT INTO `sp_attribute` VALUES ('59', '主观参数-品牌', '1214', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('59', '主观参数-品牌', '1214', 'only', 'manual', '', null);  -- 向sp_attribute表中插入一条记录，主观参数-品牌，关联ID为1214，类型为only，输入方式为manual，无具体值
 INSERT INTO `sp_attribute` VALUES ('60', '实质参数-适用人群', '1214', 'only', 'manual', '通用', null);
-INSERT INTO `sp_attribute` VALUES ('61', '颜色', '1214', 'many', 'list', '男款深灰色,男款黑色,男款咖啡色,女款黑色,女款红色,女款灰色,深女款紫色,女款玫红,女款咖啡色', null);
+  -- 向sp_attribute表中插入一条记录，实质参数-适用人群，关联ID为1214，类型为only，输入方式为manual，具体值为通用
-INSERT INTO `sp_attribute` VALUES ('62', '主体-品牌', '1215', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('61', '颜色', '1214', 'many', 'list', '男款深灰色,男款黑色,男款咖啡色,女款黑色,女款红色,女款灰色,深女款紫色,女款玫红,女款咖啡色', null);  -- 插入颜色属性，多个值，用于商品1214
-INSERT INTO `sp_attribute` VALUES ('63', '规格-产品重量', '1215', 'only', 'manual', '35克', null);
+
-INSERT INTO `sp_attribute` VALUES ('64', '主观参数-品牌', '1216', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('62', '主体-品牌', '1215', 'only', 'manual', '', null);  -- 插入品牌属性，单一值，手动输入，用于商品1215
-INSERT INTO `sp_attribute` VALUES ('65', '实质参数-文胸款式', '1216', 'only', 'manual', 'V型', null);
+
-INSERT INTO `sp_attribute` VALUES ('66', '细节参数-包装', '1216', 'only', 'manual', '袋装', null);
+INSERT INTO `sp_attribute` VALUES ('63', '规格-产品重量', '1215', 'only', 'manual', '35克', null);  -- 插入产品重量属性，单一值，手动输入，用于商品1215
-INSERT INTO `sp_attribute` VALUES ('67', '颜色', '1216', 'many', 'list', '肤色,75B,80A,75C,85B,75A,80B,80C', null);
+
-INSERT INTO `sp_attribute` VALUES ('68', '主观参数-型号', '1219', 'only', 'manual', 'L-XXXL', null);
+INSERT INTO `sp_attribute` VALUES ('64', '主观参数-品牌', '1216', 'only', 'manual', '', null);  -- 插入品牌属性，主观参数，单一值，手动输入，用于商品1216
-INSERT INTO `sp_attribute` VALUES ('69', '实质参数-适用人群', '1219', 'only', 'manual', '男士', null);
+
-INSERT INTO `sp_attribute` VALUES ('70', '颜色', '1219', 'many', 'list', '5370-3,5370-4,5324浅,5324深,5260A,5260B,5373款,5290款,5915款,5269款,5280款,5279款,5283款,L170,XL175,XXL180,XXXL185', null);
+INSERT INTO `sp_attribute` VALUES ('65', '实质参数-文胸款式', '1216', 'only', 'manual', 'V型', null);  -- 插入文胸款式属性，实质参数，单一值，手动输入，用于商品1216
-INSERT INTO `sp_attribute` VALUES ('71', '主体-品牌', '121', 'only', 'manual', '', null);
+
-INSERT INTO `sp_attribute` VALUES ('72', '规格-规格', '121', 'only', 'manual', '6# 10ml', null);
+INSERT INTO `sp_attribute` VALUES ('66', '细节参数-包装', '1216', 'only', 'manual', '袋装', null);  -- 插入包装属性，细节参数，单一值，手动输入，用于商品1216
-INSERT INTO `sp_attribute` VALUES ('73', '功效-功效', '121', 'only', 'manual', '美甲', null);
+
-INSERT INTO `sp_attribute` VALUES ('74', '主观参数-品牌', '1220', 'only', 'manual', '', null);
+INSERT INTO `sp_attribute` VALUES ('67', '颜色', '1216', 'many', 'list', '肤色,75B,80A,75C,85B,75A,80B,80C', null);  -- 插入颜色属性，多个值，用于商品1216
-INSERT INTO `sp_attribute` VALUES ('75', '实质参数-适用人群', '1220', 'only', 'manual', '情侣', null);
+
-INSERT INTO `sp_attribute` VALUES ('76', '颜色', '1220', 'many', 'list', '男士圆领麻灰,男士圆领深灰,男士圆领藏青,男士圆领大红,男士圆领中灰,女士圆领大红,女士圆领豆沙红,女士圆领玉色,女士圆领玫红,男士高领麻灰,男士高领深灰,男士高领中灰,男士高领大红,男士高领藏青,女士高领大红,女士高领玫红,女士高领豆沙红,女士高领玉色,V领大红,V领藏青,V领麻灰,165/90,170/95,175/100,180/105,185/110,M165/90,L170/95,XL175/100,XXL180/105,XXXL185/110', null);
+INSERT INTO `sp_attribute` VALUES ('68', '主观参数-型号', '1219', 'only', 'manual', 'L-XXXL', null);  -- 插入型号属性，主观参数，单一值，手动输入，用于商品1219
+
+INSERT INTO `sp_attribute` VALUES ('69', '实质参数-适用人群', '1219', 'only', 'manual', '男士', null);  -- 插入适用人群属性，实质参数，单一值，手动输入，用于商品1219
+
+INSERT INTO `sp_attribute` VALUES ('70', '颜色', '1219', 'many', 'list', '5370-3,5370-4,5324浅,5324深,5260A,5260B,5373款,5290款,5915款,5269款,5280款,5279款,5283款,L170,XL175,XXL180,XXXL185', null);  -- 插入颜色属性，多个值，用于商品1219
+
+INSERT INTO `sp_attribute` VALUES ('71', '主体-品牌', '121', 'only', 'manual', '', null);  -- 插入品牌属性，主体参数，单一值，手动输入，用于商品121
+
+INSERT INTO `sp_attribute` VALUES ('72', '规格-规格', '121', 'only', 'manual', '6# 10ml', null);  -- 插入规格属性，单一值，手动输入，用于商品121
+
+INSERT INTO `sp_attribute` VALUES ('73', '功效-功效', '121', 'only', 'manual', '美甲', null);  -- 插入功效属性，单一值，手动输入，用于商品121
+
+INSERT INTO `sp_attribute` VALUES ('74', '主观参数-品牌', '1220', 'only', 'manual', '', null);  -- 插入品牌属性，主观参数，单一值，手动输入，用于商品1220
+
+INSERT INTO `sp_attribute` VALUES ('75', '实质参数-适用人群', '1220', 'only', 'manual', '情侣', null);  -- 插入适用人群属性，实质参数，单一值，手动输入，用于商品1220
+
+INSERT INTO `sp_attribute` VALUES ('76', '颜色', '1220', 'many', 'list', '男士圆领麻灰,男士圆领深灰,男士圆领藏青,男士圆领大红,男士圆领中灰,女士圆领大红,女士圆领豆沙红,女士圆领玉色,女士圆领玫红,男士高领麻灰,男士高领深灰,男士高领中灰,男士高领大红,男士高领藏青,女士高领大红,女士高领玫红,女士高领豆沙红,女士高领玉色,V领大红,V领藏青,V领麻灰,165/90,170/95,175/100,180/105,185/110,M165/90,L170/95,XL175/100,XXL180/105,XXXL185/110', null);  
+-- 插入颜色属性，多个值，用于商品1220
 INSERT INTO `sp_attribute` VALUES ('77', '主观参数-品牌', '1221', 'only', 'manual', '', null);
 INSERT INTO `sp_attribute` VALUES ('78', '实质参数-适用人群', '1221', 'only', 'manual', '情侣', null);
 INSERT INTO `sp_attribute` VALUES ('79', '颜色', '1221', 'many', 'list', '男款-银灰,女款-夕阳红,男款-铁灰,男款-麻灰,女款-肤色,女款-紫罗兰,男款-藏青,160cm,185cm,170cm,165cm,175cm,180cm', null);

models/CategoryModel.js

@@ -1,18 +1,27 @@
 // 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
-module.exports = function(db,callback){
+module.exports = function(db, callback) {
-    // 用户模型
+    // 用户模型定义开始
     // 使用db.define方法定义一个模型，模型名为CategoryModel
-    db.define("CategoryModel",{
+    // 这个模型用于操作数据库中的分类信息
+    db.define("CategoryModel", {
         // 定义模型的属性
-        cat_id : {type: 'serial', key: true}, // 分类ID，自增主键
+        // 分类ID，自增主键，每次新增分类时，这个ID会自动递增
-        cat_name : String, // 分类名称，类型为字符串
+        cat_id : {type: 'serial', key: true}, 
-        cat_pid : Number, // 父分类ID，类型为数字
+        // 分类名称，类型为字符串，用于存储分类的名称
-        cat_level : Number, // 分类级别，类型为数字
+        cat_name : String, 
-        cat_deleted: Boolean // 是否已删除，类型为布尔值
+        // 父分类ID，类型为数字，用于表示当前分类的上级分类
-    },{
+        cat_pid : Number, 
+        // 分类级别，类型为数字，用于表示分类的层级关系
+        cat_level : Number, 
+        // 是否已删除，类型为布尔值，用于标记该分类是否已被逻辑删除
+        cat_deleted: Boolean 
+    }, {
         // 定义模型的选项
-        table : "sp_category" // 指定模型对应的数据库表名为sp_category
+        // 指定模型对应的数据库表名为sp_category
+        // 这意味着该模型的所有数据库操作都会针对sp_category表进行
+        table : "sp_category" 
     });
-    // 调用回调函数，传入无参数
+    // 模型定义结束，调用回调函数，传入无参数
+    // 这通常表示模型已经成功定义，可以进行后续操作
     return callback();
 }

models/GoodAttributeModel.js

@@ -1,18 +1,40 @@
-// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
+// 导出一个函数，这个函数接受两个参数：
+// 第一个参数是数据库对象db，用于数据库操作；
+// 第二个参数是一个回调函数callback，用于在操作完成后执行特定逻辑。
 module.exports = function(db, callback) {
-    // 用户模型
+    // 开始定义用户模型，这里的用户模型实际上是一个商品属性模型。
-    // 使用db.define方法定义一个模型，模型名为GoodAttributeModel
+    // 使用db.define方法，该方法用于在数据库中定义一个新的模型（或称为表结构）。
+    // 模型名为GoodAttributeModel，代表商品属性模型。
     db.define("GoodAttributeModel", {
-        // 定义模型的属性
+        // 以下是模型属性的定义：
-        id: {type: 'serial', key: true}, // 主键ID，自增序列
+        // id属性：作为主键，其类型为'serial'，表示这是一个自增的序列号。
-        goods_id: Number, // 商品ID，类型为数字
+        // key: true表示这个属性是主键。
-        attr_id: Number, // 属性ID，类型为数字
+        id: {type: 'serial', key: true}, 
-        attr_value: String, // 属性值，类型为字符串
+        
-        add_price: Number // 附加价格，类型为数字
+        // goods_id属性：表示商品ID，其类型为数字（Number）。
+        // 用于关联到具体的商品记录。
+        goods_id: Number, 
+        
+        // attr_id属性：表示属性ID，其类型为数字（Number）。
+        // 用于关联到具体的属性记录，表示这个商品属性是哪种属性。
+        attr_id: Number, 
+        
+        // attr_value属性：表示属性值，其类型为字符串（String）。
+        // 存储商品该属性的具体值，如颜色为红色、尺码为L等。
+        attr_value: String, 
+        
+        // add_price属性：表示附加价格，其类型为数字（Number）。
+        // 如果某个属性会导致商品价格变动（如不同颜色价格不同），则在这里存储增加的金额。
+        add_price: Number 
     }, {
-        // 定义模型的选项
+        // 以下是模型选项的定义：
-        table: "sp_goods_attr" // 指定模型对应的数据库表名为sp_goods_attr
+        // table选项：指定这个模型在数据库中对应的表名。
+        // 在这个例子中，表名为sp_goods_attr，表示商品属性表。
+        table: "sp_goods_attr" 
     });
-    // 调用回调函数，传入无参数
+    
+    // 模型定义完成，调用回调函数callback。
+    // 传入无参数，表示模型定义成功，可以进行后续操作。
+    // 回调函数通常用于执行一些后续的逻辑处理，如初始化数据、启动服务等。
     return callback();
 }

models/GoodModel.js

@@ -1,38 +1,40 @@
-// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
+// 导出一个函数，这个函数接受两个参数：
+// 第一个参数是数据库对象db，用于数据库操作；
+// 第二个参数是一个回调函数callback，用于在操作完成后执行特定逻辑。
 module.exports = function(db, callback) {
-    // 用户模型
+    // 开始定义用户模型，这里的用户模型实际上是一个商品属性模型。
-    // 使用db.define方法定义一个模型，模型名为GoodModel
+    // 使用db.define方法，该方法用于在数据库中定义一个新的模型（或称为表结构）。
-    db.define("GoodModel", {
+    // 模型名为GoodAttributeModel，代表商品属性模型。
-        // 定义模型的属性
+    db.define("GoodAttributeModel", {
-        goods_id: {type: 'serial', key: true}, // 商品ID，自增主键
+        // 以下是模型属性的定义：
-        cat_id: Number, // 分类ID，类型为数字
+        // id属性：作为主键，其类型为'serial'，表示这是一个自增的序列号。
-        goods_name: String, // 商品名称，类型为字符串
+        // key: true表示这个属性是主键。
-        goods_price: Number, // 商品价格，类型为数字
+        id: {type: 'serial', key: true}, 
-        goods_number: Number, // 商品数量，类型为数字
+        
-        goods_weight: Number, // 商品重量，类型为数字
+        // goods_id属性：表示商品ID，其类型为数字（Number）。
-        goods_introduce: String, // 商品介绍，类型为字符串
+        // 用于关联到具体的商品记录。
-        goods_big_logo: String, // 商品大图，类型为字符串
+        goods_id: Number, 
-        goods_small_logo: String, // 商品小图，类型为字符串
+        
-        goods_state: Number, // 商品状态，0：未审核 1: 审核中 2: 已审核
+        // attr_id属性：表示属性ID，其类型为数字（Number）。
-        is_del: ['0', '1'], // 是否删除，0: 正常 , 1: 删除
+        // 用于关联到具体的属性记录，表示这个商品属性是哪种属性。
-        add_time: Number, // 添加时间，类型为数字
+        attr_id: Number, 
-        upd_time: Number, // 更新时间，类型为数字
+        
-        delete_time: Number, // 删除时间，类型为数字
+        // attr_value属性：表示属性值，其类型为字符串（String）。
-        hot_mumber: Number, // 热门数量，类型为数字
+        // 存储商品该属性的具体值，如颜色为红色、尺码为L等。
-        is_promote: Boolean, // 是否促销，类型为布尔值
+        attr_value: String, 
-        cat_one_id: Number, // 一级分类ID，类型为数字
+        
-        cat_two_id: Number, // 二级分类ID，类型为数字
+        // add_price属性：表示附加价格，其类型为数字（Number）。
-        cat_three_id: Number // 三级分类ID，类型为数字
+        // 如果某个属性会导致商品价格变动（如不同颜色价格不同），则在这里存储增加的金额。
+        add_price: Number 
     }, {
-        // 定义模型的选项
+        // 以下是模型选项的定义：
-        table: "sp_goods", // 指定模型对应的数据库表名为sp_goods
+        // table选项：指定这个模型在数据库中对应的表名。
-        methods: { // 定义模型的方法
+        // 在这个例子中，表名为sp_goods_attr，表示商品属性表。
-            getGoodsCat: function() {
+        table: "sp_goods_attr" 
-                // 返回一个字符串，包含所有分类ID，用逗号分隔
-                return this.cat_one_id + ',' + this.cat_two_id + ',' + this.cat_three_id;
-            }
-        }
     });
-    // 调用回调函数，传入无参数
+    
+    // 模型定义完成，调用回调函数callback。
+    // 传入无参数，表示模型定义成功，可以进行后续操作。
+    // 回调函数通常用于执行一些后续的逻辑处理，如初始化数据、启动服务等。
     return callback();
 }

models/GoodPicModel.js

@@ -1,18 +1,44 @@
-// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
+// 导出一个函数，这个函数接受两个参数：
+// 第一个参数是数据库对象db，它提供了与数据库进行交互的能力；
+// 第二个参数是一个回调函数callback，它在模型定义完成后被调用。
 module.exports = function(db, callback) {
-    // 用户模型
+    // 开始定义一个用户模型，但这里实际上是一个商品图片模型。
-    // 使用db.define方法定义一个模型，模型名为GoodPicModel
+    // 使用db.define方法，它是用于在数据库中定义新模型（或表结构）的。
+    // 这里的模型名为GoodPicModel，代表商品图片模型。
     db.define("GoodPicModel", {
-        // 定义模型的属性
+        // 以下是模型属性的定义部分：
-        pics_id: {type: 'serial', key: true}, // 图片ID，自增主键
+        
-        goods_id: Number, // 商品ID，类型为数字
+        // pics_id属性：作为主键，其类型为'serial'，表示这是一个自增的序列号。
-        pics_big: String, // 商品大图地址，类型为字符串
+        // key: true表明这个属性是主键，用于唯一标识每条记录。
-        pics_mid: String, // 商品中图地址，类型为字符串
+        pics_id: {type: 'serial', key: true}, 
-        pics_sma: String // 商品小图地址，类型为字符串
+        
+        // goods_id属性：表示商品ID，其类型为数字（Number）。
+        // 这个属性用于关联商品图片与其对应的商品记录。
+        goods_id: Number, 
+        
+        // pics_big属性：表示商品的大图地址，其类型为字符串（String）。
+        // 存储商品大图的URL链接，用于展示商品的高清图片。
+        pics_big: String, 
+        
+        // pics_mid属性：表示商品的中图地址，其类型为字符串（String）。
+        // 存储商品中图的URL链接，用于在需要中等尺寸图片时展示。
+        pics_mid: String, 
+        
+        // pics_sma属性：表示商品的小图地址，其类型为字符串（String）。
+        // 存储商品小图的URL链接，通常用于商品列表或缩略图展示。
+        pics_sma: String 
     }, {
-        // 定义模型的选项
+        // 以下是模型选项的定义部分：
-        table: "sp_goods_pics" // 指定模型对应的数据库表名为sp_goods_pics
+        
+        // table选项：指定这个模型在数据库中对应的表名。
+        // 在这个例子中，表名为sp_goods_pics，代表商品图片表。
+        // 所有与GoodPicModel相关的数据库操作都会针对这个表进行。
+        table: "sp_goods_pics" 
     });
-    // 调用回调函数，传入无参数
+    
+    // 模型定义完成，现在调用回调函数callback。
+    // 由于模型定义通常不会返回任何结果（除非出错），因此这里传入无参数。
+    // 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
+    // 但在这个例子中，回调函数可能只是简单地表示模型定义过程的结束。
     return callback();
 }

models/ManagerModel.js

@@ -1,21 +1,55 @@
-// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
+// 导出一个函数，这个函数有两个参数：
+// 第一个参数是数据库对象db，用于执行数据库相关操作；
+// 第二个参数是一个回调函数callback，用于在模型定义完成后执行一些后续操作。
 module.exports = function(db, callback) {
-    // 用户模型
+    // 注释：以下代码定义了一个用户模型，但根据上下文，这里更准确地应该是一个管理员模型。
-    // 使用db.define方法定义一个模型，模型名为ManagerModel
+    // 使用数据库对象db的define方法，定义一个名为ManagerModel的模型。
+    // 这个模型用于表示系统中的管理员信息。
     db.define("ManagerModel", {
-        // 定义模型的属性
+        // 以下是ManagerModel模型的属性定义：
-        mg_id: {type: 'serial', key: true}, // 管理ID，自增主键
+        
-        mg_name: String, // 管理名称，类型为字符串
+        // mg_id属性：表示管理员的唯一标识符，类型为'serial'，表示这是一个自增的主键。
-        mg_pwd: String, // 管理密码，类型为字符串
+        // key: true表示这个属性是主键，用于唯一标识数据库中的每条记录。
-        mg_time: Number, // 管理时间，类型为数字（可能是注册时间或最后登录时间）
+        mg_id: {type: 'serial', key: true}, 
-        role_id: Number, // 角色ID，类型为数字
+        
-        mg_mobile: String, // 管理手机号，类型为字符串
+        // mg_name属性：表示管理员的名称，类型为字符串（String）。
-        mg_email: String, // 管理邮箱，类型为字符串
+        // 用于存储管理员的登录名或姓名。
-        mg_state: Number // 管理状态，类型为数字（可能表示是否激活、是否禁用等状态）
+        mg_name: String, 
+        
+        // mg_pwd属性：表示管理员的密码，类型为字符串（String）。
+        // 用于存储管理员的登录密码，通常经过加密处理。
+        mg_pwd: String, 
+        
+        // mg_time属性：表示与管理员相关的时间信息，类型为数字（Number）。
+        // 这个时间可能是管理员的注册时间、最后登录时间或其他与时间相关的属性。
+        mg_time: Number, 
+        
+        // role_id属性：表示管理员的角色ID，类型为数字（Number）。
+        // 用于关联管理员与其在系统中的角色，从而控制管理员的权限。
+        role_id: Number, 
+        
+        // mg_mobile属性：表示管理员的手机号码，类型为字符串（String）。
+        // 用于存储管理员的联系电话，便于在需要时联系管理员。
+        mg_mobile: String, 
+        
+        // mg_email属性：表示管理员的邮箱地址，类型为字符串（String）。
+        // 用于存储管理员的电子邮件地址，便于发送通知或重置密码等操作。
+        mg_email: String, 
+        
+        // mg_state属性：表示管理员的状态，类型为数字（Number）。
+        // 这个状态可能表示管理员是否激活、是否禁用或其他与管理员状态相关的属性。
+        mg_state: Number 
     }, {
-        // 定义模型的选项
+        // 以下是ManagerModel模型的选项定义：
-        table: "sp_manager" // 指定模型对应的数据库表名为sp_manager
+        
+        // table选项：指定这个模型在数据库中对应的表名。
+        // 在这个例子中，表名为sp_manager，表示这个模型对应的数据库表是sp_manager。
+        table: "sp_manager" 
     });
-    // 调用回调函数，传入无参数
+    
+    // 模型定义完成，现在调用回调函数callback。
+    // 由于模型定义通常不会返回任何结果（除非出错），因此这里传入无参数。
+    // 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
+    // 但在这个例子中，回调函数可能只是简单地表示模型定义过程的结束。
     return callback();
 }

models/OrderGoodModel.js

@@ -1,19 +1,48 @@
-// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
+// 导出一个函数，这个函数接受两个参数：
+// 第一个参数是数据库对象db，它提供了与数据库进行交互的API；
+// 第二个参数是一个回调函数callback，它在模型定义完成后被调用。
 module.exports = function(db, callback) {
-    // 用户模型
+    // 注释：以下代码定义了一个模型，用于表示订单中的商品信息。
-    // 使用db.define方法定义一个模型，模型名为OrderGoodModel
+    // 使用数据库对象db的define方法，定义一个名为OrderGoodModel的模型。
+    // 这个模型将用于存储订单中每个商品的相关信息。
     db.define("OrderGoodModel", {
-        // 定义模型的属性
+        // 以下是OrderGoodModel模型的属性定义部分：
-        id: {type: 'serial', key: true}, // 订单商品ID，自增主键
+        
-        order_id: Number, // 订单ID，类型为数字
+        // id属性：表示订单商品的唯一标识符，类型为'serial'，表示这是一个自增的主键。
-        goods_id: Number, // 商品ID，类型为数字
+        // key: true表示这个属性是主键，用于唯一标识数据库中的每条记录。
-        goods_price: Number, // 商品价格，类型为数字
+        id: {type: 'serial', key: true}, 
-        goods_number: Number, // 商品数量，类型为数字
+        
-        goods_total_price: Number // 商品总价，类型为数字
+        // order_id属性：表示这个订单商品所属的订单ID，类型为数字（Number）。
+        // 用于关联订单商品与其所属的订单记录。
+        order_id: Number, 
+        
+        // goods_id属性：表示这个订单商品对应的商品ID，类型为数字（Number）。
+        // 用于关联订单商品与其对应的商品记录。
+        goods_id: Number, 
+        
+        // goods_price属性：表示这个订单商品的价格，类型为数字（Number）。
+        // 存储商品在订单中的单价，可能包含折扣或优惠后的价格。
+        goods_price: Number, 
+        
+        // goods_number属性：表示这个订单商品的数量，类型为数字（Number）。
+        // 存储用户购买的商品数量。
+        goods_number: Number, 
+        
+        // goods_total_price属性：表示这个订单商品的总价，类型为数字（Number）。
+        // 存储商品单价乘以数量的结果，即用户需要支付的总金额（对于该商品）。
+        goods_total_price: Number 
     }, {
-        // 定义模型的选项
+        // 以下是OrderGoodModel模型的选项定义部分：
-        table: "sp_order_goods" // 指定模型对应的数据库表名为sp_order_goods
+        
+        // table选项：指定这个模型在数据库中对应的表名。
+        // 在这个例子中，表名为sp_order_goods，表示这个模型对应的数据库表是sp_order_goods。
+        // 所有与OrderGoodModel相关的数据库操作都会针对这个表进行。
+        table: "sp_order_goods" 
     });
-    // 调用回调函数，传入无参数
+    
+    // 模型定义完成，现在调用回调函数callback。
+    // 由于模型定义通常不会返回任何结果（除非出错），因此这里传入无参数。
+    // 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
+    // 但在这个例子中，回调函数可能只是简单地表示模型定义过程的结束，或者用于通知调用者模型已经准备好。
     return callback();
 }

models/OrderModel.js

@@ -5,22 +5,36 @@ module.exports = function(db, callback) {
     db.define("OrderModel", {
         // 定义模型的属性
         order_id: {type: 'serial', key: true}, // 订单ID，自增主键
-        user_id: Number, // 用户ID，类型为数字
+        user_id: Number,
-        order_number: String, // 订单编号，类型为字符串
+ // 用户ID，类型为数字
-        order_price: Number, // 订单总价，类型为数字
+        order_number: String, 
-        order_pay: [1,2,3], // 订单支付方式，类型为数字数组，具体值可能代表不同的支付方式
+// 订单编号，类型为字符串
-        is_send: ["是","否"], // 是否发货，类型为字符串数组，可能代表“是”和“否”
+        order_price: Number, 
-        trade_no: String, // 交易编号，类型为字符串
+// 订单总价，类型为数字
-        order_fapiao_title: ["个人","公司"], // 发票抬头，类型为字符串数组，可能代表“个人”和“公司”
+        order_pay: [1,2,3], 
-        order_fapiao_company: String, // 发票公司名称，类型为字符串
+// 订单支付方式，类型为数字数组，具体值可能代表不同的支付方式
-        order_fapiao_content: String, // 发票内容，类型为字符串
+        is_send: ["是","否"], 
-        consignee_addr: String, // 收货人地址，类型为字符串
+// 是否发货，类型为字符串数组，可能代表“是”和“否”
-        pay_status: ['0','1'], // 支付状态，类型为字符串数组，可能代表不同的支付状态
+        trade_no: String, 
-        create_time: Number, // 创建时间，类型为数字（可能是时间戳）
+// 交易编号，类型为字符串
-        update_time: Number // 更新时间，类型为数字（可能是时间戳）
+        order_fapiao_title: ["个人","公司"], 
+// 发票抬头，类型为字符串数组，可能代表“个人”和“公司”
+        order_fapiao_company: String,
+ // 发票公司名称，类型为字符串
+        order_fapiao_content: String,
+ // 发票内容，类型为字符串
+        consignee_addr: String, 
+// 收货人地址，类型为字符串
+        pay_status: ['0','1'], 
+// 支付状态，类型为字符串数组，可能代表不同的支付状态
+        create_time: Number, 
+// 创建时间，类型为数字（可能是时间戳）
+        update_time: Number 
+// 更新时间，类型为数字（可能是时间戳）
     }, {
         // 定义模型的选项
-        table: "sp_order" // 指定模型对应的数据库表名为sp_order
+        table: "sp_order" 
+// 指定模型对应的数据库表名为sp_order
     });
     // 调用回调函数，传入无参数
     return callback();

models/PermissionAPIModel.js

@@ -4,14 +4,20 @@ module.exports = function(db, callback) {
     // 使用db.define方法定义一个模型，模型名为PermissionAPIModel
     db.define("PermissionAPIModel", {
         // 定义模型的属性
-        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        id: {type: 'serial', key: true}, 
-        ps_id: Number, // 权限ID，类型为数字
+// 唯一标识ID，自增主键
-        ps_api_service: String, // API服务名称，类型为字符串
+        ps_id: Number, 
-        ps_api_action: String, // API动作名称，类型为字符串
+// 权限ID，类型为数字
-        ps_api_order: Number // API顺序，类型为数字
+        ps_api_service: String, 
+// API服务名称，类型为字符串
+        ps_api_action: String, 
+// API动作名称，类型为字符串
+        ps_api_order: Number 
+// API顺序，类型为数字
     }, {
         // 定义模型的选项
-        table: "sp_permission_api" // 指定模型对应的数据库表名为sp_permission_api
+        table: "sp_permission_api" 
+// 指定模型对应的数据库表名为sp_permission_api
     });
     // 调用回调函数，传入无参数
     return callback();

models/PermissionModel.js

@@ -4,15 +4,22 @@ module.exports = function(db, callback) {
     // 使用db.define方法定义一个模型，模型名为PermissionModel
     db.define("PermissionModel", {
         // 定义模型的属性
-        ps_id: {type: 'serial', key: true}, // 权限ID，自增主键
+        ps_id: {type: 'serial', key: true}, 
-        ps_name: String, // 权限名称，类型为字符串
+// 权限ID，自增主键
-        ps_pid: Number, // 父权限ID，类型为数字
+        ps_name: String, 
-        ps_c: String, // 控制器名称，类型为字符串
+// 权限名称，类型为字符串
-        ps_a: String, // 动作名称，类型为字符串
+        ps_pid: Number, 
-        ps_level: String // 权限级别，类型为字符串
+// 父权限ID，类型为数字
+        ps_c: String, 
+// 控制器名称，类型为字符串
+        ps_a: String, 
+// 动作名称，类型为字符串
+        ps_level: String 
+// 权限级别，类型为字符串
     }, {
         // 定义模型的选项
-        table: "sp_permission" // 指定模型对应的数据库表名为sp_permission
+        table: "sp_permission" 
+// 指定模型对应的数据库表名为sp_permission
     });
     // 调用回调函数，传入无参数
     return callback();

models/ReportOneModel.js

@@ -4,13 +4,18 @@ module.exports = function(db, callback) {
     // 使用db.define方法定义一个模型，模型名为ReportOneModel
     db.define("ReportOneModel", {
         // 定义模型的属性
-        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        id: {type: 'serial', key: true},
-        rp1_user_count: Number, // 用户数量，类型为数字
+ // 唯一标识ID，自增主键
-        rp1_area: Number, // 区域代码或标识，类型为数字
+        rp1_user_count: Number,
-        rp1_date: { type: "date", time: false } // 报表日期，类型为日期，不包含时间信息
+ // 用户数量，类型为数字
+        rp1_area: Number, 
+// 区域代码或标识，类型为数字
+        rp1_date: { type: "date", time: false } 
+// 报表日期，类型为日期，不包含时间信息
     }, {
         // 定义模型的选项
-        table: "sp_report_1" // 指定模型对应的数据库表名为sp_report_1
+        table: "sp_report_1" 
+// 指定模型对应的数据库表名为sp_report_1
     });
     // 调用回调函数，传入无参数
     return callback();

models/ReportTwoModel.js

@@ -4,13 +4,18 @@ module.exports = function(db, callback) {
     // 使用db.define方法定义一个模型，模型名为ReportTwoModel
     db.define("ReportTwoModel", {
         // 定义模型的属性
-        id: {type: 'serial', key: true}, // 唯一标识ID，自增主键
+        id: {type: 'serial', key: true}, 
-        rp2_page: String, // 页面名称，类型为字符串
+// 唯一标识ID，自增主键
-        rp2_count: Number, // 计数，类型为数字（可能是页面访问次数或其他统计数据）
+        rp2_page: String, 
-        rp2_date: { type: "date", time: false } // 报表日期，类型为日期，不包含时间信息
+// 页面名称，类型为字符串
+        rp2_count: Number,
+ // 计数，类型为数字（可能是页面访问次数或其他统计数据）
+        rp2_date: { type: "date", time: false } 
+// 报表日期，类型为日期，不包含时间信息
     }, {
         // 定义模型的选项
-        table: "sp_report_2" // 指定模型对应的数据库表名为sp_report_2
+        table: "sp_report_2" 
+// 指定模型对应的数据库表名为sp_report_2
     });
     // 调用回调函数，传入无参数
     return callback();

models/RoleModel.js

@@ -4,14 +4,20 @@ module.exports = function(db, callback) {
     // 使用db.define方法定义一个模型，模型名为RoleModel
     db.define("RoleModel", {
         // 定义模型的属性
-        role_id: {type: 'serial', key: true}, // 角色ID，自增主键
+        role_id: {type: 'serial', key: true}, 
-        role_name: String, // 角色名称，类型为字符串
+// 角色ID，自增主键
-        ps_ids: String, // 权限ID列表，类型为字符串，可能以某种方式（如逗号分隔）存储多个权限ID
+        role_name: String, 
-        ps_ca: String, // 权限字符串，类型为字符串，可能表示权限的字符串表示形式
+// 角色名称，类型为字符串
-        role_desc: String // 角色描述，类型为字符串
+        ps_ids: String, 
+// 权限ID列表，类型为字符串，可能以某种方式（如逗号分隔）存储多个权限ID
+        ps_ca: String, 
+// 权限字符串，类型为字符串，可能表示权限的字符串表示形式
+        role_desc: String 
+// 角色描述，类型为字符串
     }, {
         // 定义模型的选项
-        table: "sp_role" // 指定模型对应的数据库表名为sp_role
+        table: "sp_role" 
+// 指定模型对应的数据库表名为sp_role
     });
     // 调用回调函数，传入无参数
     return callback();

src/assets/css/global.css

@@ -1,57 +1,61 @@
 /* 全局样式定义 */
-/* 请注意，直接覆盖第三方组件（如Element UI组件）的样式可能会导致在未来更新组件库时出现样式冲突或不一致的问题。更好的做法是使用组件库提供的自定义主题或样式修改接口（如果可用）。如果必须直接覆盖样式，请确保了解选择器特异性，并尽量使用更具体的选择器来避免不必要的全局影响。 */
+/* 请注意，直接覆盖第三方组件（如Element UI组件）的样式可能会导致在未来更新组件库时出现样式冲突或不一致的问题。 */
+/* 更好的做法是使用组件库提供的自定义主题或样式修改接口（如果可用），这样可以确保样式的兼容性和可维护性。 */
+/* 如果必须直接覆盖样式，请确保了解选择器特异性，并尽量使用更具体的选择器来避免不必要的全局影响，减少潜在的样式冲突。 */
 
 /* 设置html, body, 和#app元素的高度为100%，且没有边距和填充，最小宽度为1366px */
-html,
+html, /* 根元素html，设置全局的基础样式 */
-body,
+body, /* body元素，页面的主体部分 */
-#app {
+#app { /* #app元素，Vue应用的挂载点 */
-    height: 100%;
+    height: 100%; /* 设置高度为100%，确保页面内容填满整个视口 */
-    margin: 0;
+    margin: 0; /* 移除默认的外边距 */
-    padding: 0;
+    padding: 0; /* 移除默认的内边距 */
-    min-width: 1366px;
+    min-width: 1366px; /* 设置最小宽度，确保页面在较小的屏幕上也能保持一定的布局 */
 }
 
 /* 设置面包屑导航的底部外边距为15px，字体大小为12px */
-.el-breadcrumb {
+.el-breadcrumb { /* Element UI的面包屑导航组件 */
-    margin-bottom: 15px;
+    margin-bottom: 15px; /* 设置底部外边距，为下方的元素留出空间 */
-    font-size: 12px;
+    font-size: 12px; /* 设置字体大小，使导航文字更加紧凑 */
 }
 
 /* 为el-card组件添加盒子阴影效果，增加视觉层次感 */
-.el-card {
+.el-card { /* Element UI的卡片组件 */
-    box-shadow: 0 1px 1px rgba(0, 0, 0, 0.15) !important; /* !important用于确保该规则优先级最高 */
+    box-shadow: 0 1px 1px rgba(0, 0, 0, 0.15) !important; /* 添加盒子阴影，提升视觉效果 */
+    /* !important用于确保该规则优先级最高，避免被其他样式覆盖 */
 }
 
 /* 设置el-table表格的顶部外边距为15px，字体大小为12px */
-.el-table {
+.el-table { /* Element UI的表格组件 */
-    margin-top: 15px;
+    margin-top: 15px; /* 设置顶部外边距，为上方的元素留出空间 */
-    font-size: 12px;
+    font-size: 12px; /* 设置字体大小，使表格内容更加紧凑 */
 }
 
 /* 设置el-pagination分页组件的顶部外边距为15px */
-.el-pagination {
+.el-pagination { /* Element UI的分页组件 */
-    margin-top: 15px;
+    margin-top: 15px; /* 设置顶部外边距，为上方的元素留出空间 */
 }
 
 /* 解决级联选择框内部滚动条包裹元素的高度问题 */
-/* 注意：这里的选择器可能存在特异性问题，通常不建议这样直接覆盖第三方组件的样式 */
+/* 注意：这里的选择器可能存在特异性问题，通常不建议这样直接覆盖第三方组件的样式，除非有特别的需求 */
-div .el-scrollbar__wrap {
+div .el-scrollbar__wrap { /* Element UI级联选择框内部滚动条包裹元素 */
-    height: 300px !important; /* 强制设置高度为300px */
+    height: 300px !important; /* 强制设置高度为300px，确保滚动条能够正常工作 */
+    /* !important用于确保该规则优先级最高，避免被其他样式覆盖 */
 }
 
 /* 步骤条样式 */
 /* 设置el-steps步骤条组件的外边距，上下各15px */
-.el-steps {
+.el-steps { /* Element UI的步骤条组件 */
-    margin: 15px 0;
+    margin: 15px 0; /* 设置上下外边距，为步骤条上方和下方的元素留出空间 */
 }
 
 /* 设置el-step步骤项标题的字体大小为13px */
-.el-step__title {
+.el-step__title { /* Element UI步骤条中步骤项的标题 */
-    font-size: 13px;
+    font-size: 13px; /* 设置字体大小，使步骤标题更加清晰易读 */
 }
 
 /* 富文本编辑器ql-editor的最小高度设置 */
 /* 这通常用于Quill富文本编辑器，确保编辑器区域有足够的高度进行内容编辑 */
-.ql-editor {
+.ql-editor { /* Quill富文本编辑器的编辑区域 */
-    min-height: 300px;
+    min-height: 300px; /* 设置最小高度，确保用户有足够的空间进行内容编辑 */
 }