m534ctfno
/
vue-shop-admin-work
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

mhx

Browse Source
feature/mhx
mhx 5 months ago
parent a971ca63b4
commit 2510bccfb8
25 changed files with 2126 additions and 844 deletions
Show Stats Download Patch File Download Diff File

51
dao/AttributeDAO.js
Unescape View File

@ -1,21 +1,46 @@
// 引入 Node.js 的 path 模块，用于处理文件和目录路径
var path = require("path");
// 引入自定义的 DAO 模块，可能是数据访问对象模块，具体功能取决于其实现
// 这个模块可能包含一些与数据库交互的底层方法
daoModule = require("./DAO");
databaseModule = require(path.join(process.cwd(),"modules/database"));
// 引入位于 modules/database 目录下的 database 模块
// 使用 process.cwd() 获取当前工作目录，并使用 path.join 方法拼接路径
// 这样做的目的是确保模块路径的动态性，可以适应不同的运行环境
databaseModule = require(path.join(process.cwd(), "modules/database"));
/**
* 获取参数列表数据
*
* @param {[type]} cat_id 分类ID
* @param {[type]} sel 类型
* @param {Function} cb 回调函数
* @param {[type]} cat_id 分类 ID，可能是用于筛选商品或产品的分类标识符
* @param {[type]} sel 类型，可能是指定要查询的属性类型或筛选条件的一部分
* @param {Function} cb 回调函数，用于处理获取数据后的操作
* 第一个参数为可能的错误信息，第二个参数为从数据库获取的数据
*/
module.exports.list = function(cat_id,sel,cb) {
db = databaseModule.getDatabase();
sql = "SELECT * FROM sp_attribute WHERE cat_id = ? AND attr_sel = ? AND delete_time is NULL";
database.driver.execQuery(
sql
,[cat_id,sel],function(err,attributes){
if(err) return cb("查询执行出错");
cb(null,attributes);
});
module.exports.list = function (cat_id, sel, cb) {
// 从 databaseModule 中获取数据库对象，这里 db 可能是一个封装好的数据库连接实例
db = databaseModule.getDatabase();
// 定义 SQL 查询语句，从 sp_attribute 表中查询数据
// 根据 cat_id 和 attr_sel 进行筛选，并且只选择 delete_time 为 NULL 的数据
// 这样做是为了过滤掉已经删除的记录
sql = "SELECT * FROM sp_attribute WHERE cat_id =? AND attr_sel =? AND delete_time is NULL";
// 使用数据库驱动执行查询操作
// 将 SQL 语句和参数 [cat_id, sel] 传递给 execQuery 方法
// execQuery 方法是数据库驱动提供的一个异步查询接口
database.driver.execQuery(
sql, // SQL 查询语句
[cat_id, sel], // 查询参数
function (err, attributes) { // 回调函数，用于处理查询结果
// 如果执行查询出现错误，调用回调函数并传递错误信息
// 这样可以确保调用者能够处理错误情况
if (err) return cb("查询执行出错");
// 如果查询成功，将结果（attributes）传递给回调函数
// 调用者可以在回调函数中处理这些数据
cb(null, attributes);
}
);
}

484
dao/DAO.js
Unescape View File

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

79
dao/GoodAttributeDAO.js
Unescape View File

@ -1,26 +1,63 @@
var path = require("path");
daoModule = require("./DAO");
databaseModule = require(path.join(process.cwd(),"modules/database"));
var path = require("path"); // 引入Node.js的path模块，用于处理文件和目录的路径
// 引入自定义的 DAO 模块，可能用于数据访问操作，具体功能取决于其内部实现
daoModule = require("./DAO"); // 引入当前目录下的DAO模块
module.exports.clearGoodAttributes = function(goods_id,cb) {
db = databaseModule.getDatabase();
sql = "DELETE FROM sp_goods_attr WHERE goods_id = ?";
database.driver.execQuery(
sql
,[goods_id],function(err){
if(err) return cb("删除出错");
cb(null);
});
// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录与相对路径
databaseModule = require(path.join(process.cwd(), "modules/database")); // 引入数据库模块，路径根据当前工作目录动态确定
/**
* 清除商品属性
*
* @param {[type]} goods_id 商品的唯一标识符，用于确定要清除属性的商品
* @param {Function} cb 回调函数，用于处理清除操作的结果
* 当操作完成时，将调用此函数。若操作出现错误，第一个参数将包含错误信息；若操作成功，第一个参数为 null
*/
module.exports.clearGoodAttributes = function (goods_id, cb) {
// 从数据库模块中获取数据库对象
db = databaseModule.getDatabase(); // 获取数据库实例
// 定义 SQL 语句，用于删除 sp_goods_attr 表中 goods_id 匹配的记录
sql = "DELETE FROM sp_goods_attr WHERE goods_id =?"; // SQL删除语句
// 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
database.driver.execQuery( // 执行SQL查询的方法
sql // SQL语句
, [goods_id], // 参数数组，包含要删除的goods_id
function (err) { // 回调函数，处理执行结果
// 如果执行查询时出现错误，调用回调函数并传递错误信息
if (err) return cb("删除出错"); // 错误处理
// 若操作成功，调用回调函数，将第一个参数设为 null
cb(null); // 成功处理，无返回值
});
}
module.exports.list = function(goods_id,cb) {
db = databaseModule.getDatabase();
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 = ?";
database.driver.execQuery(
sql
,[goods_id],function(err,attrs){
if(err) return cb("删除出错");
cb(null,attrs);
});
/**
* 查询商品属性列表
*
* @param {[type]} goods_id 商品的唯一标识符，用于确定要查询属性的商品
* @param {Function} cb 回调函数，用于处理查询操作的结果
* 当操作完成时，将调用此函数。若操作出现错误，第一个参数将包含错误信息；若操作成功，第一个参数为 null，第二个参数为查询结果
*/
module.exports.list = function (goods_id, cb) {
// 从数据库模块中获取数据库对象
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查询语句
// 执行 SQL 查询操作，将 goods_id 作为参数传递给 SQL 语句
database.driver.execQuery( // 执行SQL查询的方法
sql // SQL语句
, [goods_id], // 参数数组，包含要查询的goods_id
function (err, attrs) { // 回调函数，处理执行结果
// 如果执行查询时出现错误，调用回调函数并传递错误信息
if (err) return cb("删除出错"); // 注意：这里的错误信息提示为“删除出错”可能是个笔误，应为“查询出错”
// 若操作成功，调用回调函数，将第一个参数设为 null，第二个参数为查询结果
cb(null, attrs); // 成功处理，返回查询结果
});
}

230
dao/ManagerDAO.js
Unescape View File

@ -1,165 +1,199 @@
var path = require("path");
// 引入自定义的 DAO 模块，可能包含了对数据库操作的封装
daoModule = require("./DAO");
databaseModule = require(path.join(process.cwd(),"modules/database"));
// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录和相对路径
databaseModule = require(path.join(process.cwd(), "modules/database"));
/**
* 创建管理员
*
* @param {[type]} obj 管理员信息
* @param {Function} cb 回调函数
* @param {[type]} obj 管理员信息，包含创建管理员所需的信息，如用户名、密码等，具体结构取决于数据库表的设计
* @param {Function} cb 回调函数，用于处理创建操作的结果
* 当创建操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
*/
module.exports.create = function(obj,cb) {
daoModule.create("ManagerModel",obj,cb);
module.exports.create = function (obj, cb) {
// 调用 daoModule 的 create 方法，创建 ManagerModel 类型的对象，传入管理员信息和回调函数
daoModule.create("ManagerModel", obj, cb);
}
/**
* 获取管理员列表
*
* @param {[type]} conditions 查询条件
* @param {Function} cb 回调函数
* @param {[type]} conditions 查询条件，用于筛选管理员列表，具体内容根据业务需求而定
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
*/
module.exports.list = function(conditions,cb) {
daoModule.list("ManagerModel",conditions,function(err,models) {
if(err) return cb(err,null);
cb(null,models);
});
module.exports.list = function (conditions, cb) {
// 调用 daoModule 的 list 方法，查询 ManagerModel 类型的对象，传入查询条件和自定义的回调函数
daoModule.list("ManagerModel", conditions, function (err, models) {
if (err) return cb(err, null);
cb(null, models);
});
}
/**
* 通过查询条件获取管理员对象
*
* @param {[type]} conditions 条件
* @param {Function} cb 回调函数
* @param {[type]} conditions 条件，用于筛选单个管理员，具体内容根据业务需求而定
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
*/
module.exports.findOne = function(conditions,cb) {
daoModule.findOne("ManagerModel",conditions,cb);
module.exports.findOne = function (conditions, cb) {
// 调用 daoModule 的 findOne 方法，根据条件查询 ManagerModel 类型的对象，传入条件和回调函数
daoModule.findOne("ManagerModel", conditions, cb);
}
/**
* 通过关键词查询用户
*
* @param {[type]} key 关键词
* @param {[type]} offset
* @param {[type]} limit
* @param {Function} cb 回调函数
* @param {[type]} key 关键词，用于筛选用户，可能是用户名的一部分等
* @param {[type]} offset 分页偏移量，用于分页查询，从第几行开始查询
* @param {[type]} limit 分页限制，每页显示的数量
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
*/
module.exports.findByKey = function(key,offset,limit,cb) {
db = databaseModule.getDatabase();
sql = "SELECT * FROM sp_manager as mgr LEFT JOIN sp_role as role ON mgr.role_id = role.role_id";
if(key) {
sql += " WHERE mg_name LIKE ? LIMIT ?,?";
database.driver.execQuery(
sql
,["%" + key + "%",offset,limit],function(err,managers){
if(err) return cb("查询执行出错");
cb(null,managers);
});
} else {
sql += " LIMIT ?,? ";
database.driver.execQuery(sql,[offset,limit],function(err,managers){
if(err) return cb("查询执行出错");
cb(null,managers);
});
}
module.exports.findByKey = function (key, offset, limit, cb) {
// 从数据库模块中获取数据库对象
db = databaseModule.getDatabase();
// 定义基本的 SQL 查询语句，使用 LEFT JOIN 连接 sp_manager 和 sp_role 表
sql = "SELECT * FROM sp_manager as mgr LEFT JOIN sp_role as role ON mgr.role_id = role.role_id";
// 根据是否有关键词进行不同的 SQL 拼接和查询操作
if (key) {
// 拼接 LIKE 子句，进行模糊查询，并添加 LIMIT 子句进行分页
sql += " WHERE mg_name LIKE? LIMIT?,?";
database.driver.execQuery(
sql
, ["%" + key + "%", offset, limit], function (err, managers) {
if (err) return cb("查询执行出错");
cb(null, managers);
});
} else {
// 仅添加 LIMIT 子句进行分页
sql += " LIMIT?,? ";
database.driver.execQuery(sql, [offset, limit], function (err, managers) {
if (err) return cb("查询执行出错");
cb(null, managers);
});
}
}
/**
* 判断是否存在管理员
*
* @param {[type]} username 用户名
* @param {Function} cb 回调函数
*
* @param {[type]} username 用户名，用于判断该用户名对应的管理员是否存在
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为布尔值表示是否存在
*/
module.exports.exists = function(username,cb) {
var db = databaseModule.getDatabase();
var Model = db.models.ManagerModel;
Model.exists({"mg_name":username},function(err,isExists){
if(err) return cb("查询失败");
cb(null,isExists);
});
module.exports.exists = function (username, cb) {
// 从数据库模块中获取数据库对象
var db = databaseModule.getDatabase();
// 获取 ManagerModel 模型
var Model = db.models.ManagerModel;
// 调用 Model 的 exists 方法，传入用户名作为条件，查询是否存在
Model.exists({"mg_name": username}, function (err, isExists) {
if (err) return cb("查询失败");
cb(null, isExists);
});
}
/**
* 模糊查询用户数量
*
* @param {[type]} key 关键词
* @param {Function} cb 回调函数
* @param {[type]} key 关键词，用于模糊查询用户数量，可能是用户名的一部分等
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的用户数量
*/
module.exports.countByKey = function(key,cb) {
db = databaseModule.getDatabase();
sql = "SELECT count(*) as count FROM sp_manager";
if(key) {
sql += " WHERE mg_name LIKE ?";
database.driver.execQuery(
sql
,["%" + key + "%"],function(err,result){
if(err) return cb("查询执行出错");
cb(null,result[0]["count"]);
});
} else {
database.driver.execQuery(sql,function(err,result){
if(err) return cb("查询执行出错");
cb(null,result[0]["count"]);
});
}
module.exports.countByKey = function (key, cb) {
// 从数据库模块中获取数据库对象
db = databaseModule.getDatabase();
// 定义基本的 SQL 查询语句，统计 sp_manager 表中的记录数
sql = "SELECT count(*) as count FROM sp_manager";
// 根据是否有关键词进行不同的 SQL 拼接和查询操作
if (key) {
// 拼接 LIKE 子句，进行模糊查询
sql += " WHERE mg_name LIKE?";
database.driver.execQuery(
sql
, ["%" + key + "%"], function (err, result) {
if (err) return cb("查询执行出错");
// 从查询结果中获取数量
cb(null, result[0]["count"]);
});
} else {
database.driver.execQuery(sql, function (err, result) {
if (err) return cb("查询执行出错");
// 从查询结果中获取数量
cb(null, result[0]["count"]);
});
}
}
/**
* 通过ID获取管理员对象数据
* 通过 ID 获取管理员对象数据
*
* @param {[type]} id 管理员主键ID
* @param {Function} cb 回调函数
* @param {[type]} id 管理员主键 ID，用于唯一标识管理员
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
*/
module.exports.show = function(id,cb) {
daoModule.show("ManagerModel",id,cb);
module.exports.show = function (id, cb) {
// 调用 daoModule 的 show 方法，根据 ID 查询 ManagerModel 类型的对象，传入 ID 和回调函数
daoModule.show("ManagerModel", id, cb);
}
/**
* 更新管理员信息
*
* @param {[type]} obj 管理员对象
* @param {Function} cb 回调函数
* @param {[type]} obj 管理员对象，包含更新后的管理员信息，具体结构取决于数据库表的设计
* @param {Function} cb 回调函数，用于处理更新操作的结果
* 当更新操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
*/
module.exports.update = function(obj,cb) {
daoModule.update("ManagerModel",obj.mg_id,obj,cb);
module.exports.update = function (obj, cb) {
// 调用 daoModule 的 update 方法，更新 ManagerModel 类型的对象，传入对象的 mg_id 作为主键和对象信息及回调函数
daoModule.update("ManagerModel", obj.mg_id, obj, cb);
}
/**
* 删除管理员对象数据
*
* @param {[type]} id 主键ID
* @param {Function} cb 回调函数
* @param {[type]} id 主键 ID，用于唯一标识要删除的管理员
* @param {Function} cb 回调函数，用于处理删除操作的结果
* 当删除操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
*/
module.exports.destroy = function(id,cb) {
daoModule.destroy("ManagerModel",id,function(err){
if(err) return cb(err);
return cb(null);
});
module.exports.destroy = function (id, cb) {
// 调用 daoModule 的 destroy 方法，根据 ID 删除 ManagerModel 类型的对象，传入 ID 和自定义的回调函数
daoModule.destroy("ManagerModel", id, function (err) {
if (err) return cb(err);
return cb(null);
});
}
/**
* 保存管理员信息
*
* @param {[type]} obj 管理员对象
* @param {Function} cb 回调函数
* @param {[type]} obj 管理员对象，包含管理员信息，具体结构取决于数据库表的设计
* @param {Function} cb 回调函数，用于处理保存操作的结果
* 当保存操作完成时调用此函数，根据管理员对象是否有 mg_id 决定是创建新的管理员还是更新现有管理员
*/
module.exports.save = function(obj,cb) {
daoModule.show(obj.mg_id,function(err,oldObj){
if(err) {
daoModule.create("ManagerModel",obj,cb);
} else {
daoModule.update("ManagerModel",obj.mg_id,obj,cb);
}
})
module.exports.save = function (obj, cb) {
// 调用 daoModule 的 show 方法，根据管理员对象的 mg_id 进行查询
daoModule.show(obj.mg_id, function (err, oldObj) {
if (err) {
// 若查询出错，可能是不存在该管理员，调用 create 方法创建新的管理员
daoModule.create("ManagerModel", obj, cb);
} else {
// 若查询成功，调用 update 方法更新现有管理员
daoModule.update("ManagerModel", obj.mg_id, obj, cb);
}
})
}
/**
* 获取管理员数量
*
* @param {Function} cb 回调函数
* @param {Function} cb 回调函数，用于处理查询结果
* 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为管理员数量
*/
module.exports.count = function(cb) {
daoModule("ManagerModel",cb);
module.exports.count = function (cb) {
// 调用 daoModule 进行查询，传入 ManagerModel 类型和回调函数，但这里可能存在错误，因为调用方式不完整，应该是调用 daoModule 的某个方法
daoModule("ManagerModel", cb);
}

86
dao/PermissionAPIDAO.js
Unescape View File

@ -1,50 +1,64 @@
var path = require("path");
// 引入自定义的 DAO 模块，可能包含了对数据库操作的相关函数
daoModule = require("./DAO");
databaseModule = require(path.join(process.cwd(),"modules/database"));
// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录和相对路径
databaseModule = require(path.join(process.cwd(), "modules/database"));
/**
* 获取权限列表
*
* @param {Function} cb 回调函数
* @param {Function} cb 回调函数，用于处理获取权限列表的结果
* 当获取权限列表操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为权限列表结果
*/
module.exports.list = function(cb) {
db = databaseModule.getDatabase();
sql = "SELECT * FROM sp_permission_api as api LEFT JOIN sp_permission as main ON main.ps_id = api.ps_id WHERE main.ps_id is not null";
database.driver.execQuery(sql,function(err,result){
if(err) return cb("获取权限列表失败",null);
cb(null,result);
});
module.exports.list = function (cb) {
// 从数据库模块中获取数据库对象
db = databaseModule.getDatabase();
// 定义 SQL 查询语句，使用 LEFT JOIN 连接 sp_permission_api 和 sp_permission 表
// 筛选出 sp_permission 表的 ps_id 不为空的记录
sql = "SELECT * FROM sp_permission_api as api LEFT JOIN sp_permission as main ON main.ps_id = api.ps_id WHERE main.ps_id is not null";
// 执行 SQL 查询操作
database.driver.execQuery(sql, function (err, result) {
if (err) return cb("获取权限列表失败", null);
cb(null, result);
});
}
/**
* 权限验证
*
* @param {[type]} rid 角色ID
* @param {[type]} serviceName 服务名
* @param {[type]} actionName 动作名
* @param {Function} cb 回调函数
* @param {[type]} rid 角色 ID，用于标识用户的角色，可能是数字类型，不同角色拥有不同的权限
* @param {[type]} serviceName 服务名，可能是要访问的服务的名称，例如 API 服务的名称
* @param {[type]} actionName 动作名，可能是对服务的具体操作名称，例如 GET、POST 等操作
* @param {Function} cb 回调函数，用于处理权限验证的结果
* 当权限验证操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若验证通过，第一个参数为 null，第二个参数为 true；若验证不通过，第一个参数包含相应的错误信息，第二个参数为 false
*/
module.exports.authRight = function(rid,serviceName,actionName,cb) {
// 超级管理员
if(rid == 0) return cb(null,true);
// 权限验证
daoModule.findOne("PermissionAPIModel",{"ps_api_service":serviceName,"ps_api_action":actionName},function(err,permissionAPI){
console.log("rid => %s,serviceName => %s,actionName => %s",rid,serviceName,actionName);
if(err || !permissionAPI) return cb("无权限访问",false);
daoModule.findOne("RoleModel",{"role_id":rid},function(err,role){
console.log(role);
if(err || !role) return cb("获取角色信息失败",false);
ps_ids = role.ps_ids.split(",");
for(idx in ps_ids) {
ps_id = ps_ids[idx];
if(parseInt(permissionAPI.ps_id) == parseInt(ps_id)) {
return cb(null,true);
}
}
return cb("无权限访问",false);
});
});
module.exports.authRight = function (rid, serviceName, actionName, cb) {
// 超级管理员权限验证，若角色 ID 为 0，则直接认为有权限
if (rid == 0) return cb(null, true);
// 权限验证过程
// 使用 daoModule 的 findOne 方法查找 PermissionAPIModel 类型的对象
daoModule.findOne("PermissionAPIModel", {"ps_api_service": serviceName, "ps_api_action": actionName}, function (err, permissionAPI) {
// 打印当前角色 ID、服务名和动作名，方便调试
console.log("rid => %s,serviceName => %s,actionName => %s", rid, serviceName, actionName);
// 若出现错误或未找到权限 API 对象，认为无权限
if (err ||!permissionAPI) return cb("无权限访问", false);
// 查找 RoleModel 类型的对象，获取角色信息
daoModule.findOne("RoleModel", {"role_id": rid}, function (err, role) {
console.log(role);
// 若出现错误或未找到角色对象，认为获取角色信息失败
if (err ||!role) return cb("获取角色信息失败", false);
// 将角色的 ps_ids 以逗号分隔存储在数组中
ps_ids = role.ps_ids.split(",");
// 遍历 ps_ids 数组
for (idx in ps_ids) {
ps_id = ps_ids[idx];
// 若权限 API 的 ps_id 与角色的某个 ps_id 相等，认为有权限
if (parseInt(permissionAPI.ps_id) == parseInt(ps_id)) {
return cb(null, true);
}
}
// 若遍历完都不满足条件，认为无权限
return cb("无权限访问", false);
});
});
}

305
db/mydb.sql
Unescape View File

@ -1,115 +1,224 @@
/*
Navicat MySQL Data Transfer
Source Server : localhost_3306
Source Server Version : 50553
Source Host : localhost:3306
Source Database : mydb
Source Server : localhost_3306 -- 源服务器地址
Source Server Version : 50553 -- 源服务器MySQL版本
Source Host : localhost:3306 -- 源服务器主机地址和端口
Source Database : mydb -- 源数据库名称
Target Server Type : MYSQL
Target Server Version : 50553
File Encoding : 65001
Target Server Type : MYSQL -- 目标服务器类型
Target Server Version : 50553 -- 目标服务器MySQL版本
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_name` varchar(32) NOT NULL COMMENT '属性名称',
`cat_id` smallint(5) unsigned NOT NULL COMMENT '外键，类型id',
`attr_sel` enum('only','many') NOT NULL DEFAULT 'only' COMMENT 'only:输入框(唯一) many:后台下拉列表/前台单选框',
`attr_write` enum('manual','list') NOT NULL DEFAULT 'manual' COMMENT 'manual:手工录入 list:从列表选择',
`attr_vals` text NOT NULL COMMENT '可选值列表信息,例如颜色：白色,红色,绿色,多个可选值通过逗号分隔',
`delete_time` int(11) DEFAULT NULL COMMENT '删除时间标志',
PRIMARY KEY (`attr_id`),
KEY `type_id` (`cat_id`)
) ENGINE=InnoDB AUTO_INCREMENT=3803 DEFAULT CHARSET=utf8 COMMENT='属性表';
`attr_id` smallint(5) unsigned NOT NULL AUTO_INCREMENT COMMENT '主键id', -- 自增主键，用于唯一标识属性
`attr_name` varchar(32) NOT NULL COMMENT '属性名称', -- 属性名称，不能为空
`cat_id` smallint(5) unsigned NOT NULL COMMENT '外键，类型id', -- 外键，关联到商品类型表的id
`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:从列表选择', -- 属性值录入方式，默认为manual，表示手工录入
`attr_vals` text NOT NULL COMMENT '可选值列表信息,例如颜色：白色,红色,绿色,多个可选值通过逗号分隔', -- 可选值列表，用于下拉列表或单选框
`delete_time` int(11) DEFAULT NULL COMMENT '删除时间标志', -- 逻辑删除时间标志，用于软删除
PRIMARY KEY (`attr_id`), -- 主键约束
KEY `type_id` (`cat_id`) -- 为cat_id字段创建索引，提高查询效率
) 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 ('44', '规格-规格', '120', 'only', 'manual', '240毫升', null);
INSERT INTO `sp_attribute` VALUES ('45', '功效-功效', '120', 'only', 'manual', '保湿补水', null);
INSERT INTO `sp_attribute` VALUES ('46', '主观参数-品牌', '1210', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('47', '实质参数-适用人群', '1210', 'only', 'manual', '男士', null);
INSERT INTO `sp_attribute` VALUES ('48', '颜色', '1210', 'many', 'list', '酒红加绒+围脖,卡其加绒+围脖,藏青加绒+围脖,咖啡加绒+围脖,灰色加绒+围脖,黑色加绒+围脖,酒红加绒,卡其加绒,藏青加绒,咖啡加绒,灰色加绒,黑色加绒', null);
INSERT INTO `sp_attribute` VALUES ('49', '主观参数-品牌', '1211', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('50', '实质参数-适用人群', '1211', 'only', 'manual', '通用', null);
INSERT INTO `sp_attribute` VALUES ('51', '细节参数-形状', '1211', 'only', 'manual', '长方形', null);
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 ('53', '基本参数-品牌', '1212', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('54', '外观参数-色系', '1212', 'only', 'manual', '黑色系', null);
INSERT INTO `sp_attribute` VALUES ('55', '主观参数-品牌', '1213', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('56', '实质参数-适用对象', '1213', 'only', 'manual', '青年', null);
INSERT INTO `sp_attribute` VALUES ('57', '细节参数-包装', '1213', 'only', 'manual', '盒装', null);
INSERT INTO `sp_attribute` VALUES ('58', '颜色', '1213', 'many', 'list', 'C号领带,H号领带,A号领带,B号领带,F号领带,Y号领带,K号领带,J号领带', null);
INSERT INTO `sp_attribute` VALUES ('59', '主观参数-品牌', '1214', '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); -- 向sp_attribute表中插入一条记录，规格-规格，关联ID为120，类型为only，输入方式为manual，具体值为240毫升
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); -- 向sp_attribute表中插入一条记录，主观参数-品牌，关联ID为1210，类型为only，输入方式为manual，无具体值
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); -- 向sp_attribute表中插入一条记录，颜色，关联ID为1210，类型为many，输入方式为list，具体值为多种颜色组合
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); -- 向sp_attribute表中插入一条记录，实质参数-适用人群，关联ID为1211，类型为only，输入方式为manual，具体值为通用
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); -- 向sp_attribute表中插入一条记录，颜色，关联ID为1211，类型为many，输入方式为list，具体值为多种颜色
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); -- 向sp_attribute表中插入一条记录，外观参数-色系，关联ID为1212，类型为only，输入方式为manual，具体值为黑色系
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); -- 向sp_attribute表中插入一条记录，实质参数-适用对象，关联ID为1213，类型为only，输入方式为manual，具体值为青年
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); -- 向sp_attribute表中插入一条记录，颜色，关联ID为1213，类型为many，输入方式为list，具体值为多种领带颜色
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);
INSERT INTO `sp_attribute` VALUES ('62', '主体-品牌', '1215', 'only', 'manual', '', null);
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 ('65', '实质参数-文胸款式', '1216', 'only', 'manual', 'V型', null);
INSERT INTO `sp_attribute` VALUES ('66', '细节参数-包装', '1216', 'only', 'manual', '袋装', null);
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 ('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 ('71', '主体-品牌', '121', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('72', '规格-规格', '121', 'only', 'manual', '6# 10ml', null);
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 ('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);
-- 向sp_attribute表中插入一条记录，实质参数-适用人群，关联ID为1214，类型为only，输入方式为manual，具体值为通用
INSERT INTO `sp_attribute` VALUES ('61', '颜色', '1214', 'many', 'list', '男款深灰色,男款黑色,男款咖啡色,女款黑色,女款红色,女款灰色,深女款紫色,女款玫红,女款咖啡色', null); -- 插入颜色属性，多个值，用于商品1214
INSERT INTO `sp_attribute` VALUES ('62', '主体-品牌', '1215', 'only', 'manual', '', null); -- 插入品牌属性，单一值，手动输入，用于商品1215
INSERT INTO `sp_attribute` VALUES ('63', '规格-产品重量', '1215', 'only', 'manual', '35克', null); -- 插入产品重量属性，单一值，手动输入，用于商品1215
INSERT INTO `sp_attribute` VALUES ('64', '主观参数-品牌', '1216', 'only', 'manual', '', null); -- 插入品牌属性，主观参数，单一值，手动输入，用于商品1216
INSERT INTO `sp_attribute` VALUES ('65', '实质参数-文胸款式', '1216', 'only', 'manual', 'V型', null); -- 插入文胸款式属性，实质参数，单一值，手动输入，用于商品1216
INSERT INTO `sp_attribute` VALUES ('66', '细节参数-包装', '1216', 'only', 'manual', '袋装', null); -- 插入包装属性，细节参数，单一值，手动输入，用于商品1216
INSERT INTO `sp_attribute` VALUES ('67', '颜色', '1216', 'many', 'list', '肤色,75B,80A,75C,85B,75A,80B,80C', null); -- 插入颜色属性，多个值，用于商品1216
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);
@ -156,44 +265,76 @@ INSERT INTO `sp_attribute` VALUES ('119', '材质-商品尺寸', '1238', 'only',
INSERT INTO `sp_attribute` VALUES ('120', '颜色', '1238', 'many', 'list', '乐迪包裹造型挎包,乐迪圆形挎包,乐迪蛋壳背包,乐迪造型斗篷,小爱圆形挎包,小爱蛋壳背包', null);
INSERT INTO `sp_attribute` VALUES ('121', '主体-品牌', '1239', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('122', '规格-包装尺寸', '1239', 'only', 'manual', '900*360*200毫米', null);
-- 向sp_attribute表中插入一条新记录，设置属性ID为123，属性名称为'颜色'，所属商品ID为1239，属性类型为'many'，表示可以有多个值，
-- 属性输入方式为'list'，即列表选择，属性值为多个卡通小鹿的颜色选项，最后一个字段为null，可能表示没有额外的备注或默认值
INSERT INTO `sp_attribute` VALUES ('123', '颜色', '1239', 'many', 'list', '卡通小鹿粉蓝色,卡通小鹿黄绿色,卡通小鹿蓝桔色,卡通小鹿紫玫色,卡通小鹿粉玫色,卡通小鹿绿橘色', null);
-- 插入一条新记录，设置属性ID为124，属性名称为'主体-品牌'，所属商品ID为123，属性类型为'only'，表示只能有一个值，
-- 属性输入方式为'manual'，即手动输入，属性值为空，可能表示该属性在后续操作中会被填充或该商品没有特定的品牌信息
INSERT INTO `sp_attribute` VALUES ('124', '主体-品牌', '123', 'only', 'manual', '', null);
-- 插入一条新记录，设置属性ID为125，属性名称为'规格-规格'，所属商品ID为123，属性类型为'only'，输入方式为'manual'，
-- 属性值为'250ml'，表示该商品的规格为250毫升
INSERT INTO `sp_attribute` VALUES ('125', '规格-规格', '123', 'only', 'manual', '250ml', null);
-- 插入一条新记录，设置属性ID为126，属性名称为'功效-功效'，所属商品ID为123，属性类型为'only'，输入方式为'manual'，
-- 属性值为'清洁,淡化异味'，表示该商品具有清洁和淡化异味的效果
INSERT INTO `sp_attribute` VALUES ('126', '功效-功效', '123', 'only', 'manual', '清洁,淡化异味', null);
-- 插入一条新记录，设置属性ID为127，属性名称为'香型'，所属商品ID为123，属性类型为'many'，输入方式为'list'，
-- 属性值为多个香型选项，表示该商品有多种香型可供选择
INSERT INTO `sp_attribute` VALUES ('127', '香型', '123', 'many', 'list', '洋甘菊,百合,蔓越莓', null);
INSERT INTO `sp_attribute` VALUES ('128', '主体-品牌', '1240', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('129', '规格-重量', '1240', 'only', 'manual', '0.8克', null);
INSERT INTO `sp_attribute` VALUES ('130', '颜色', '1240', 'many', 'list', '30个6.5CM海洋球,50个6.5CM海洋球,100个6.5CM海洋球', null);
INSERT INTO `sp_attribute` VALUES ('131', '主体-品牌', '1241', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('132', '材质-包装尺寸', '1241', 'only', 'manual', '630x310x380毫米', null);
INSERT INTO `sp_attribute` VALUES ('133', '颜色', '1241', 'many', 'list', '不倒翁979,健儿球 929,快乐摇马987,摇铃939,欢乐园717,跳跳椅696', null);
INSERT INTO `sp_attribute` VALUES ('134', '主体-品牌', '1242', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('135', '特性-包装尺寸', '1242', 'only', 'manual', '185*3*265毫米', null);
INSERT INTO `sp_attribute` VALUES ('136', '主体-品牌', '1243', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('137', '规格-包装尺寸', '1243', 'only', 'manual', '300*90*175毫米', null);
INSERT INTO `sp_attribute` VALUES ('138', '主体-品牌', '1244', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('139', '材质-实物尺寸', '1244', 'only', 'manual', '60*38*120+76厘米', null);
INSERT INTO `sp_attribute` VALUES ('140', '颜色', '1244', 'many', 'list', '童话游戏屋,投手球池,热带雨林帐篷三件套,星月球池,1.2米圆点球池,海豚投篮球池球池,萤火虫投篮球池,热带雨林隧道', null);
-- 后续插入语句类似，均为向sp_attribute表中添加新记录，以下是对每条记录的简要说明：
-- ID 128: 为商品ID 1240设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 129: 为商品ID 1240设置'规格-重量'属性，属性类型为'only'，输入方式为'manual'，属性值为'0.8克'
-- ID 130: 为商品ID 1240设置'颜色'属性，属性类型为'many'，输入方式为'list'，属性值为多个海洋球选项
-- ID 131: 为商品ID 1241设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 132: 为商品ID 1241设置'材质-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'630x310x380毫米'
-- ID 133: 为商品ID 1241设置'颜色'属性，属性类型为'many'，输入方式为'list'，属性值为多个玩具选项
-- ID 134: 为商品ID 1242设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 135: 为商品ID 1242设置'特性-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'185*3*265毫米'
-- ID 136: 为商品ID 1243设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 137: 为商品ID 1243设置'规格-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'300*90*175毫米'
-- ID 138: 为商品ID 1244设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 139: 为商品ID 1244设置'材质-实物尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'60*38*120+76厘米'
-- ID 140: 为商品ID 1244设置'颜色'属性，属性类型为'many'，输入方式为'list'，属性值为多个帐篷或球池选项-- 向sp_attribute表中插入一条新记录，设置属性ID为141，属性名称为'主体-品牌'，所属商品ID为1245，
-- 属性类型为'only'，表示只能有一个值，属性输入方式为'manual'，即手动输入，属性值为空，
-- 可能表示该属性在后续操作中会被填充或该商品没有特定的品牌信息，最后一个字段为null，可能表示没有额外的备注或默认值
INSERT INTO `sp_attribute` VALUES ('141', '主体-品牌', '1245', 'only', 'manual', '', null);
-- 插入一条新记录，设置属性ID为142，属性名称为'规格-实物尺寸'，所属商品ID为1245，
-- 属性类型为'only'，输入方式为'manual'，属性值为'16厘米'，表示该商品的实物尺寸为16厘米
INSERT INTO `sp_attribute` VALUES ('142', '规格-实物尺寸', '1245', 'only', 'manual', '16厘米', null);
-- 插入一条新记录，设置属性ID为143，属性名称为'颜色'，所属商品ID为1245，
-- 属性类型为'many'，表示可以有多个值，输入方式为'list'，即列表选择，
-- 属性值为多个小猪佩奇的颜色和角色选项，表示该商品有多种颜色和角色可供选择
INSERT INTO `sp_attribute` VALUES ('143', '颜色', '1245', 'many', 'list', '橙色佩奇,蓝色乔治,粉色佩奇,乔治', null);
INSERT INTO `sp_attribute` VALUES ('144', '主体-品牌', '1247', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('145', '规格-实物尺寸', '1247', 'only', 'manual', '20-30cm', null);
INSERT INTO `sp_attribute` VALUES ('146', '颜色', '1247', 'many', 'list', '粉色海马,蓝色海马', null);
INSERT INTO `sp_attribute` VALUES ('147', '主体-类别', '1248', 'only', 'manual', '游戏叠叠乐', null);
INSERT INTO `sp_attribute` VALUES ('148', '规格-包装尺寸', '1248', 'only', 'manual', '285*80*80毫米', null);
INSERT INTO `sp_attribute` VALUES ('149', '51数字叠叠乐', '1248', 'many', 'list', '51数字叠叠乐+锤子,51数字叠叠乐,51数字叠叠乐+锤子,51数字叠叠乐', null);
INSERT INTO `sp_attribute` VALUES ('150', '主体-品牌', '1249', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('151', '规格-包装尺寸', '1249', 'only', 'manual', '250毫米', null);
INSERT INTO `sp_attribute` VALUES ('152', '主体参数-品牌', '124', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('153', '规格参数-包装', '124', 'only', 'manual', '瓶装', null);
INSERT INTO `sp_attribute` VALUES ('154', '其他参数-产品标准号', '124', 'only', 'manual', '。', null);
INSERT INTO `sp_attribute` VALUES ('155', '特性参数-产品剂型', '124', 'only', 'manual', '片剂', null);
INSERT INTO `sp_attribute` VALUES ('156', '主体-品牌', '1251', 'only', 'manual', '', null);
INSERT INTO `sp_attribute` VALUES ('157', '规格-重量', '1251', 'only', 'manual', '7克', null);
INSERT INTO `sp_attribute` VALUES ('158', '主体-适用年龄', '1252', 'only', 'manual', '1-3岁', null);
INSERT INTO `sp_attribute` VALUES ('159', '规格-包装尺寸', '1252', 'only', 'manual', '312*108*273毫米', null);
INSERT INTO `sp_attribute` VALUES ('160', '主体-品牌', '1253', 'only', 'manual', '', null);
-- 后续插入语句类似，均为向sp_attribute表中添加新记录，以下是对每条记录的简要说明：
-- ID 144: 为商品ID 1247设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 145: 为商品ID 1247设置'规格-实物尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'20-30cm'
-- ID 146: 为商品ID 1247设置'颜色'属性，属性类型为'many'，输入方式为'list'，属性值为多个海马的颜色选项
-- ID 147: 为商品ID 1248设置'主体-类别'属性，属性类型为'only'，输入方式为'manual'，属性值为'游戏叠叠乐'
-- ID 148: 为商品ID 1248设置'规格-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'285*80*80毫米'
-- ID 149: 为商品ID 1248设置'51数字叠叠乐'属性（可能是特定商品的一个特性或组合），属性类型为'many'，输入方式为'list'，属性值为多个选项
-- ID 150: 为商品ID 1249设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 151: 为商品ID 1249设置'规格-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'250毫米'
-- 接下来的记录是针对商品ID 124的多个属性设置：
-- ID 152: 为商品ID 124设置'主体参数-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 153: 为商品ID 124设置'规格参数-包装'属性，属性类型为'only'，输入方式为'manual'，属性值为'瓶装'
-- ID 154: 为商品ID 124设置'其他参数-产品标准号'属性，属性类型为'only'，输入方式为'manual'，属性值为一个点（可能是占位符或错误）
-- ID 155: 为商品ID 124设置'特性参数-产品剂型'属性，属性类型为'only'，输入方式为'manual'，属性值为'片剂'
-- ID 156: 为商品ID 1251设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
-- ID 157: 为商品ID 1251设置'规格-重量'属性，属性类型为'only'，输入方式为'manual'，属性值为'7克'
-- ID 158: 为商品ID 1252设置'主体-适用年龄'属性，属性类型为'only'，输入方式为'manual'，属性值为'1-3岁'
-- ID 159: 为商品ID 1252设置'规格-包装尺寸'属性，属性类型为'only'，输入方式为'manual'，属性值为'312*108*273毫米'
-- ID 160: 为商品ID 1253设置'主体-品牌'属性，属性类型为'only'，输入方式为'manual'，属性值为空
INSERT INTO `sp_attribute` VALUES ('161', '规格-包装尺寸', '1253', 'only', 'manual', '635.25毫米', null);
INSERT INTO `sp_attribute` VALUES ('162', '电源-充电', '1253', 'only', 'manual', '否', null);
INSERT INTO `sp_attribute` VALUES ('163', '颜色', '1253', 'many', 'list', '一辆装,二十辆装,五十辆装,十辆装', null);

63
models/AttributeModel.js
Unescape View File

@ -1,15 +1,50 @@
module.exports = function(db,callback){
// 用户模型
db.define("AttributeModel",{
attr_id : {type: 'serial', key: true},
attr_name : String,
cat_id : Number,
attr_sel : ["only", "many"], // only:输入框(唯一) many:后台下拉列表/前台单选框
attr_write: ["manual","list"], // manual:手工录入 list:从列表选择
attr_vals: String,
delete_time : Number
},{
table : "sp_attribute"
});
return callback();
/// 导出一个函数，这个函数是模块的主要接口，它接受两个参数：
// 第一个参数是数据库对象db，它提供了与数据库进行交互的能力；
// 第二个参数是一个回调函数callback，它将在模型定义成功后被调用。
module.exports = function(db, callback) {
// 开始使用db.define方法定义一个名为"AttributeModel"的模型。
// 这个模型用于表示商品或产品的属性。
db.define("AttributeModel", {
// 以下是该模型属性的定义部分：
// attr_id属性：作为主键，其类型为'serial'，表示这是一个自增的序列号。
// key: true表明这个属性是主键，用于唯一标识每条记录。
attr_id: {type: 'serial', key: true},
// attr_name属性：表示属性的名称，其类型为字符串（String）。
// 用于存储属性的描述性名称。
attr_name: String,
// cat_id属性：表示分类ID，其类型为数字（Number）。
// 这个属性用于将属性与特定的商品分类关联起来。
cat_id: Number,
// attr_sel属性：表示属性的选择类型，其值为一个数组，包含"only"和"many"。
// "only"表示该属性为唯一选择（如输入框），"many"表示该属性可以从多个选项中选择（如下拉列表或单选框）。
attr_sel: ["only", "many"],
// attr_write属性：表示属性的写入方式，其值为一个数组，包含"manual"和"list"。
// "manual"表示属性值需要手工录入，"list"表示属性值应从预定义的列表中选择。
attr_write: ["manual", "list"],
// attr_vals属性：表示属性的值，其类型为字符串（String）。
// 存储属性的实际值，可能是一个逗号分隔的字符串（对于"many"类型的属性）。
attr_vals: String,
// delete_time属性：表示删除时间，其类型为数字（Number）。
// 用于逻辑删除，即不真正从数据库中删除记录，而是通过设置一个删除时间来标记记录已删除。
delete_time: Number
}, {
// 以下是该模型的选项或配置的定义部分：
// table选项：指定这个模型在数据库中对应的表名。
// 在这个例子中，表名被指定为"sp_attribute"，这是数据库中存储属性信息的表的名称。
table: "sp_attribute"
});
// 模型定义完成。现在，我们调用之前传入的回调函数callback。
// 由于模型定义操作通常不会返回任何结果（除非出现错误），因此这里我们传入一个空参数。
// 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
// 但在这个例子中，回调函数可能只是被用来简单地表示模型定义过程的结束。
return callback();
}

55
models/CategoryModel.js
Unescape View File

@ -1,13 +1,44 @@
module.exports = function(db,callback){
// 用户模型
db.define("CategoryModel",{
cat_id : {type: 'serial', key: true},
cat_name : String,
cat_pid : Number,
cat_level : Number,
cat_deleted: Boolean
},{
table : "sp_category"
});
return callback();
// 这是一个Node.js模块，它导出一个函数。这个函数用于定义一个数据库模型，并允许在模型定义完成后执行回调函数。
module.exports = function(db, callback) {
// 开始定义用户模型（在这个上下文中，是分类模型）。
// 函数接受一个数据库对象db和一个回调函数callback作为参数。
// 使用db对象的define方法来定义一个名为CategoryModel的新模型。
// 这个模型用于操作数据库中的分类信息，如创建、读取、更新和删除分类。
db.define("CategoryModel", {
// 定义模型的第一个属性：分类ID（cat_id）。
// 这是一个自增主键，意味着每当向数据库添加新分类时，这个ID都会自动递增。
// type: 'serial'指定了这是一个序列类型（自增类型），key: true表示这是主键。
cat_id: {type: 'serial', key: true},
// 定义模型的第二个属性：分类名称（cat_name）。
// 这是一个字符串类型，用于存储分类的名称或标题。
cat_name: String,
// 定义模型的第三个属性：父分类ID（cat_pid）。
// 这是一个数字类型，用于表示当前分类的上级分类（如果存在的话）。
// 通过这个属性，可以建立分类之间的层级关系或父子关系。
cat_pid: Number,
// 定义模型的第四个属性：分类级别（cat_level）。
// 这也是一个数字类型，用于表示分类在层级结构中的位置或深度。
// 例如，顶级分类的级别可能是1，其子分类的级别可能是2，依此类推。
cat_level: Number,
// 定义模型的第五个属性：是否已删除（cat_deleted）。
// 这是一个布尔值类型，用于标记该分类是否已被逻辑删除（即在数据库中保留但不再显示或使用）。
// 这是一种软删除的方式，允许在不实际删除数据的情况下，从系统中移除分类。
cat_deleted: Boolean
}, {
// 定义模型的选项或配置。
// 在这个例子中，只定义了一个选项：table。
// 这个选项指定了模型对应的数据库表名。
// 在这个例子中，表名是"sp_category"。
// 这意味着该模型的所有数据库操作（如查询、插入、更新和删除）都会针对这个表进行。
table: "sp_category"
});
// 模型定义完成。现在调用回调函数callback，并传入空参数（或无参数）。
// 这通常表示模型已经成功定义，可以进行后续操作（如查询数据库、添加数据等）。
// 回调函数可以用于执行任何需要在模型定义完成后立即执行的操作。
return callback();
}

57
models/GoodAttributeModel.js
Unescape View File

@ -1,13 +1,46 @@
module.exports = function(db,callback){
// 用户模型
db.define("GoodAttributeModel",{
id : {type: 'serial', key: true},
goods_id : Number,
attr_id : Number,
attr_value : String,
add_price : Number
},{
table : "sp_goods_attr"
});
return callback();
// 导出一个函数，这个函数接受两个参数：
// 第一个参数是数据库对象db，它提供了与数据库交互的API，用于执行数据库操作；
// 第二个参数是一个回调函数callback，它在模型定义完成后被调用，用于执行一些后续逻辑。
module.exports = function(db, callback) {
// 使用db.define方法开始定义一个新的数据库模型。
// 这个模型实际上是一个商品属性模型，用于存储商品的属性信息。
// 模型的名称被指定为"GoodAttributeModel"，这是在代码中引用该模型时使用的标识符。
db.define("GoodAttributeModel", {
// 定义模型的第一个属性：id。
// 这是一个自增的主键，用于唯一标识数据库中的每一条记录。
// type: 'serial'指定了这是一个序列类型（自增类型），key: true表示这是主键。
id: {type: 'serial', key: true},
// 定义模型的第二个属性：goods_id。
// 这是一个数字类型的属性，用于存储关联的商品ID。
// 通过这个属性，可以将商品属性与具体的商品记录关联起来。
goods_id: Number,
// 定义模型的第三个属性：attr_id。
// 这也是一个数字类型的属性，用于存储关联的属性ID。
// 通过这个属性，可以将商品属性与具体的属性记录关联起来，表示这个商品属性是哪种属性。
attr_id: Number,
// 定义模型的第四个属性：attr_value。
// 这是一个字符串类型的属性，用于存储商品属性的具体值。
// 例如，如果属性是颜色，那么attr_value就可能是"红色"、"蓝色"等。
attr_value: String,
// 定义模型的第五个属性：add_price。
// 这是一个数字类型的属性，用于存储由于这个属性而导致的附加价格。
// 如果某个属性会导致商品价格变动（如不同颜色价格不同），则在这里存储增加的金额。
add_price: Number
}, {
// 定义模型的选项或配置。
// 在这个例子中，只定义了一个选项：table。
// table选项指定了模型在数据库中对应的表名。
// 在这个例子中，表名被指定为"sp_goods_attr"，这是数据库中存储商品属性信息的表的名称。
table: "sp_goods_attr"
});
// 模型定义完成。现在，我们调用回调函数callback。
// 由于我们没有向回调函数传递任何参数，这通常表示模型定义成功，没有发生错误。
// 回调函数可以在这里执行一些后续操作，如初始化数据、启动服务等。
// 在这个例子中，回调函数被简单地调用，没有执行任何额外的逻辑。
return callback();
}

71
models/GoodModel.js
Unescape View File

@ -1,33 +1,40 @@
module.exports = function(db,callback){
// 用户模型
db.define("GoodModel",{
goods_id : {type: 'serial', key: true},
cat_id : Number,
goods_name : String,
goods_price : Number,
goods_number : Number,
goods_weight : Number,
goods_introduce : String,
goods_big_logo : String,
goods_small_logo : String,
goods_state : Number, // 0：未审核 1: 审核中 2: 已审核
is_del : ['0','1'], // 0: 正常 , 1: 删除
add_time : Number,
upd_time : Number,
delete_time : Number,
hot_mumber : Number,
is_promote : Boolean,
cat_one_id : Number,
cat_two_id : Number,
cat_three_id : Number
},{
table : "sp_goods",
methods: {
getGoodsCat: function () {
return this.cat_one_id + ',' + this.cat_two_id + ',' + this.cat_three_id;
}
}
});
return callback();
// 导出一个函数，这个函数接受两个参数：
// 第一个参数是数据库对象db，用于数据库操作；
// 第二个参数是一个回调函数callback，用于在操作完成后执行特定逻辑。
module.exports = function(db, callback) {
// 开始定义用户模型，这里的用户模型实际上是一个商品属性模型。
// 使用db.define方法，该方法用于在数据库中定义一个新的模型（或称为表结构）。
// 模型名为GoodAttributeModel，代表商品属性模型。
db.define("GoodAttributeModel", {
// 以下是模型属性的定义：
// id属性：作为主键，其类型为'serial'，表示这是一个自增的序列号。
// key: true表示这个属性是主键。
id: {type: 'serial', key: true},
// 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，表示商品属性表。
table: "sp_goods_attr"
});
// 模型定义完成，调用回调函数callback。
// 传入无参数，表示模型定义成功，可以进行后续操作。
// 回调函数通常用于执行一些后续的逻辑处理，如初始化数据、启动服务等。
return callback();
}

55
models/GoodPicModel.js
Unescape View File

@ -1,13 +1,44 @@
module.exports = function(db,callback){
// 用户模型
db.define("GoodPicModel",{
pics_id : {type: 'serial', key: true},
goods_id : Number,
pics_big : String,
pics_mid : String,
pics_sma : String
},{
table : "sp_goods_pics"
});
return callback();
// 导出一个函数，这个函数是模块的主要接口，它接受两个参数：
// 第一个参数是数据库对象db，它封装了与数据库进行交互的所有能力；
// 第二个参数是一个回调函数callback，它将在模型定义成功完成后被调用。
module.exports = function(db, callback) {
// 使用db.define方法开始定义一个新的数据库模型。
// 需要注意的是，虽然这里提到的是“用户模型”，但实际上定义的是一个商品图片模型。
// 模型的名称被指定为"GoodPicModel"，这是在代码中引用该模型时的标识符。
db.define("GoodPicModel", {
// 以下是该模型属性的定义，每个属性都对应数据库表中的一个字段：
// pics_id属性：这是模型的主键，类型为'serial'，表示这是一个自增的序列号。
// key: true表明这个属性是主键，用于唯一标识数据库中的每一条记录。
pics_id: {type: 'serial', key: true},
// 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"，这是数据库中存储商品图片信息的表的名称。
// 所有与GoodPicModel相关的数据库操作都会针对这个表进行。
table: "sp_goods_pics"
});
// 模型定义完成。现在，我们调用之前传入的回调函数callback。
// 由于模型定义操作通常不会返回任何结果（除非出现错误），因此这里我们传入一个空参数。
// 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
// 但在这个例子中，回调函数可能只是被用来简单地表示模型定义过程的结束，或者进行一些简单的日志记录。
return callback();
}

69
models/ManagerModel.js
Unescape View File

@ -1,16 +1,55 @@
module.exports = function(db,callback){
// 用户模型
db.define("ManagerModel",{
mg_id : {type: 'serial', key: true},
mg_name : String,
mg_pwd : String,
mg_time : Number,
role_id : Number,
mg_mobile : String,
mg_email : String,
mg_state : Number
},{
table : "sp_manager"
});
return callback();
// 导出一个函数，这个函数有两个参数：
// 第一个参数是数据库对象db，用于执行数据库相关操作；
// 第二个参数是一个回调函数callback，用于在模型定义完成后执行一些后续操作。
module.exports = function(db, callback) {
// 注释：以下代码定义了一个用户模型，但根据上下文，这里更准确地应该是一个管理员模型。
// 使用数据库对象db的define方法，定义一个名为ManagerModel的模型。
// 这个模型用于表示系统中的管理员信息。
db.define("ManagerModel", {
// 以下是ManagerModel模型的属性定义：
// mg_id属性：表示管理员的唯一标识符，类型为'serial'，表示这是一个自增的主键。
// key: true表示这个属性是主键，用于唯一标识数据库中的每条记录。
mg_id: {type: 'serial', key: true},
// mg_name属性：表示管理员的名称，类型为字符串（String）。
// 用于存储管理员的登录名或姓名。
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"
});
// 模型定义完成，现在调用回调函数callback。
// 由于模型定义通常不会返回任何结果（除非出错），因此这里传入无参数。
// 回调函数可以在此处执行一些后续的逻辑处理，如初始化数据、启动服务等。
// 但在这个例子中，回调函数可能只是简单地表示模型定义过程的结束。
return callback();
}

60
models/OrderGoodModel.js
Unescape View File

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

61
models/OrderModel.js
Unescape View File

@ -1,22 +1,41 @@
module.exports = function(db,callback){
// 用户模型
db.define("OrderModel",{
order_id : {type: 'serial', key: true},
user_id : Number,
order_number : String,
order_price : Number,
order_pay : [1,2,3],
is_send : ["是","否"],
trade_no : String,
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"
});
return callback();
// 导出一个函数，这个函数接受数据库对象db和一个回调函数callback作为参数
module.exports = function(db, callback) {
// 用户模型
// 使用db.define方法定义一个模型，模型名为OrderModel
db.define("OrderModel", {
// 定义模型的属性
order_id: {type: 'serial', key: true}, // 订单ID，自增主键
user_id: Number,
// 用户ID，类型为数字
order_number: String,
// 订单编号，类型为字符串
order_price: Number,
// 订单总价，类型为数字
order_pay: [1,2,3],
// 订单支付方式，类型为数字数组，具体值可能代表不同的支付方式
is_send: ["是","否"],
// 是否发货，类型为字符串数组，可能代表“是”和“否”
trade_no: String,
// 交易编号，类型为字符串
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
});
// 调用回调函数，传入无参数
return callback();
}

36
models/PermissionAPIModel.js
Unescape View File

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

64
models/PermissionModel.js
Unescape View File

@ -1,14 +1,52 @@
module.exports = function(db,callback){
// 用户模型
db.define("PermissionModel",{
ps_id : {type: 'serial', key: true},
ps_name : String,
ps_pid : Number,
ps_c : String,
ps_a : String,
ps_level : String
},{
table : "sp_permission"
});
return callback();
// 导出一个函数，该函数是模块的主要接口。
// 它接受两个参数：数据库对象db（用于数据库操作）和一个回调函数callback（在模型定义后执行）。
module.exports = function(db, callback) {
// 定义一个名为"PermissionModel"的模型，用于表示系统中的权限。
// 使用db.define方法，该方法来自传入的数据库对象db。
db.define("PermissionModel", {
// 定义模型的属性，这些属性将映射到数据库表中的列。
// ps_id属性：权限的唯一标识符，类型为'serial'，表示这是一个自增的序列。
// key: true表明这个属性是主键。
ps_id: {type: 'serial', key: true},
// 注释：权限ID，自增主键，用于唯一标识每个权限记录。
// ps_name属性：权限的名称，类型为字符串（String）。
// 用于存储权限的描述性名称。
ps_name: String,
// 注释：权限名称，类型为字符串，用于标识和描述权限。
// ps_pid属性：父权限的ID，类型为数字（Number）。
// 用于表示权限之间的层级关系，即哪个权限是另一个权限的父级。
ps_pid: Number,
// 注释：父权限ID，类型为数字，用于建立权限的层级结构。
// ps_c属性：控制器名称，类型为字符串（String）。
// 在MVC架构中，控制器负责处理用户的请求。
// 这个属性可能用于指示哪个控制器与这个权限相关联。
ps_c: String,
// 注释：控制器名称，类型为字符串，用于指示处理请求的控制器。
// ps_a属性：动作名称，类型为字符串（String）。
// 在MVC架构中，动作是控制器中的一个方法，用于执行特定的任务。
// 这个属性可能用于指示哪个动作与这个权限相关联。
ps_a: String,
// 注释：动作名称，类型为字符串，用于指示控制器中要执行的动作。
// ps_level属性：权限级别，类型为字符串（String）。
// 这个属性可能用于表示权限的重要性或访问级别。
ps_level: String
// 注释：权限级别，类型为字符串，用于表示权限的等级或重要性。
}, {
// 定义模型的选项，这些选项用于配置模型的行为或属性。
// table选项：指定这个模型在数据库中对应的表名。
// 在这个例子中，表名被指定为"sp_permission"。
table: "sp_permission"
// 注释：指定模型对应的数据库表名为sp_permission，这是存储权限信息的数据库表。
});
// 调用回调函数callback，表示模型定义已经完成。
// 回调函数不接受任何参数，因为它主要用于执行一些后续的逻辑处理，而不是处理模型定义的结果。
return callback();
}

32
models/ReportOneModel.js
Unescape View File

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

61
models/ReportTwoModel.js
Unescape View File

@ -1,12 +1,51 @@
module.exports = function(db,callback){
// 报表模型1
db.define("ReportTwoModel",{
id : {type: 'serial', key: true},
rp2_page : String,
rp2_count : Number,
rp2_date : { type: "date", time: false }
},{
table : "sp_report_2"
});
return callback();
// 导出一个函数，这个函数是模块的主要接口。
// 它接受两个参数：数据库对象db（用于数据库操作）和一个回调函数callback（在模型定义后执行）。
module.exports = function(db, callback) {
// 这一行开始定义了一个名为"ReportTwoModel"的模型。
// db.define是数据库操作的一部分，用于创建一个新的模型。
// 这个模型可能用于存储报表数据，特别是与页面相关的统计数据。
db.define("ReportTwoModel", {
// 以下是模型属性的定义部分。
// 每个属性都映射到数据库表中的一个列。
// id属性：这是模型的主键，用于唯一标识每条记录。
// type: 'serial' 表示这是一个自增的整数序列。
// key: true 表示这是主键字段。
id: {type: 'serial', key: true},
// 注释：这是报表记录的唯一标识ID，它是一个自增的主键。
// rp2_page属性：用于存储与报表关联的页面名称。
// 类型为String，表示这是一个字符串类型的字段。
rp2_page: String,
// 注释：这是报表关联的页面名称，它是一个字符串类型的字段。
// rp2_count属性：用于存储与页面相关的统计数据，如访问次数。
// 类型为Number，表示这是一个数字类型的字段。
rp2_count: Number,
// 注释：这是与报表页面相关的统计数据，如访问次数，它是一个数字类型的字段。
// rp2_date属性：用于存储报表的生成日期。
// 类型为"date"，并且time: false表示只存储日期部分，不存储时间部分。
rp2_date: { type: "date", time: false }
// 注释：这是报表的生成日期，只包含日期部分，不包含时间部分，它是一个日期类型的字段。
}, {
// 以下是模型选项的定义部分。
// 这些选项用于配置模型的行为或属性。
// table选项：指定这个模型在数据库中对应的表名。
// 在这个例子中，表名被指定为"sp_report_2"。
table: "sp_report_2"
// 注释：这是模型对应的数据库表名，存储报表相关数据的表名为sp_report_2。
});
// 这一行调用了回调函数callback。
// 回调函数是在模型定义完成后执行的，它不接受任何参数。
// 在这个例子中，回调函数的调用表示ReportTwoModel模型已经成功定义。
// 这之后，模型就可以在应用程序的其他部分被引用和使用了。
return callback();
}

35
models/RoleModel.js
Unescape View File

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

73
src/assets/css/global.css
Unescape View File

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

140
src/assets/fonts/demo_fontclass.html
Unescape View File

@ -1,100 +1,120 @@
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8"/>
<title>IconFont</title>
<link rel="stylesheet" href="demo.css">
<link rel="stylesheet" href="iconfont.css">
<meta charset="utf-8"/> <!-- 设置文档的字符编码为UTF-8 -->
<title>IconFont</title> <!-- 设置网页的标题为IconFont -->
<link rel="stylesheet" href="demo.css"> <!-- 引入demo.css样式文件，用于页面的样式设计 -->
<link rel="stylesheet" href="iconfont.css"> <!-- 引入iconfont.css样式文件，包含图标字体的样式定义 -->
</head>
<body>
<div class="main markdown">
<h1>IconFont 图标</h1>
<ul class="icon_lists clear">
<div class="main markdown"> <!-- 定义一个主容器，使用main和markdown类进行样式设置 -->
<h1>IconFont 图标</h1> <!-- 设置一个一级标题，显示“IconFont 图标” -->
<ul class="icon_lists clear"> <!-- 定义一个无序列表，用于展示图标，同时添加clear类清除浮动 -->
<li>
<i class="icon iconfont icon-showpassword"></i>
<div class="name">show-password </div>
<div class="fontclass">.icon-showpassword</div>
<li> <!-- 列表项开始 -->
<i class="icon iconfont icon-showpassword"></i> <!-- 使用icon、iconfont和icon-showpassword类显示一个显示密码的图标 -->
<!-- 图标显示区域 -->
<div class="name">show-password </div> <!-- 显示图标的名称 -->
<!-- 图标名称显示区域 -->
<div class="fontclass">.icon-showpassword</div> <!-- 显示图标字体类名，用于开发者引用 -->
<!-- 图标字体类名显示区域 -->
</li>
<!-- 列表项结束 -->
<li>
<i class="icon iconfont icon-user"></i>
<div class="name">user</div>
<div class="fontclass">.icon-user</div>
<li> <!-- 另一个列表项开始 -->
<i class="icon iconfont icon-user"></i> <!-- 使用icon、iconfont和icon-user类显示一个用户图标 -->
<!-- 图标显示区域 -->
<div class="name">user</div> <!-- 显示图标的名称 -->
<!-- 图标名称显示区域 -->
<div class="fontclass">.icon-user</div> <!-- 显示图标字体类名 -->
<!-- 图标字体类名显示区域 -->
</li>
<!-- 列表项结束 -->
<li>
<!-- 后续列表项省略，格式与上述类似 -->
<li> <!-- 列表项开始，展示“用户们”图标 -->
<i class="icon iconfont icon-users"></i>
<div class="name">users</div>
<div class="fontclass">.icon-users</div>
</li>
<li>
<!-- 列表项结束 -->
<li> <!-- 列表项开始，展示“密码-b”图标 -->
<i class="icon iconfont icon-3702mima"></i>
<div class="name">password-b</div>
<div class="fontclass">.icon-3702mima</div>
</li>
<li>
<!-- 列表项结束 -->
<li> <!-- 列表项开始，展示“06商品”图标 -->
<i class="icon iconfont icon-shangpin"></i>
<div class="name">06商品</div>
<div class="fontclass">.icon-shangpin</div>
</li>
<li>
<!-- 列表项结束 -->
<li> <!-- 列表项开始，展示“25单据”图标 -->
<i class="icon iconfont icon-danju"></i>
<div class="name">25单据</div>
<div class="fontclass">.icon-danju</div>
</li>
<li>
<!-- 列表项结束 -->
<li> <!-- 列表项开始，展示“28体积、空间”图标 -->
<i class="icon iconfont icon-tijikongjian"></i>
<div class="name">28体积、空间</div>
<div class="fontclass">.icon-tijikongjian</div>
</li>
<li>
<i class="icon iconfont icon-morentouxiang"></i>
<div class="name">225默认头像</div>
<div class="fontclass">.icon-morentouxiang</div>
</li>
<i class="icon iconfont icon-morentouxiang"></i> <!-- 图标元素，使用iconfont图标库中的“默认头像”图标 -->
<div class="name">225默认头像</div> <!-- 图标名称，显示该图标的描述 -->
<div class="fontclass">.icon-morentouxiang</div> <!-- 图标类名，用于在CSS或JavaScript中引用该图标 -->
</li>
<li>
<i class="icon iconfont icon-baobiao"></i>
<div class="name">406报表</div>
<div class="fontclass">.icon-baobiao</div>
</li>
<li>
<i class="icon iconfont icon-baobiao"></i> <!-- 图标元素，使用iconfont图标库中的“报表”图标 -->
<div class="name">406报表</div> <!-- 图标名称，显示该图标的描述 -->
<div class="fontclass">.icon-baobiao</div> <!-- 图标类名，用于在CSS或JavaScript中引用该图标 -->
</li>
<li>
<i class="icon iconfont icon-lock_fill"></i>
<div class="name">lock_fill</div>
<div class="fontclass">.icon-lock_fill</div>
</li>
<li>
<i class="icon iconfont icon-lock_fill"></i> <!-- 图标元素，使用iconfont图标库中的“lock_fill”图标 -->
<div class="name">lock_fill</div> <!-- 图标名称，显示该图标的描述 -->
<div class="fontclass">.icon-lock_fill</div> <!-- 图标类名，用于在CSS或JavaScript中引用该图标 -->
</li>
</ul>
</ul>
<h2 id="font-class-">font-class引用</h2>
<hr>
<!-- 标题，说明接下来要介绍font-class引用方式 -->
<h2 id="font-class-">font-class引用</h2>
<hr>
<p>font-class是unicode使用方式的一种变种，主要是解决unicode书写不直观，语意不明确的问题。</p>
<p>与unicode使用方式相比，具有如下特点：</p>
<ul>
<li>兼容性良好，支持ie8+，及所有现代浏览器。</li>
<li>相比于unicode语意明确，书写更直观。可以很容易分辨这个icon是什么。</li>
<li>因为使用class来定义图标，所以当要替换图标时，只需要修改class里面的unicode引用。</li>
<li>不过因为本质上还是使用的字体，所以多色图标还是不支持的。</li>
</ul>
<p>使用步骤如下：</p>
<h3 id="-fontclass-">第一步：引入项目下面生成的fontclass代码：</h3>
<!-- 介绍font-class引用方式的优点 -->
<p>font-class是unicode使用方式的一种变种，主要是解决unicode书写不直观，语意不明确的问题。</p>
<p>与unicode使用方式相比，具有如下特点：</p>
<ul>
<li>兼容性良好，支持ie8+，及所有现代浏览器。</li> <!-- 兼容性说明 -->
<li>相比于unicode语意明确，书写更直观。可以很容易分辨这个icon是什么。</li> <!-- 语意明确性说明 -->
<li>因为使用class来定义图标，所以当要替换图标时，只需要修改class里面的unicode引用。</li> <!-- 替换图标方便性说明 -->
<li>不过因为本质上还是使用的字体，所以多色图标还是不支持的。</li> <!-- 多色图标不支持说明 -->
</ul>
<p>使用步骤如下：</p>
<!-- 第一步：引入fontclass代码 -->
<h3 id="-fontclass-">第一步：引入项目下面生成的fontclass代码：</h3>
<pre><code class="lang-js hljs javascript"><span class="hljs-comment">&lt;link rel="stylesheet" type="text/css" href="./iconfont.css"&gt;</span></code></pre>
<!-- 注释说明：引入iconfont.css文件，该文件包含了图标字体的定义 -->
<pre><code class="lang-js hljs javascript"><span class="hljs-comment">&lt;link rel="stylesheet" type="text/css" href="./iconfont.css"&gt;</span></code></pre>
<h3 id="-">第二步：挑选相应图标并获取类名，应用于页面：</h3>
<pre><code class="lang-css hljs">&lt;<span class="hljs-selector-tag">i</span> <span class="hljs-selector-tag">class</span>="<span class="hljs-selector-tag">iconfont</span> <span class="hljs-selector-tag">icon-xxx</span>"&gt;&lt;/<span class="hljs-selector-tag">i</span>&gt;</code></pre>
<blockquote>
<p>"iconfont"是你项目下的font-family。可以通过编辑项目查看，默认是"iconfont"。</p>
</blockquote>
</div>
<!-- 第二步：挑选相应图标并获取类名，应用于页面 -->
<h3 id="-">第二步：挑选相应图标并获取类名，应用于页面：</h3>
<pre><code class="lang-css hljs">&lt;<span class="hljs-selector-tag">i</span> <span class="hljs-selector-tag">class</span>="<span class="hljs-selector-tag">iconfont</span> <span class="hljs-selector-tag">icon-xxx</span>"&gt;&lt;/<span class="hljs-selector-tag">i</span>&gt;</code></pre>
<!-- 注释说明：使用<i>标签，并添加iconfont和具体的图标类名（如icon-xxx），来在页面上显示图标 -->
<blockquote>
<p>"iconfont"是你项目下的font-family。可以通过编辑项目查看，默认是"iconfont"。</p>
<!-- 注释说明：iconfont是CSS中定义的字体族名，用于指定图标字体 -->
</blockquote>
</div>
</body>
</html>

215
src/assets/fonts/demo_symbol.html
Unescape View File

@ -1,117 +1,210 @@
<!DOCTYPE html>
<!-- 声明文档类型为HTML5 -->
<html>
<!-- HTML文档的根元素 -->
<head>
<!-- 头部元素，包含文档的元数据 -->
<meta charset="utf-8"/>
<!-- 指定文档使用的字符编码为UTF-8 -->
<title>IconFont</title>
<!-- 设置文档的标题，显示在浏览器的标签页上 -->
<link rel="stylesheet" href="demo.css">
<!-- 链接外部样式表demo.css，用于定义页面的样式 -->
<script src="iconfont.js"></script>
<!-- 引入外部JavaScript文件iconfont.js，可能包含图标字体的初始化代码或功能 -->
<style type="text/css">
<!-- 内部样式表，定义具体的CSS规则 -->
.icon {
/* 图标类的基本样式定义 */
/* 通过设置 font-size 来改变图标大小 */
width: 1em; height: 1em;
/* 使用em单位设置图标的宽度和高度，em单位相对于当前元素的字体大小 */
/* 图标和文字相邻时，垂直对齐 */
vertical-align: -0.15em;
/* 通过微调vertical-align属性，使图标与文本垂直对齐 */
/* 通过设置 color 来改变 SVG 的颜色/fill */
fill: currentColor;
/* 使用currentColor关键字，使图标的填充颜色与父元素的文本颜色一致 */
/* path 和 stroke 溢出 viewBox 部分在 IE 下会显示
normalize.css 中也包含这行 */
overflow: hidden;
/* 隐藏超出SVG viewBox边界的内容，解决IE浏览器的显示问题 */
}
</style>
</head>
<body>
<!-- 这是HTML文档的body部分，用于包含网页的主要内容 -->
<div class="main markdown">
<!-- 这是一个div元素，用于包含主要内容，并应用了'main'和'markdown'两个CSS类 -->
<h1>IconFont 图标</h1>
<!-- 这是一个h1元素，用于显示页面或部分的标题，这里显示的是"IconFont 图标" -->
<ul class="icon_lists clear">
<!-- 这是一个无序列表（ul），用于显示图标列表，并应用了'icon_lists'和'clear'两个CSS类 -->
<li>
<!-- 列表项（li）的开始，用于包含单个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 这是一个svg元素，用于嵌入矢量图标，并应用了'icon'CSS类，aria-hidden属性设置为true表示这个元素对于屏幕阅读器是隐藏的 -->
<use xlink:href="#icon-showpassword"></use>
<!-- use元素用于引用SVG定义中的某个元素，这里引用的是id为"icon-showpassword"的图标 -->
</svg>
<div class="name">show-password </div>
<!-- 这是一个div元素，用于显示图标的名称，并应用了'name'CSS类 -->
<div class="fontclass">#icon-showpassword</div>
<!-- 这是一个div元素，用于显示图标的fontclass名称，通常用于CSS或JavaScript中引用图标 -->
</li>
<li>
<!-- 另一个列表项的开始，用于包含第二个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-user"></use>
<!-- 引用id为"icon-user"的图标 -->
</svg>
<div class="name">user</div>
<!-- 显示图标的名称 -->
<div class="fontclass">#icon-user</div>
<!-- 显示图标的fontclass名称 -->
</li>
<li>
<!-- 第三个列表项的开始，用于包含第三个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-users"></use>
<!-- 引用id为"icon-users"的图标 -->
</svg>
<div class="name">users</div>
<!-- 显示图标的名称 -->
<div class="fontclass">#icon-users</div>
<!-- 显示图标的fontclass名称 -->
</li>
<li>
<!-- 第四个列表项的开始，用于包含第四个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-3702mima"></use>
<!-- 引用id为"icon-3702mima"的图标 -->
</svg>
<div class="name">password-b</div>
<!-- 显示图标的名称 -->
<div class="fontclass">#icon-3702mima</div>
<!-- 显示图标的fontclass名称 -->
</li>
<!-- 列表项（li）的结束 -->
</ul>
<!-- 无序列表（ul）的结束 -->
</div>
<!-- div元素的结束 -->
</body>
<!-- HTML文档的body部分的结束 -->
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-shangpin"></use>
</svg>
<div class="name">06商品</div>
<div class="fontclass">#icon-shangpin</div>
</li>
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-danju"></use>
</svg>
<div class="name">25单据</div>
<div class="fontclass">#icon-danju</div>
</li>
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-tijikongjian"></use>
</svg>
<div class="name">28体积、空间</div>
<div class="fontclass">#icon-tijikongjian</div>
</li>
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-morentouxiang"></use>
</svg>
<div class="name">225默认头像</div>
<div class="fontclass">#icon-morentouxiang</div>
</li>
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-baobiao"></use>
</svg>
<div class="name">406报表</div>
<div class="fontclass">#icon-baobiao</div>
</li>
<li>
<!-- 这是一个列表项（li）元素，用于包含单个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 这是一个svg元素，用于嵌入矢量图标 -->
<!-- class="icon" 表示这个svg元素应用了'icon'CSS类 -->
<!-- aria-hidden="true" 表示这个svg元素对于屏幕阅读器是隐藏的，主要用于提高无障碍性 -->
<use xlink:href="#icon-shangpin"></use>
<!-- use元素用于引用SVG定义中的某个元素 -->
<!-- xlink:href="#icon-shangpin" 表示引用id为"icon-shangpin"的图标 -->
</svg>
<div class="name">06商品</div>
<!-- 这是一个div元素，用于显示图标的名称 -->
<!-- class="name" 表示这个div元素应用了'name'CSS类 -->
<div class="fontclass">#icon-shangpin</div>
<!-- 这是一个div元素，用于显示图标的fontclass名称 -->
<!-- class="fontclass" 表示这个div元素应用了'fontclass'CSS类 -->
<!-- #icon-shangpin 是图标的fontclass名称，通常用于CSS或JavaScript中引用图标 -->
</li>
<li>
<!-- 这是另一个列表项（li）元素，用于包含第二个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-danju"></use>
<!-- 引用id为"icon-danju"的图标 -->
</svg>
<div class="name">25单据</div>
<!-- 显示图标的名称 -->
<div class="fontclass">#icon-danju</div>
<!-- 显示图标的fontclass名称 -->
</li>
<li>
<!-- 这是第三个列表项（li）元素，用于包含第三个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-tijikongjian"></use>
<!-- 引用id为"icon-tijikongjian"的图标 -->
</svg>
<div class="name">28体积、空间</div>
<!-- 显示图标的名称，这里包含了中文描述和英文（可能是缩写或翻译） -->
<div class="fontclass">#icon-tijikongjian</div>
<!-- 显示图标的fontclass名称 -->
</li>
<li>
<!-- 这是第四个列表项（li）元素，用于包含第四个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-morentouxiang"></use>
<!-- 引用id为"icon-morentouxiang"的图标 -->
</svg>
<div class="name">225默认头像</div>
<!-- 显示图标的名称，这里的数字可能是图标的编号或顺序 -->
<div class="fontclass">#icon-morentouxiang</div>
<!-- 显示图标的fontclass名称 -->
</li>
<li>
<svg class="icon" aria-hidden="true">
<use xlink:href="#icon-lock_fill"></use>
</svg>
<div class="name">lock_fill</div>
<div class="fontclass">#icon-lock_fill</div>
</li>
</ul>
<!-- 这是一个列表项（li）元素，用于包含单个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 这是一个svg元素，用于嵌入矢量图标 -->
<!-- class="icon" 表示这个svg元素应用了'icon'CSS类，用于设置图标的样式 -->
<!-- aria-hidden="true" 表示这个svg元素对于屏幕阅读器是隐藏的，主要用于提高网页的无障碍性 -->
<use xlink:href="#icon-baobiao"></use>
<!-- use元素用于引用SVG定义中的某个元素 -->
<!-- xlink:href="#icon-baobiao" 表示引用id为"icon-baobiao"的图标 -->
</svg>
<div class="name">406报表</div>
<!-- 这是一个div元素，用于显示图标的名称或描述 -->
<!-- class="name" 表示这个div元素应用了'name'CSS类，用于设置文本样式 -->
<div class="fontclass">#icon-baobiao</div>
<!-- 这是一个div元素，用于显示图标的fontclass名称 -->
<!-- class="fontclass" 表示这个div元素应用了'fontclass'CSS类，用于设置文本样式 -->
<!-- #icon-baobiao 是图标的fontclass名称，通常用于CSS或JavaScript中引用图标 -->
</li>
<li>
<!-- 这是另一个列表项（li）元素，用于包含另一个图标的显示信息 -->
<svg class="icon" aria-hidden="true">
<!-- 同上，用于嵌入矢量图标 -->
<use xlink:href="#icon-lock_fill"></use>
<!-- 引用id为"icon-lock_fill"的图标 -->
</svg>
<div class="name">lock_fill</div>
<!-- 显示图标的名称或描述，这里的名称与图标的id相同，便于识别 -->
<div class="fontclass">#icon-lock_fill</div>
<!-- 显示图标的fontclass名称，与图标的id相同 -->
</li>
</ul>
<!-- 这是ul元素的结束标签，表示列表的结束 -->
<h2 id="symbol-">symbol引用</h2>
<hr>
<h2 id="symbol-">symbol引用</h2>
<!-- 这是一个h2元素，用于显示一个二级标题 -->
<!-- id="symbol-" 是这个h2元素的唯一标识符，可能用于CSS或JavaScript中定位或操作该元素 -->
<!-- 标题内容为"symbol引用"，表示接下来的内容将介绍如何使用symbol引用图标 -->
<hr>
<!-- 这是一个hr元素，用于在视觉上分隔内容 -->
<!-- 它通常用于分隔不同的主题或章节，使页面内容更加清晰易读 -->
<p>这是一种全新的使用方式，应该说这才是未来的主流，也是平台目前推荐的用法。相关介绍可以参考这篇<a href="">文章</a>
这种用法其实是做了一个svg的集合，与另外两种相比具有如下特点：</p>
@ -134,10 +227,24 @@
}
&lt;<span class="hljs-regexp">/style&gt;</span></code></pre>
<h3 id="-">第三步：挑选相应图标并获取类名，应用于页面：</h3>
<pre><code class="lang-js hljs javascript">&lt;svg <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"icon"</span> aria-hidden=<span class="hljs-string">"true"</span>&gt;<span class="xml"><span class="hljs-tag">
&lt;<span class="hljs-name">use</span> <span class="hljs-attr">xlink:href</span>=<span class="hljs-string">"#icon-xxx"</span>&gt;</span><span class="hljs-tag">&lt;/<span class="hljs-name">use</span>&gt;</span>
</span>&lt;<span class="hljs-regexp">/svg&gt;
</span></code></pre>
</div>
<body>
<!-- 这是一个包含JavaScript代码块的pre标签，用于在网页上显示格式化的代码 -->
<pre>
<!-- 使用hljs（可能是highlight.js）库对JavaScript代码进行高亮显示 -->
<code class="lang-js hljs javascript">
<!-- SVG标签的开始，用于在网页中嵌入矢量图形 -->
&lt;svg <span class="hljs-class"><span class="hljs-keyword">class</span></span>=<span class="hljs-string">"icon"</span> aria-hidden=<span class="hljs-string">"true"</span>&gt;<span class="xml">
<!--
use标签用于引用SVG定义中的某个元素，这里引用的是id为"icon-xxx"的元素。
xlink:href属性指定了要引用的元素的URL，但在这里使用的是ID选择器语法。
-->
&lt;<span class="hljs-name">use</span> <span class="hljs-attr">xlink:href</span>=<span class="hljs-string">"#icon-xxx"</span>&gt;<span class="hljs-tag">&lt;/<span class="hljs-name">use</span>&gt;</span>
</span>
<!-- SVG标签的结束 -->
&lt;<span class="hljs-regexp">/svg&gt;</span>
</code>
<!-- code标签的结束 -->
</pre>
<!-- body标签的结束 -->
</body>
</html>

187
src/assets/fonts/demo_unicode.html
Unescape View File

@ -1,96 +1,179 @@
<!DOCTYPE html>
<!-- 声明文档类型为HTML5，这是HTML页面的标准声明，告诉浏览器如何解析和渲染页面 -->
<html>
<!-- <html>标签是HTML页面的根元素，所有其他HTML元素都是其子元素 -->
<head>
<!-- <head>标签包含了文档的元数据（meta-information），如字符集、标题、样式表链接等 -->
<meta charset="utf-8"/>
<!-- <meta>标签用于指定文档的字符编码为UTF-8，这是一种国际通用的字符编码，支持多种语言的字符 -->
<title>IconFont</title>
<!-- <title>标签定义了文档的标题，这个标题会显示在浏览器的标签栏或标题栏上 -->
<link rel="stylesheet" href="demo.css">
<!-- <link>标签用于链接外部样式表（CSS文件），这里链接的是名为"demo.css"的样式表文件 -->
<style type="text/css">
<!-- <style>标签用于在HTML文档中嵌入CSS样式 -->
@font-face {font-family: "iconfont";
src: url('iconfont.eot'); /* IE9*/
src: url('iconfont.eot#iefix') format('embedded-opentype'), /* IE6-IE8 */
url('iconfont.woff') format('woff'), /* chrome, firefox */
url('iconfont.ttf') format('truetype'), /* chrome, firefox, opera, Safari, Android, iOS 4.2+*/
url('iconfont.svg#iconfont') format('svg'); /* iOS 4.1- */
@font-face {
/* @font-face是一个CSS规则，它允许你定义自己的字体，并指定字体文件的路径和格式 */
font-family: "iconfont";
/* font-family属性定义了字体的名称，这里定义的字体名称为"iconfont" */
src: url('iconfont.eot'); /* IE9及以下版本使用EOT格式的字体文件 */
/* src属性指定了字体文件的路径和格式 */
src: url('iconfont.eot#iefix') format('embedded-opentype'), /* IE6-IE8使用带嵌入OpenType格式的EOT字体文件 */
url('iconfont.woff') format('woff'), /* Chrome和Firefox支持WOFF格式的字体文件 */
url('iconfont.ttf') format('truetype'), /* Chrome、Firefox、Opera、Safari、Android和iOS 4.2+支持TrueType格式的字体文件 */
url('iconfont.svg#iconfont') format('svg'); /* iOS 4.1及以下版本支持SVG格式的字体文件 */
/* 注意：这里的src属性被重复使用了多次，实际上在@font-face规则中，src属性应该只出现一次，
但可以通过逗号分隔多个字体文件路径和格式。这里的写法可能是为了突出展示不同浏览器支持的字体格式，
但在实际使用中应该合并为一个src属性，例如：
src: url('iconfont.eot'); src: url('iconfont.eot#iefix') format('embedded-opentype'),
url('iconfont.woff') format('woff'), url('iconfont.ttf') format('truetype'),
url('iconfont.svg#iconfont') format('svg');
但正确的合并方式应该是：
src: url('iconfont.eot'); /* IE9 Compat Modes */
url('iconfont.eot?#iefix') format('embedded-opentype'), /* IE6-IE8 */
url('iconfont.woff') format('woff'), /* Super Modern Browsers */
url('iconfont.ttf') format('truetype'), /* Safari, Android, iOS */
url('iconfont.svg#iconfont') format('svg'); /* Legacy iOS */
并且注意，第一个src后的分号应该是逗号（但在实际规则中，我们只需要一个src属性，用逗号分隔不同的文件路径和格式）。
这里的注释是为了解释，实际代码应该按照正确的格式书写。 */
}
.iconfont {
font-family:"iconfont" !important;
font-size:16px;
font-style:normal;
-webkit-font-smoothing: antialiased;
-webkit-text-stroke-width: 0.2px;
-moz-osx-font-smoothing: grayscale;
}
.iconfont {
/* 定义字体家族为"iconfont"，用于应用图标字体 */
font-family: "iconfont" !important;
/* 使用!important是为了提高该规则的优先级，确保它不会被其他样式覆盖 */
/* 设置字体大小为16像素 */
font-size: 16px;
/* 设置字体样式为正常（非斜体） */
font-style: normal;
/* 在WebKit内核的浏览器中启用抗锯齿平滑处理，使字体边缘更平滑 */
-webkit-font-smoothing: antialiased;
/* 设置文本描边宽度为0.2像素（在WebKit内核的浏览器中有效），但通常用于放大效果 */
/* 注意：在大多数情况下，文本描边可能不是必需的，且可能因浏览器支持而异 */
-webkit-text-stroke-width: 0.2px;
/* 在Mac OS X的Firefox浏览器中启用灰度平滑处理，以减少字体渲染时的彩色边缘 */
-moz-osx-font-smoothing: grayscale;
}
/* CSS样式块结束 */
</style>
</style>
/* HTML文档的头部区域结束 */
</head>
/* HTML文档的主体区域开始 */
<body>
<!-- 定义一个具有"main"和"markdown"类的div容器，用于包含主要内容 -->
<div class="main markdown">
<!-- 定义一个一级标题，显示文本为"IconFont 图标" -->
<h1>IconFont 图标</h1>
<!-- 定义一个无序列表，具有"icon_lists"和"clear"类，用于包含图标列表 -->
<ul class="icon_lists clear">
<li>
<!-- 列表项开始，每个列表项包含一个图标、名称和代码 -->
<li>
<!-- 定义一个图标，使用"icon"和"iconfont"类，并显示特定的图标字符 -->
<i class="icon iconfont">&#xea3f;</i>
<div class="name">show-password </div>
<div class="code">&amp;#xea3f;</div>
</li>
<!-- 显示图标的名称 -->
<div class="name">show-password </div>
<!-- 显示图标的Unicode代码 -->
<div class="code">&amp;#xea3f;</div>
</li>
<li>
<!-- 类似的列表项，包含不同的图标、名称和代码 -->
<li>
<i class="icon iconfont">&#xe89a;</i>
<div class="name">user</div>
<div class="code">&amp;#xe89a;</div>
</li>
</li>
<li>
<li>
<i class="icon iconfont">&#xe8b5;</i>
<div class="name">users</div>
<div class="code">&amp;#xe8b5;</div>
</li>
</li>
<li>
<li>
<i class="icon iconfont">&#xe66c;</i>
<div class="name">password-b</div>
<div class="code">&amp;#xe66c;</div>
</li>
</li>
<li>
<li>
<i class="icon iconfont">&#xe888;</i>
<div class="name">06商品</div>
<div class="code">&amp;#xe888;</div>
</li>
</li>
<li>
<li>
<i class="icon iconfont">&#xe89b;</i>
<div class="name">25单据</div>
<div class="code">&amp;#xe89b;</div>
</li>
<li>
<i class="icon iconfont">&#xe89f;</i>
<div class="name">28体积、空间</div>
<div class="code">&amp;#xe89f;</div>
</li>
<li>
<i class="icon iconfont">&#xe8c9;</i>
<div class="name">225默认头像</div>
<div class="code">&amp;#xe8c9;</div>
</li>
</li>
<li>
<i class="icon iconfont">&#xe902;</i>
<div class="name">406报表</div>
<div class="code">&amp;#xe902;</div>
</li>
<li>
<i class="icon iconfont">&#xe709;</i>
<div class="name">lock_fill</div>
<div class="code">&amp;#xe709;</div>
</li>
<!-- 列表项开始，用于显示一个图标及其相关信息 -->
<li>
<!-- 定义一个图标元素，使用"icon"和"iconfont"类来应用图标字体的样式 -->
<!-- 字符实体"&#xe89f;"代表在iconfont字体中定义的特定图标 -->
<i class="icon iconfont">&#xe89f;</i>
<!-- 显示图标的名称，这里是"28体积、空间" -->
<!-- 这个名称可能用于描述图标所代表的含义或用途 -->
<div class="name">28体积、空间</div>
<!-- 显示图标的Unicode代码，这里是"&amp;#xe89f;" -->
<!-- 注意：在HTML中，"&"符号需要被转义为"&amp;"，所以Unicode代码前面有"&amp;" -->
<div class="code">&amp;#xe89f;</div>
</li>
<!-- 另一个列表项开始，用于显示另一个图标及其相关信息 -->
<li>
<!-- 定义一个图标元素，使用"icon"和"iconfont"类 -->
<!-- 字符实体"&#xe8c9;"代表另一个在iconfont字体中定义的图标 -->
<i class="icon iconfont">&#xe8c9;</i>
<!-- 显示图标的名称，"225默认头像" -->
<div class="name">225默认头像</div>
<!-- 显示图标的Unicode代码 -->
<div class="code">&amp;#xe8c9;</div>
</li>
<!-- 又一个列表项开始 -->
<li>
<!-- 定义一个图标元素，字符实体"&#xe902;"代表另一个图标 -->
<i class="icon iconfont">&#xe902;</i>
<!-- 显示图标的名称，"406报表" -->
<div class="name">406报表</div>
<!-- 显示图标的Unicode代码 -->
<div class="code">&amp;#xe902;</div>
</li>
<!-- 最后一个列表项 -->
<li>
<!-- 定义一个图标元素，字符实体"&#xe709;"代表锁填充图标 -->
<i class="icon iconfont">&#xe709;</i>
<!-- 显示图标的名称，"lock_fill" -->
<div class="name">lock_fill</div>
<!-- 显示图标的Unicode代码 -->
<div class="code">&amp;#xe709;</div>
</li>
</ul>
<h2 id="unicode-">unicode引用</h2>

51
src/assets/fonts/iconfont.css
Unescape View File

@ -15,23 +15,52 @@
-moz-osx-font-smoothing: grayscale;
}
.icon-showpassword:before { content: "\ea3f"; }
.icon-user:before { content: "\e89a"; }
.icon-showpassword:before {
content: "\ea3f"; /* 显示密码图标的Unicode字符 */
/* 这是一个伪元素，用于在元素前添加内容，这里添加的是显示密码的图标 */
}
.icon-users:before { content: "\e8b5"; }
.icon-user:before {
content: "\e89a"; /* 用户图标的Unicode字符 */
/* 在元素前添加用户图标 */
}
.icon-3702mima:before { content: "\e66c"; }
.icon-users:before {
content: "\e8b5"; /* 多个用户（群组）图标的Unicode字符 */
/* 在元素前添加多个用户（群组）图标 */
}
.icon-shangpin:before { content: "\e888"; }
.icon-3702mima:before {
content: "\e66c"; /* 特定编号（可能是项目内部编号）的密码图标的Unicode字符 */
/* 在元素前添加特定编号的密码图标 */
}
.icon-danju:before { content: "\e89b"; }
.icon-shangpin:before {
content: "\e888"; /* 商品图标的Unicode字符 */
/* 在元素前添加商品图标 */
}
.icon-tijikongjian:before { content: "\e89f"; }
.icon-danju:before {
content: "\e89b"; /* 单据（可能是发票或收据）图标的Unicode字符 */
/* 在元素前添加单据图标 */
}
.icon-morentouxiang:before { content: "\e8c9"; }
.icon-tijikongjian:before {
content: "\e89f"; /* 提交空间（可能是指提交表单或文件的区域）图标的Unicode字符 */
/* 在元素前添加提交空间图标 */
}
.icon-baobiao:before { content: "\e902"; }
.icon-morentouxiang:before {
content: "\e8c9"; /* 多人头像（可能是群聊或多人合作）图标的Unicode字符 */
/* 在元素前添加多人头像图标 */
}
.icon-lock_fill:before { content: "\e709"; }
.icon-baobiao:before {
content: "\e902"; /* 报表（可能是数据分析或统计）图标的Unicode字符 */
/* 在元素前添加报表图标 */
}
.icon-lock_fill:before {
content: "\e709"; /* 已填充（实心）锁头图标的Unicode字符 */
/* 在元素前添加已填充锁头图标，表示锁定或安全状态 */
}

350
src/assets/fonts/iconfont.svg
Unescape View File

@ -1,15 +1,40 @@
<?xml version="1.0" standalone="no"?>
<?xml version="1.0" standalone="no"?> <!-- 声明XML版本为1.0，且不是独立文档 -->
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
<!--
文档类型定义（DTD），指定这是一个SVG 1.1文档，并链接到SVG 1.1的DTD。
DTD定义了SVG文档的结构和允许的元素。
-->
<!--
2013-9-30: Created.
-->
<!--
注释：该SVG文件是在2013年9月30日创建的。
-->
<svg>
<!--
SVG根元素，所有SVG内容都包含在此元素内。
-->
<metadata>
<!--
元数据元素，用于存储有关SVG文件的额外信息。
-->
Created by iconfont
<!--
元数据内容，说明该SVG文件是由iconfont创建的。
-->
</metadata>
<defs>
<!--
定义元素，用于存储SVG文档中可重复使用的元素定义。
例如，可以在这里定义渐变、滤镜、字体等。
-->
<font id="iconfont" horiz-adv-x="1024" >
<!--
字体元素，定义一个SVG字体。
id属性为字体指定一个唯一标识符。
horiz-adv-x属性指定水平高级宽度，即字体中字符的水平间距。
-->
<font-face
font-family="iconfont"
font-weight="500"
@ -18,8 +43,20 @@ Created by iconfont
ascent="896"
descent="-128"
/>
<!--
font-face元素，定义字体的外观属性。
font-family属性指定字体的名称。
font-weight属性指定字体的粗细。
font-stretch属性指定字体的拉伸程度。
units-per-em属性指定em单位的尺寸，em是相对于字体大小的单位。
ascent属性指定字符的上升部分的高度。
descent属性指定字符的下降部分的高度（负值表示下降）。
-->
<missing-glyph />
<!--
missing-glyph元素，定义当字符在字体中找不到时显示的默认图形。
在这个例子中，没有指定missing-glyph的内容，所以它可能是一个空图形或默认的回退图形。
-->
<glyph glyph-name="x" unicode="x" horiz-adv-x="1001"
d="M281 543q-27 -1 -53 -1h-83q-18 0 -36.5 -6t-32.5 -18.5t-23 -32t-9 -45.5v-76h912v41q0 16 -0.5 30t-0.5 18q0 13 -5 29t-17 29.5t-31.5 22.5t-49.5 9h-133v-97h-438v97zM955 310v-52q0 -23 0.5 -52t0.5 -58t-10.5 -47.5t-26 -30t-33 -16t-31.5 -4.5q-14 -1 -29.5 -0.5
t-29.5 0.5h-32l-45 128h-439l-44 -128h-29h-34q-20 0 -45 1q-25 0 -41 9.5t-25.5 23t-13.5 29.5t-4 30v167h911zM163 247q-12 0 -21 -8.5t-9 -21.5t9 -21.5t21 -8.5q13 0 22 8.5t9 21.5t-9 21.5t-22 8.5zM316 123q-8 -26 -14 -48q-5 -19 -10.5 -37t-7.5 -25t-3 -15t1 -14.5
@ -30,31 +67,308 @@ t9.5 -10.5t21.5 -4h37h67h81h80h64h36q23 0 34 12t2 38q-5 13 -9.5 30.5t-9.5 34.5q-
<glyph glyph-name="showpassword" unicode="&#59967;" d="M1024 300c0-96-211.2-307.2-512-307.2-294.4 0-512 204.8-512 307.2s217.6 307.2 512 307.2c300.8 0 512-204.8 512-307.2l0 0zM512 549.6c-134.4 0-243.2-108.8-243.2-249.6s108.8-249.6 249.6-249.6c134.4 0 249.6 115.2 249.6 249.6-6.4 140.8-121.6 249.6-256 249.6l0 0zM512 460c-89.6 0-160-70.4-160-160s70.4-160 160-160c89.6 0 160 70.4 160 160s-70.4 160-160 160l0 0z" horiz-adv-x="1024" />
<glyph glyph-name="user" unicode="&#59546;" d="M622.816 193.28c-22.112 3.52-22.624 64.32-22.624 64.32s64.96 64.32 79.136 150.816c38.08 0 61.632 91.936 23.52 124.288C704.448 566.72 751.808 800 512 800c-239.808 0-192.448-233.28-190.88-267.328-38.08-32.352-14.56-124.288 23.52-124.288 14.144-86.496 79.136-150.816 79.136-150.816s-0.512-60.8-22.624-64.32C329.952 181.92 64 64.64 64-64l448 0 448 0C960 64.64 694.048 181.92 622.816 193.28z" horiz-adv-x="1024" />
<glyph
glyph-name="user"
<!-- 定义图标的名称为"user" -->
unicode="&#59546;"
<!-- 定义图标对应的Unicode编码 -->
d="M622.816 193.28c-22.112 3.52-22.624 64.32-22.624 64.32s64.96 64.32 79.136 150.816c38.08 0 61.632 91.936 23.52 124.288C704.448 566.72 751.808 800 512 800c-239.808 0-192.448-233.28-190.88-267.328-38.08-32.352-14.56-124.288 23.52-124.288 14.144-86.496 79.136-150.816 79.136-150.816s-0.512-60.8-22.624-64.32C329.952 181.92 64 64.64 64-64l448 0 448 0C960 64.64 694.048 181.92 622.816 193.28z"
<!-- 定义图标的路径数据，描述图标的形状 -->
horiz-adv-x="1024"
<!-- 定义图标的水平高级宽度 -->
/>
<glyph glyph-name="users" unicode="&#59573;" d="M735.008 90.624c-18.944 2.976-19.392 54.656-19.392 54.656s55.68 54.656 67.808 128.16c32.64 0 52.8 78.144 20.16 105.632 1.376 28.928 41.984 227.168-163.584 227.168-205.568 0-164.96-198.24-163.584-227.168-32.64-27.488-12.48-105.632 20.16-105.632 12.128-73.504 67.84-128.16 67.84-128.16s-0.416-51.68-19.392-54.656C483.968 80.992 256-18.688 256-128l384 0 384 0C1024-18.688 796.032 80.992 735.008 90.624zM344.064 73.184c44.096 27.136 97.632 52.32 141.536 67.424-15.744 22.432-33.28 52.928-44.32 89.056-15.392 12.576-27.936 30.528-36 52.608-8.064 22.112-11.136 46.848-8.608 69.696 1.792 16.384 6.464 31.68 13.664 45.088-4.352 46.592-7.424 138.048 52.448 204.736 23.2 25.856 52.544 44.448 87.712 55.68C544.192 722.24 511.296 798.24 384 798.24c-205.568 0-164.96-198.24-163.584-227.168-32.64-27.488-12.48-105.632 20.16-105.632 12.128-73.504 67.84-128.16 67.84-128.16s-0.416-51.68-19.392-54.656C227.968 272.992 0 173.312 0 64l329.6 0C334.304 67.072 339.104 70.144 344.064 73.184z" horiz-adv-x="1024" />
<glyph
glyph-name="users"
<!-- 定义图标的名称为"users" -->
unicode="&#59573;"
<!-- 定义图标对应的Unicode编码 -->
d="M735.008 90.624c-18.944 2.976-19.392 54.656-19.392 54.656s55.68 54.656 67.808 128.16c32.64 0 52.8 78.144 20.16 105.632 1.376 28.928 41.984 227.168-163.584 227.168-205.568 0-164.96-198.24-163.584-227.168-32.64-27.488-12.48-105.632 20.16-105.632 12.128-73.504 67.84-128.16 67.84-128.16s-0.416-51.68-19.392-54.656C483.968 80.992 256-18.688 256-128l384 0 384 0C1024-18.688 796.032 80.992 735.008 90.624zM344.064 73.184c44.096 27.136 97.632 52.32 141.536 67.424-15.744 22.432-33.28 52.928-44.32 89.056-15.392 12.576-27.936 30.528-36 52.608-8.064 22.112-11.136 46.848-8.608 69.696 1.792 16.384 6.464 31.68 13.664 45.088-4.352 46.592-7.424 138.048 52.448 204.736 23.2 25.856 52.544 44.448 87.712 55.68C544.192 722.24 511.296 798.24 384 798.24c-205.568 0-164.96-198.24-163.584-227.168-32.64-27.488-12.48-105.632 20.16-105.632 12.128-73.504 67.84-128.16 67.84-128.16s-0.416-51.68-19.392-54.656C227.968 272.992 0 173.312 0 64l329.6 0C334.304 67.072 339.104 70.144 344.064 73.184z"
<!-- 定义图标的路径数据，描述多个用户的图标形状 -->
horiz-adv-x="1024"
<!-- 定义图标的水平高级宽度 -->
/>
<glyph glyph-name="3702mima" unicode="&#58988;" d="M893.532041 14.644791l-0.284479 392.855436c-1.805112 41.266869-35.472909 74.250074-77.136821 74.419943l-50.869574-0.029676 0 35.523051 0.191358 0 0.170892 81.20344c0 2.183735-0.285502 4.273327-0.647753 6.363941-2.829442 123.525338-101.722776 223.293599-224.985124 227.214908l0 1.137916C414.498874 831.871447 313.084113 731.117742 310.218856 606.004233c-0.361227-2.090615-0.64673-4.180206-0.64673-6.363941l0.170892-81.20344 0.191358 0 0-36.477796-0.094144 0 0-0.323365-42.272779-0.019443c-2.596128-0.115634-5.158487-0.358157-7.682983-0.720408l-0.819668 0c-41.663912-0.169869-75.331709-33.152051-77.136821-74.419943l-0.284479-392.855436c0.209778-42.786479 34.921347-77.441766 77.763085-77.441766l38.911218 0 0-0.037862 466.923362-0.265036 0 0.302899 38.910195 0c4.331655 0 8.575306 0.370437 12.71458 1.050935C859.199095-62.181969 893.32431-27.774321 893.532041 14.644791zM387.811048 599.905328c0.514723 82.71998 65.588811 150.08832 147.393955 154.210197l0-0.847298c84.028788-1.687432 151.633512-70.065775 152.158469-154.386206l0.454348 0c0-0.095167-0.036839-0.170892-0.036839-0.265036l-0.26299-116.770494-299.860439-0.172939-0.265036 117.966739c0 0.094144-0.037862 0.169869-0.037862 0.265036L387.811048 599.905328z" horiz-adv-x="1024" />
<glyph
glyph-name="3702mima"
<!-- 定义图标的名称为"3702mima" -->
unicode="&#58988;"
<!-- 定义图标对应的Unicode编码 -->
d="M893.532041 14.644791l-0.284479 392.855436
<!-- 从坐标(893.532041, 14.644791)开始，向上绘制一条长度为392.855436的线段 -->
c-1.805112 41.266869-35.472909 74.250074-77.136821 74.419943
<!-- 从上一点开始，绘制一条三次贝塞尔曲线到(减去偏移后的位置)，曲线控制点和结束点如上 -->
l-50.869574-0.029676 0 35.523051 0.191358 0 0.170892 81.20344
<!-- 绘制一系列直线段，长度和方向如上 -->
c0 2.183735-0.285502 4.273327-0.647753 6.363941
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（实际上是直线，因为控制点与起点或终点重合），表示微小的垂直上升 -->
-2.829442 123.525338-101.722776 223.293599-224.985124 227.214908
<!-- 绘制另一条三次贝塞尔曲线，表示大幅上升并稍微向右弯曲 -->
l0 1.137916
<!-- 绘制一条长度为1.137916的垂直线段 -->
C414.498874 831.871447 313.084113 731.117742 310.218856 606.004233
<!-- 绘制一条到指定坐标的二次贝塞尔曲线，但由于缺少控制点，这里可能是一个误解，应为直线或需额外信息 -->
c-0.361227-2.090615-0.64673-4.180206-0.64673-6.363941
<!-- 从上一点开始，绘制一条微小的下降直线 -->
l0.170892-81.20344 0.191358 0 0-36.477796-0.094144 0 0-0.323365-42.272779-0.019443
<!-- 绘制一系列直线段和微小的下降，表示向左下方的折线 -->
c-2.596128-0.115634-5.158487-0.358157-7.682983-0.720408
<!-- 从上一点开始，绘制一条微小的下降直线，表示进一步的下降 -->
l-0.819668 0
<!-- 绘制一条长度为0的水平线段，可能是为了调整位置或作为路径的一部分，但无实际效果 -->
c-41.663912-0.169869-75.331709-33.152051-77.136821-74.419943
<!-- 从上一点开始，绘制一条三次贝塞尔曲线，表示向左下方的大幅下降 -->
l-0.284479-392.855436
<!-- 绘制一条向左下方的长直线，回到起始区域附近 -->
c0.209778-42.786479 34.921347-77.441766 77.763085-77.441766
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线，因为控制点与终点重合），表示微小的水平移动和大幅上升回到原高度 -->
l38.911218 0 0-0.037862 466.923362-0.265036 0 0.302899 38.910195 0
<!-- 绘制一系列直线段，主要是水平移动，可能用于调整位置或作为路径的一部分 -->
c4.331655 0 8.575306 0.370437 12.71458 1.050935
<!-- 从上一点开始，绘制一条微小的上升直线 -->
C859.199095-62.181969 893.32431-27.774321 893.532041 14.644791
<!-- 绘制一条到起始坐标的二次贝塞尔曲线，完成整个图标的轮廓 -->
z
<!-- 表示路径的结束，回到起始点 -->
M387.811048 599.905328
<!-- 开始绘制图标内部的另一个形状或元素 -->
c0.514723 82.71998 65.588811 150.08832 147.393955 154.210197
<!-- 从指定坐标开始，绘制一条三次贝塞尔曲线，表示向上的大幅弯曲 -->
l0-0.847298
<!-- 绘制一条微小的下降直线 -->
c84.028788-1.687432 151.633512-70.065775 152.158469-154.386206
<!-- 从上一点开始，绘制一条三次贝塞尔曲线，表示向左下方的大幅下降 -->
l0.454348 0
<!-- 绘制一条长度为0的水平线段，可能是为了调整位置或作为路径的一部分，但无实际效果 -->
c0-0.095167-0.036839-0.170892-0.036839-0.265036
<!-- 从上一点开始，绘制一条微小的下降直线 -->
l-0.26299-116.770494-299.860439-0.172939-0.265036 117.966739
<!-- 绘制一系列直线段，表示向左下方的大幅移动，然后向右上方的大幅移动，回到接近起始位置 -->
c0 0.094144-0.037862 0.169869-0.037862 0.265036
<!-- 从上一点开始，绘制一条微小的上升直线 -->
L387.811048 599.905328
<!-- 绘制一条直线到起始坐标，完成内部形状或元素的绘制 -->
z"
<!-- 表示路径的结束，回到起始点 -->
horiz-adv-x="1024"
<!-- 定义图标的水平高级宽度 -->
/>
<glyph glyph-name="shangpin" unicode="&#59528;" d="M832 640H640V735.2c0 17.6-14.4 32.8-32.8 32.8H416c-17.6 0-32.8-14.4-32.8-32.8V640H192l-64-576c0-35.2 28.8-64 64-64h640c35.2 0 64 28.8 64 64l-64 576z m-384 64h128v-64H448v64z m-0.8-192H384v63.2h63.2V512zM640 512h-63.2v63.2H640V512z" horiz-adv-x="1024" />
<glyph
glyph-name="shangpin"
<!-- 定义图标的名称为“shangpin” -->
unicode="&#59528;"
<!-- 定义图标对应的Unicode编码 -->
d="M832 640H640V735.2
<!-- 从坐标(832, 640)开始，水平移动到(640, 640)，然后垂直移动到(640, 735.2) -->
c0 17.6-14.4 32.8-32.8 32.8
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线，因为控制点与起点或终点重合），表示垂直上升，高度为32.8 -->
H416
<!-- 水平移动到(416, 735.2) -->
c-17.6 0-32.8-14.4-32.8-32.8
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示垂直下降，回到高度640 -->
V640
<!-- 垂直移动到(416, 640) -->
H192
<!-- 水平移动到(192, 640) -->
l-64-576
<!-- 从上一点开始，绘制一条向左下方倾斜的直线，长度为64，垂直下降576 -->
c0-35.2 28.8-64 64-64
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示微小的水平移动和大幅的垂直下降，形成矩形的底部 -->
h640
<!-- 水平移动到(832, -64)（但由于是相对于上一个点，且上一个点已经在最低点，这里实际上没有垂直移动） -->
c35.2 0 64 28.8 64 64
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示微小的水平移动和大幅的垂直上升，回到起始高度附近 -->
l-64 576
<!-- 绘制一条向右上方倾斜的直线，长度为64，垂直上升576，形成矩形的右上角 -->
z
<!-- 表示路径的结束，回到起始点，形成闭合路径 -->
m-384 64
<!-- 从上一个路径的结束点开始，水平移动到(448, 64)（因为-384的偏移） -->
h128
<!-- 水平移动到(576, 64) -->
v-64
<!-- 垂直移动到(576, 0) -->
H448
<!-- 水平移动到(448, 0) -->
v64
<!-- 垂直移动到(448, 64)，形成一个小的正方形或矩形 -->
z
<!-- 表示路径的结束，回到起始点（对于这个小矩形） -->
m-0.8-192
<!-- 从上一个路径的结束点开始，微小地向左移动，准备绘制下一个形状 -->
H384
<!-- 水平移动到(384, -128)（但由于是相对于上一个点，且上一个点已经在y=64，所以这里实际上是向下移动） -->
v63.2
<!-- 垂直移动到(384, -64.8)（但由于是向上移动，且起始点在y=0以下，所以这里的数值表示相对于某个更低点的位置） -->
h63.2
<!-- 水平移动到(447.2, -64.8) -->
V512
<!-- 垂直移动到(447.2, 512)，形成一个向上的直线段，可能是为了与其他部分对齐或形成某种视觉效果 -->
z
<!-- 但由于此命令后没有其他形状或路径连接到此点，V512和随后的Z可能是为了保持路径的完整性或为了后续可能的修改预留 -->
M640 512
<!-- 绝对移动到(640, 512) -->
h-63.2
<!-- 水平移动到(576.8, 512) -->
v63.2
<!-- 垂直移动到(576.8, 575.2) -->
H640
<!-- 水平移动到(640, 575.2) -->
V512
<!-- 垂直移动回到(640, 512)，形成一个小的正方形或矩形，与之前的类似但位置不同 -->
z"
<!-- 表示路径的结束，回到起始点（对于这个小矩形） -->
horiz-adv-x="1024"
<!-- 定义图标的水平高级宽度 -->
/>
<glyph glyph-name="danju" unicode="&#59547;" d="M800 704H640c0 70.4-57.6 128-128 128s-128-57.6-128-128H224c-17.6 0-32-14.4-32-32v-704c0-17.6 14.4-32 32-32h576c17.6 0 32 14.4 32 32V672c0 17.6-14.4 32-32 32z m-288 32c17.6 0 32-14.4 32-32s-14.4-32-32-32-32 14.4-32 32 14.4 32 32 32z m64-608H320v64h256v-64z m128 128H320v64h384v-64z m0 128H320v64h384v-64z" horiz-adv-x="1024" />
<glyph
glyph-name="danju"
<!-- 定义图标的名称为“danju” -->
unicode="&#59547;"
<!-- 定义图标对应的Unicode编码 -->
d="M800 704H640
<!-- 从坐标(800, 704)开始，水平移动到(640, 704) -->
c0 70.4-57.6 128-128 128
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示水平不移动，垂直上升70.4到128的高度变化 -->
s-128-57.6-128-128
<!-- 从上一点开始，使用对称的控制点绘制另一条三次贝塞尔曲线（或直线），表示垂直下降到原来的高度 -->
H224
<!-- 水平移动到(224, 704) -->
c-17.6 0-32-14.4-32-32
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示微小的水平移动和垂直下降32 -->
v-704
<!-- 垂直移动到(224, 0) -->
c0-17.6 14.4-32 32-32
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示微小的水平移动和垂直不变，但形成矩形的左下角 -->
h576
<!-- 水平移动到(800, 0) -->
c17.6 0 32 14.4 32 32
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示微小的水平移动和垂直上升32，形成矩形的右下角 -->
V672
<!-- 垂直移动到(800, 672) -->
c0 17.6-14.4 32-32 32
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示水平不移动，但垂直上升形成矩形的右上角 -->
z
<!-- 表示路径的结束，回到起始点，形成闭合路径（矩形） -->
m-288 32
<!-- 从上一个路径的结束点开始，水平向左移动288，准备绘制内部的小形状 -->
c17.6 0 32-14.4 32-32
<!-- 从上一点开始，绘制一条三次贝塞尔曲线（或直线），表示形成一个小圆形的上半部分 -->
s-14.4-32-32-32
<!-- 使用对称的控制点绘制另一条三次贝塞尔曲线（或直线），形成小圆形的下半部分 -->
s-32 14.4-32 32
<!-- 再次使用对称的控制点，但这次是为了回到原始高度，完成小圆形的绘制 -->
s14.4 32 32 32
<!-- 完成小圆形的闭合路径（虽然这里没有直接用Z命令，但通过连续的S命令实现了闭合） -->
z
<!-- 但由于S命令的连续性，这里的Z可能是隐含的或为了保持路径命令的一致性而添加的 -->
m64-608
<!-- 从上一个路径的结束点开始，向右移动64，准备绘制另一个形状 -->
H320
<!-- 水平移动到(320, -608)（但由于是相对于上一个点，且上一个点已经在某个高度，所以这里实际上是向左移动并垂直下降） -->
v64
<!-- 垂直移动到(320, -544) -->
h256
<!-- 水平移动到(576, -544) -->
v-64
<!-- 垂直移动到(576, -608)，形成一个矩形或条形的底部 -->
z
<!-- 表示路径的结束，但这里并没有回到起始点，因为是一个开放的-->
<glyph glyph-name="tijikongjian" unicode="&#59551;" d="M496 0.8L138.4 124.8c-6.4 2.4-10.4 8-10.4 15.2V608.8l368-112v-496z m32 0l357.6 124c6.4 2.4 10.4 8 10.4 15.2V608.8l-368-112v-496z m-400 640l384-112 384 112-379.2 125.6c-3.2 0.8-7.2 0.8-10.4 0L128 640.8z" horiz-adv-x="1024" />
<glyph glyph-name="morentouxiang" unicode="&#59593;"
d="M512 832
<!-- 设置圆心的x坐标，并定义该点为头像的顶部 -->
C264.8 832
<!-- 从圆心向左绘制一条贝塞尔曲线到左侧的点，该点位于顶部 -->
64 631.2
<!-- 从左侧的点向下绘制一条直线到左侧的底部点 -->
64 384
<!-- 从左侧的底部点向右绘制一条水平直线到右侧的底部点 -->
s200.8-448
<!-- 从右侧的底部点向上绘制一条对称的曲线到右侧的中间点 -->
448-448
<!-- 从右侧的中间点向左绘制一条直线到圆心的下侧点 -->
448 200.8
<!-- 从圆心的下侧点向上绘制一条直线到圆心的上侧点 -->
448 448
<!-- 从圆心的上侧点向右绘制一条直线到右侧的顶部点 -->
S759.2 832
<!-- 从右侧的顶部点向左绘制一条对称的曲线回到圆心 -->
512 832z
<!-- 关闭路径，形成一个完整的圆形头像 -->
M384.8 520
<!-- 设置新路径的起点，准备绘制眼睛或脸部特征 -->
c4 64
<!-- 从起点向右上方绘制一条贝塞尔曲线，模拟眼睛或脸部特征的上边缘 -->
56 115.2
<!-- 从上边缘的点继续向右上方绘制一条更长的贝塞尔曲线 -->
120 119.2
<!-- 到达眼睛或脸部特征的最右侧点 -->
74.4 4
<!-- 从最右侧点向左下方绘制一条较短的贝塞尔曲线，形成眼睛或脸部特征的下边缘的一部分 -->
135.2-55.2
<!-- 从下边缘的点继续向左下方绘制一条贝塞尔曲线，模拟眼睛或脸部的凹陷部分 -->
135.2-128
<!-- 到达眼睛或脸部特征的底部点 -->
0-70.4
<!-- 从底部点向上绘制一条垂直直线，模拟眼睛或脸部特征的垂直高度 */
-57.6-128
<!-- 从垂直高度的顶部点向左下方绘制一条直线，模拟另一只眼睛或脸部特征的左侧边缘 */
-128-128
<!-- 到达另一只眼睛或脸部特征的底部点 */
-73.6 0
<!-- 从另一只眼睛或脸部特征的底部点向右上方绘制一条直线，模拟脸部下半部分的宽度 */
-132 62.4
<!-- 从脸部下半部分的右侧点向左上方绘制一条贝塞尔曲线，模拟下巴的轮廓 */
-127.2 136.8z
<!-- 到达下巴的顶部点，并关闭路径，形成完整的眼睛或脸部特征 */
M768 149.6
<!-- 设置新路径的起点，准备绘制嘴巴或下巴下方的装饰物 -->
c0-12
<!-- 从起点向下绘制一条垂直直线，模拟嘴巴或下巴下方的装饰物的上边缘 */
-9.6-21.6
<!-- 从上边缘的点向左下方绘制一条直线，模拟装饰物的左侧边缘 */
-21.6-21.6
<!-- 到达装饰物的底部点 */
H278.4
<!-- 从底部点向左水平绘制一条直线，模拟装饰物的水平宽度 */
c-12 0
<!-- 从水平宽度的左侧点向右绘制一条垂直直线，模拟装饰物的右侧边缘 */
-21.6 9.6
<!-- 从右侧边缘的点向上绘制一条直线，模拟装饰物的下边缘 */
-21.6 21.6
<!-- 到达装饰物的顶部点 */
v64
<!-- 从顶部点向上垂直绘制一条直线，模拟装饰物的高度 */
c0 84.8
<!-- 从装饰物的高度的顶部点向右绘制一条水平直线，模拟下巴下方的空白区域 */
170.4 128
<!-- 从空白区域的右侧点向右上方绘制一条直线，模拟下巴下方的装饰物的右侧边缘 */
255.2 128
<!-- 到达装饰物的最右侧点 */
84.8 0
<!-- 从装饰物的最右侧点向左绘制一条水平直线，模拟装饰物的水平宽度 */
255.2-42.4
<!-- 从水平宽度的左侧点向左下方绘制一条直线，模拟下巴下方的空白区域的左侧边缘 */
255.2-128
<!-- 到达空白区域的底部点 */
l0.8-64z
<!-- 从空白区域的底部点向左下方绘制一条直线，并关闭路径，完成装饰物的绘制 */
horiz-adv-x="1024" />
<!-- 设置水平方向上的高级宽度为1024 -->
<glyph glyph-name="morentouxiang" unicode="&#59593;" d="M512 832C264.8 832 64 631.2 64 384s200.8-448 448-448 448 200.8 448 448S759.2 832 512 832zM384.8 520c4 64 56 115.2 120 119.2 74.4 4 135.2-55.2 135.2-128 0-70.4-57.6-128-128-128-73.6 0-132 62.4-127.2 136.8zM768 149.6c0-12-9.6-21.6-21.6-21.6H278.4c-12 0-21.6 9.6-21.6 21.6v64c0 84.8 170.4 128 255.2 128 84.8 0 255.2-42.4 255.2-128l0.8-64z" horiz-adv-x="1024" />
<glyph glyph-name="baobiao" unicode="&#59650;" d="M960 224V736c0 17.6-14.4 32-32 32H544V832h-64v-64H96c-17.6 0-32-14.4-32-32v-512c0-17.6 14.4-32 32-32h384v-50.4l-152.8-89.6 32-56 144 84h19.2l144-84 32 56L544 141.6V192h384c17.6 0 32 14.4 32 32z <!-- 绘制宝表图标的外框 -->
M790.4 640l41.6-48.8-316.8-270.4L352 458.4 233.6 359.2 192.8 408l160 133.6 163.2-137.6L790.4 640z" <!-- 绘制宝表图标内部的装饰线条 -->
horiz-adv-x="1024" /> <!-- 水平方向上的高级宽度设置为1024 -->
<glyph glyph-name="baobiao" unicode="&#59650;" d="M960 224V736c0 17.6-14.4 32-32 32H544V832h-64v-64H96c-17.6 0-32-14.4-32-32v-512c0-17.6 14.4-32 32-32h384v-50.4l-152.8-89.6 32-56 144 84h19.2l144-84 32 56L544 141.6V192h384c17.6 0 32 14.4 32 32zM790.4 640l41.6-48.8-316.8-270.4L352 458.4 233.6 359.2 192.8 408l160 133.6 163.2-137.6L790.4 640z" horiz-adv-x="1024" />
<glyph glyph-name="lock_fill" unicode="&#59145;" d="M394.304 579.392A124.672 124.672 0 0 0 518.72 704a124.704 124.704 0 0 0 124.48-124.608V480h-248.896V579.392zM544 192a32 32 0 0 0-64 0v128a32 32 0 0 0 64 0v-128z m256.256 288H707.2V579.392A188.736 188.736 0 0 1 518.72 768c-103.904 0-188.416-84.608-188.416-188.608V480h-106.56A64 64 0 0 1 160 415.904v-319.84A64 64 0 0 1 223.744 32h576.512A64 64 0 0 1 864 96.064v319.84A64 64 0 0 1 800.256 480z" horiz-adv-x="1024" />
<glyph glyph-name="lock_fill" unicode="&#59145;" d="M394.304 579.392A124.672 124.672 0 0 0 518.72 704a124.704 124.704 0 0 0 124.48-124.608V480h-248.896V579.392z <!-- 绘制锁的上半部分包括锁体和锁舌 -->
M544 192a32 32 0 0 0-64 0v128a32 32 0 0 0 64 0v-128z <!-- 绘制锁的中间部分，即锁芯 -->
m256.256 288H707.2V579.392A188.736 188.736 0 0 1 518.72 768c-103.904 0-188.416-84.608-188.416-188.608V480h-106.56A64 64 0 0 1 160 415.904v-319.84A64 64 0 0 1 223.744 32h576.512A64 64 0 0 1 864 96.064v319.84A64 64 0 0 1 800.256 480z" <!-- 绘制锁的下半部分，包括锁链 -->
horiz-adv-x="1024" /> <!-- 水平方向上的高级宽度设置为1024 -->

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 6.6 KiB

After

Width:  |  Height:  |  Size: 21 KiB

Write Preview
Loading…
Cancel
Save