@ -1,141 +1,191 @@
var path = require ( "path" ) ;
// 引入 Node.js 的 path 模块，用于处理文件和目录的路径
// 获取数据库模型
// 获取数据库模型 ，通过 path.join 拼接当前工作目录和相对路径来引入模块
databaseModule = require ( path . join ( process . cwd ( ) , "modules/database" ) ) ;
// process.cwd() 获取当前工作目录，
// 引入自定义的 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 ] ;
// 从 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 ] ;
// 从 databaseModule 中获取数据库对象
var db = databaseModule . getDatabase ( ) ; // 获取整个数据库实例或连接
if ( ! model ) return cb ( "模型不存在" , null ) ;
// 根据模型名称获取相应的模型
var model = db . models [ modelName ] ; // 从数据库实例的 models 属性中，根据传入的模型名称获取对应的模型
// 如果模型不存在，调用回调函数并传递错误信息
if ( ! model ) return cb ( "模型不存在" , null ) ; // 如果模型未找到，则立即返回错误信息给回调函数
// 初始化查询模型为 find 方法，表示要执行查询操作
var queryModel = model . find ( ) ; // 默认执行全表查询，后续根据条件进行筛选
// 如果存在查询条件，则根据条件进行相应的查询操作
if ( conditions ) {
// 如果指定了需要查询的字段条件
if ( conditions [ "columns" ] ) {
model = model . find ( conditions [ "columns" ] ) ;
} else {
model = model . find ( ) ;
queryModel = queryModel . find ( conditions [ "columns" ] ) ; // 根据字段条件进行精确查询
}
// 如果指定了数据偏移量，用于分页查询
if ( conditions [ "offset" ] ) {
model = m odel. offset ( parseInt ( conditions [ "offset" ] ) ;
queryModel = queryM odel. offset ( parseInt ( conditions [ "offset" ] , 10 )) ; // 解析偏移量为整数，并设置到查询模型中
}
// 如果指定了查询数量限制
if ( conditions [ "limit" ] ) {
model = m odel. limit ( parseInt ( conditions [ "limit" ] ) ;
queryModel = queryM odel. limit ( parseInt ( conditions [ "limit" ] , 10 )) ; // 解析限制数量为整数，并设置到查询模型中
}
// 如果指定了只需要查询的字段列表
if ( conditions [ "only" ] ) {
model = m odel. only ( conditions [ "only" ] ) ;
queryModel = queryM odel. only ( conditions [ "only" ] ) ; // 设置查询模型中只返回这些字段
}
// 如果指定了要排除的字段列表
if ( conditions [ "omit" ] ) {
model = m odel. omit ( conditions [ "omit" ] ) ;
queryModel = queryM odel. omit ( conditions [ "omit" ] ) ; // 设置查询模型中排除这些字段
}
// 如果指定了排序条件
if ( conditions [ "order" ] ) {
model = model . order ( conditions [ "order" ] ) ;
queryModel = queryModel . order ( conditions [ "order" ] ) ; // 根据排序条件设置查询模型的排序方式
}
}
// 执行查询操作，并将结果传递给回调函数
queryModel . exec ( cb ) ; // 执行查询，并通过回调函数返回结果
} else {
// 如果没有指定查询条件，则执行全表查询
model = model . find ( ) ;
}
model . run ( function ( err , models ) {
// 执行查询操作并处理结果，通过回调函数返回查询结果或错误信息
model . run ( function ( err , models ) { // 注意： ，
if ( err ) {
console . log ( err ) ;
return cb ( "查询失败" , null ) ;
// 如果查询过程中发生错误，打印错误信息并通过回调函数返回错误
console . log ( err ) ; // 在生产环境中，通常不会直接打印错误到控制台，而是记录到日志文件中
return cb ( "查询失败" , null ) ; // 立即返回错误信息给回调函数，不继续执行后续代码
}
cb ( null , models ) ;
// 如果查询成功，将查询结果通过回调函数返回
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 ) ;
}
// 如果计数成功，将结果（符合条件的记录数）通过回调函数返回
cb ( null , count ) ; // 第一个参数为null表示没有错误，
} ;
// 根据传入的条件执行计数操作
if ( conditions ) {
// 如果指定了查询条件
if ( conditions [ "columns" ] ) {
model = model . count ( conditions [ "columns" ] , resultCB ) ;
// 如果条件中包含了字段条件，则根据这些条件进行计数
model = model . count ( conditions [ "columns" ] , resultCB ) ; // 注意： ，
} else {
model = model . count ( resultCB ) ;
// 如果没有指定字段条件，则执行全表计数
model . count ( resultCB ) ; // 注意： ， ，
}
} else {
model = model . count ( resultCB ) ;
// 如果没有指定任何条件，则执行全表计数
model . count ( resultCB ) ; // 同上，
}
// 注意： ， （ ） ，
// 正确的做法应该是直接调用count方法并传入回调函数，
} ;
/ * *
* 获取一条数据
* @ param { [ type ] } modelName 模型名称
* @ param { [ 数组 ] } conditions 条件集合
* @ param { Function } cb 回调函数
* @ param { [ type ] } modelName 模型名称 ， 用于指定要查找的模型 ， 该名称应与数据库中定义的模型名称一致
* @ param { [ 数组 / 对象 ] } conditions 条件集合 ， 包含查找该条数据的具体条件 ， 可以是对象形式或查询构造器
* @ param { Function } cb 回调函数 ， 用于处理查找结果 ， 第一个参数为错误信息 （ 如有 ） ， 第二个参数为找到的数据对象
* /
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框架提供的，
// 如果找不到符合条件的数据，
Model . one ( conditions , function ( err , obj ) {
// 使用日志记录器记录可能出现的错误，这里使用的是 debug 级别，表示一般性的调试信息
// 在生产环境中，可能需要根据错误类型调整日志级别，比如使用 error 级别记录严重错误
logger . debug ( err ) ;
// 如果查询过程中发生错误，通过回调函数返回错误信息，并终止后续操作
if ( err ) {
return cb ( "查询失败" , null ) ;
}
// 如果查询成功，将找到的数据对象通过回调函数返回
return cb ( null , obj ) ;
} ) ;
}
@ -143,30 +193,53 @@ module.exports.findOne = function(modelName,conditions,cb) {
/ * *
* 更新对象数据
*
* @ 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 ) {
// 从 databaseModule 模块中获取数据库连接或实例对象
var db = databaseModule . getDatabase ( ) ;
// 根据传入的模型名称从数据库实例的models属性中获取对应的模型类
var Model = db . models [ modelName ] ;
// 根据提供的 ID 获取要更新的数据对象
// 注意：这里的 get 方法可能是特定ORM框架提供的，
// 在某些框架中，可能需要使用 findById 或类似的方法
Model . get ( id , function ( err , obj ) {
// 如果获取数据对象过程中发生错误， ， ，
if ( err ) return cb ( "更新失败" , null ) ;
// 如果成功获取到数据对象，则调用其 save 方法更新数据
// 注意：这里的 save 方法可能是特定ORM框架提供的，
// save 方法通常会接受一个回调函数，用于处理保存操作的结果
obj . save ( updateObj , cb ) ;
// 注意： ， （ ）
// 因此，这里的代码可能需要根据实际使用的数据库库或框架进行调整
} ) ;
}
/ * *
* 通过主键 ID 获取对象
* @ param { [ type ] } modelName 模型名称
* @ param { [ type ] } id 主键 ID
* @ param { Function } cb 回调函数
* @ param { [ type ] } modelName 模型名称 ， 用于指定要查找的模型 ， 该名称应与数据库中定义的模型名称一致
* @ param { [ type ] } id 主键 ID， 用于唯一确定要查找的具体数据记录
* @ param { Function } cb 回调函数 ， 用于处理查找结果 ， 第一个参数为错误信息 （ 如有 ） ， 第二个参数为找到的数据对象 （ 如有 ）
* /
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 ) ;
} ) ;
}
@ -174,17 +247,31 @@ module.exports.show = function(modelName,id,cb) {
/ * *
* 通过主键 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 ) {
// 从名为 databaseModule 的模块中获取数据库连接或实例对象
var db = databaseModule . getDatabase ( ) ;
// 根据传入的模型名称从数据库实例的 models 属性中获取对应的模型类
var Model = db . models [ modelName ] ;
// 使用模型类的 get 方法根据提供的主键 ID 获取要删除的数据对象
// 注意：在某些 ORM 框架中，可能不需要先获取对象再删除，而是可以直接根据 ID 删除
// 但这里的代码示例遵循了先获取对象再删除的模式，可能是为了演示或特定框架的要求
Model . get ( id , function ( err , obj ) {
if ( err ) return cb ( "无模型ID" ) ;
// 如果获取对象过程中发生错误（比如 ID 不存在），则通过回调函数返回错误信息
if ( err ) return cb ( "无模型 ID" ) ; // 注意：这里的错误信息可能不够具体，实际应用中应提供更详细的错误信息
// 调用数据对象的 remove 方法删除该对象
// remove 方法通常也接受一个回调函数，用于处理删除过程中的结果或错误
obj . remove ( function ( err ) {
if ( err ) return cb ( "删除失败" ) ;
// 如果删除过程中发生错误，则通过回调函数返回错误信息
if ( err ) return cb ( "删除失败" ) ; // 同样，这里的错误信息可能不够具体
// 如果删除成功，则通过回调函数返回 null（ ） ，
return cb ( null ) ;
} ) ;
} ) ;
@ -193,32 +280,69 @@ module.exports.destroy = function(modelName,id,cb) {
/ * *
* 通过模型名称获取数据库数量
*
* @ param { [ type ] } modelName 模型名称
* @ param { Function } cb 回调函数
* @ param { [ type ] } modelName 模型名称 ， 用于指定要统计数量的模型 ， 该名称应与数据库中定义的模型名称一致
* @ param { Function } cb 回调函数 ， 用于处理统计结果 ， 第一个参数为错误信息 （ 如有 ） ， 第二个参数为统计得到的数量
* /
module . exports . count = function ( modelName , cb ) {
// 从名为 databaseModule 的模块中获取数据库连接或实例对象
var db = databaseModule . getDatabase ( ) ;
// 根据传入的模型名称从数据库实例的 models 属性中获取对应的模型类
var Model = db . models [ modelName ] ;
Model . count ( cb ) ;
}
// 调用模型类的 count 方法统计该模型对应的数据记录数量
// count 方法通常不接受条件参数（除非特定框架支持），直接统计所有记录的数量
// 它也接受一个回调函数，用于处理统计过程中的结果或错误
Model . count ( function ( err , count ) {
// 注意：这里的回调函数应该有两个参数，但原代码中的 cb 调用只传递了一个（ ）
// 为了保持注释的准确性，我假设原代码是一个简化或错误的示例，并在此处修正
// 正确的调用应该是 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 回调函数
通过条件判断数据是否存在
@ 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 ) ;
// 从 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 ) ; // 如果没有错误，则通过回调函数返回数据是否存在的布尔值
} ) ;
}
/ * *
获取指定名称的模型
@ param { [ type ] } modelName 模型名 ， 用于指定要获取的模型
@ return { [ type ] } 返回指定名称的模型对象
* /
module . exports . getModel = function ( modelName ) {
var db = databaseModule . getDatabase ( ) ;
return db . models [ modelName ] ;
// 从 databaseModule 中获取数据库对象
var db = databaseModule . getDatabase ( ) ; // 获取全局数据库对象，用于后续操作
// 根据模型名称获取相应的模型
return db . models [ modelName ] ; // 从数据库对象中，通过模型名称获取到具体的模型，并返回该模型对象
}
