apis-scf-nodejs
Version:
Apis Serverless Compute Function NodeJS Package
1,536 lines (1,400 loc) • 144 kB
JavaScript
//
const Apis = require( 'apis-core-nodejs' );
//
const { Sequelize, DataTypes } = require( 'sequelize' );
//
const sequelize = require( './connection' );
//
class ModelCore extends Sequelize.Model
{
/**
* 获取配置
* @returns {*}
*/
static getConfig()
{
return {
base : {
//模型名
model_name : '',
//模型介绍
model_comment : ''
},
logic : {
//类型；正常（横表）base，上下级（递归表）infinite，属性（竖表）attribute
type : '',
base : {},
infinite : {
infinite_parent_field : '',//上级id字段名，默认为0
infinite_status_field : '',//状态字段名，0停止，1正常
infinite_sort_field : '',//排序字段名，默认为1
virtual_tree_text_field : '',//树型结构text字段用对应的真实字段
virtual_tree_value_field : '',//树型结构value字段对应的真实字段
},
attribute : {
object_type_field : '',//绑定对象类型（固定）字段名
object_value_field : '',//绑定对象数据（固定）字段名
target_type_field : '',//绑定目标类型（固定）字段名
target_value_field : '',//绑定目标数据（固定）字段名
is_exclude_field : '',//绑定目标数据是否过滤（固定）字段名
}
},
dao : {
//表名
table_name : '',
//表字段
table_fields : [],
//主键
primary_key : '',
//插入
insert : {
//必须插入的字段
input_data_field : []
},
//更新
update : {
//允许作为where条件的字段
input_where_field : [],
//可以更新的字段
input_data_field : []
},
//删除
delete : {
//软删除，false真删除；true假删除
soft_delete : true,
//允许作为where条件的字段
input_where_field : []
},
//读取
read : {
//允许作为where条件的字段
input_where_field : [],
//输出需要隐藏的字段
output_hidden_field : []
},
//查询
search : {
//允许作为where条件的字段
input_where_field : {},
//输出需要隐藏的字段
output_hidden_field : []
},
//时间戳
timestamp : [],
//唯一值
unique : []
}
}
}
/**
* ==============================================================
* helper
* ==============================================================
*/
/**
* 日志
* @param data
* @param title
* @param level
* @private
*/
static _log( data, title = '', level = 'info' )
{
// 是否开启日志
if( CONFIG[ 'Base' ].log.enable === true )
{
Apis.Utils.Base.log( data, title, level );
}
}
/**
* 生成唯一参数
* @param uniqueData
* @returns {{_field_name: *}}
*/
static _buildUniqueParameter( uniqueData = '' )
{
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {};
//字段名
let _field_name;
//主键
let _pk = this.getConfig().dao.primary_key;
if( Apis.Utils.Base.check( 'unique', uniqueData ) )
{
//unique
if( _pk === 'id' )
{
//id 转 number
_field_name = _pk.replace( 'id', 'number' );
}
else
{
//user_idaa_id 转 user_idaa_number
_field_name = _pk.substring( 0, _pk.lastIndexOf( '_id' ) ) + '_number';
}
}
else if( Apis.Utils.Base.check( 'id', uniqueData ) )
{
//id
_field_name = _pk;
}
else if( Apis.Utils.Base.check( 'uuid', uniqueData ) )
{
//uuid
if( _pk === 'id' )
{
//id 转 uuid
_field_name = _pk.replace( 'id', 'uuid' );
}
else
{
//user_idaa_id 转 user_idaa_uuid
_field_name = _pk.substring( 0, _pk.lastIndexOf( '_id' ) ) + '_uuid';
}
}
else
{
this._log( uniqueData, '生成唯一值条件错误', 'error' );
throw new Error( '生成唯一值条件错误' );
}
//赋值
_result[ _field_name ] = uniqueData;
return _result;
};
/**
* 时间戳字段转换
* @param name
* @param data
* @returns {Promise<*>}
* @private
*/
static async _timestampFieldsFormat( name, data )
{
//时间戳字段
let _timestamp_field = this.getConfig().dao.timestamp;
//不是时间戳字段，原样返回数据
if( _timestamp_field.indexOf( name ) === -1 )
{
return data;
}
//如果是时间戳，直接返回
let _rule = /\d{10}/;
if( _rule.test( data ) )
{
return data;
}
//格式['2012-07-12','2013-08-19']
if( typeof (data) === 'object' )
{
data[ 0 ] = Apis.Utils.Time.toTimestamp( data[ 0 ] );
data[ 1 ] = Apis.Utils.Time.toTimestamp( data[ 1 ] );
}
//
if( typeof (data) === 'string' )
{
//格式'2012-07-12'|'2013-08-19'
if( data.indexOf( '|' ) !== -1 )
{
//1、字符串转数组，11111|22222 转 [11111,22222]
let _temp_array = data.split( '|' );
this._log( _temp_array, '参数转时间戳-1' );
//2、数组值转时间戳
let _time_array = {};
for( let i = 0; i < _temp_array.length; i++ )
{
_time_array.push( Apis.Utils.Time.toTimestamp( _temp_array[ i ] ) );
}
this._log( _time_array, '参数转时间戳-2' );
//3、数组转字符串，[11111,22222] 转 11111|22222
data = _time_array.join( '|' );
this._log( data, '参数转时间戳-3' );
}
else
{
//转时间戳
data = Apis.Utils.Time.toTimestamp( data );
this._log( '参数转时间戳-4（' + data + '）' );
}
}
else
{
//转时间戳
data = Apis.Utils.Time.toTimestamp( data );
this._log( '参数转时间戳-5（' + data + '）' );
}
return data;
}
/**
* 时间戳转日期时间
* @param dataObject
* @param format
* @returns {Promise<void>}
* @private
*/
static async _timestampFieldsToDateTime( dataObject = {}, format = 'YYYY-MM-DD HH:mm:ss' )
{
//时间戳字段
let _timestamp_field = this.getConfig().dao.timestamp;
let _result = {};
for( let key in dataObject )
{
if( !dataObject.hasOwnProperty( key ) )
{
continue;
}
if( _timestamp_field.indexOf( key ) !== -1 && Number( dataObject[ key ] ) > 0 )
{
_result[ key ] = Apis.Utils.Time.format( format, dataObject[ key ] );
}
else
{
_result[ key ] = dataObject[ key ];
}
}
return _result;
};
/**
* 参数格式化成标准格式
* @param dataObject
* @returns {*}
* {
aaa:['in',['123','456']],
bbb:['between','2018-01-01|2018-12-30'],
ccc:['between',['2018-01-01','2018-12-30']],
ddd:['=','dsdsds'],
eee:999,
or:{
aaa:['in',['123','456']],
bbb:['between','2018-01-01|2018-12-30'],
ccc:['between',['2018-01-01','2018-12-30']],
ddd:['=','dsdsds'],
eee:999,
}
}
*/
static async _parameterFormat( dataObject = {} )
{
//判断是否为空
if( Object.keys( dataObject ).length === 0 )
{
return dataObject;
}
for( let key in dataObject )
{
if( !dataObject.hasOwnProperty( key ) )
{
continue;
}
if( Object.prototype.toString.call( dataObject[ key ] ) === '[object Object]' )
{
//递归并把key换成运算符
dataObject[ [ Sequelize.Op[ key ] ] ] = await this._parameterFormat( dataObject[ key ] );
}
else
{
//转换
dataObject[ key ] = await this._parameterFormatOnce( key, dataObject[ key ] );
}
}
//this._log( dataObject, '参数转换结果' );
return dataObject;
}
/**
* 参数格式化成标准格式
* 入格式：
* id,['=',['123','456']]
* id,['=','dsdsds']
* id,999
* 出格式：
* { OP.gt: 10 }
* @param name
* @param data
*/
static async _parameterFormatOnce( name, data )
{
//**********************************************************/
//变量
//**********************************************************/
let _result = {};
let _name = name;
let _value;
let _condition;
//定义条件和值
if( Object.prototype.toString.call( data ) === '[object Array]' )
{
_condition = data[ 0 ];
_value = data[ 1 ];
}
else
{
_condition = '=';
_value = data;
}
//转时间戳
_value = await this._timestampFieldsFormat( _name, _value );
//某些时候值转数组
if( _condition === 'between' || _condition === 'notBetween' || _condition === 'in' || _condition === 'notIn' )
{
if( typeof (_value) === 'string' )
{
//字符串转数组
if( _value.indexOf( '|' ) !== -1 )
{
_value = _value.split( '|' );
}
//
if( _value.indexOf( ',' ) !== -1 )
{
_value = _value.split( ',' );
}
}
}
switch( _condition )
{
case '>':
_result = { [ Sequelize.Op.gt ] : Apis.Utils.String.trim( _value ) };
break;
case '>=':
_result = { [ Sequelize.Op.gte ] : Apis.Utils.String.trim( _value ) };
break;
case '<':
_result = { [ Sequelize.Op.lt ] : Apis.Utils.String.trim( _value ) };
break;
case '<=':
_result = { [ Sequelize.Op.lte ] : Apis.Utils.String.trim( _value ) };
break;
case '<>':
_result = { [ Sequelize.Op.ne ] : Apis.Utils.String.trim( _value ) };
break;
case '=':
_result = { [ Sequelize.Op.eq ] : Apis.Utils.String.trim( _value ) };
break;
case 'like':
_result = { [ Sequelize.Op.like ] : '%' + Apis.Utils.String.trim( _value ) + '%' };
break;
case 'rightLike':
_result = { [ Sequelize.Op.like ] : Apis.Utils.String.trim( _value ) + '%' };
break;
case 'leftLike':
_result = { [ Sequelize.Op.like ] : '%' + Apis.Utils.String.trim( _value ) };
break;
case 'notLike':
_result = { [ Sequelize.Op.notLike ] : '%' + Apis.Utils.String.trim( _value ) + '%' };
break;
case 'between':
_result = { [ Sequelize.Op.between ] : _value };
break;
case 'notBetween':
_result = { [ Sequelize.Op.notBetween ] : _value };
break;
case 'in':
_result = { [ Sequelize.Op.in ] : _value };
break;
case 'notIn':
_result = { [ Sequelize.Op.notIn ] : _value };
break;
default:
this._log( _condition, '发现不明条件，拒绝查询', 'error' );
throw new Error( '发现不明条件，拒绝查询' );
}
return _result;
}
/**
* 根据场景过滤数据
* @param dataObject
* @param scene
* @returns {Promise<*>}
*/
static async _filterFields( dataObject = {}, scene = 'pass' )
{
//**********************************************************/
//变量
//**********************************************************/
//场景
let _scene = scene;
//场景字段
let _scene_fields;
//**********************************************************/
//排除非数据库字段
//**********************************************************/
let _table_fields = this.getConfig().dao.table_fields;
for( let key in dataObject )
{
if( !dataObject.hasOwnProperty( key ) )
{
continue;
}
if( _table_fields.indexOf( key ) === -1 )
{
this._log( '发现非数据库字段(' + key + ')，场景(' + _scene + ')，方案（排除）' );
//删除
delete dataObject[ key ];
}
}
//**********************************************************/
//场景处理
//**********************************************************/
switch( _scene )
{
case 'insert':
_scene_fields = this.getConfig().dao.insert.input_data_field;
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的字段参与创建' );
throw new Error( '没有允许的字段参与创建' );
}
//过滤场景未指定的字段
dataObject = Apis.Utils.ArrayObject.reserveObjectAttribute( dataObject, _scene_fields );
//检测必须字段是否存在
for( let i = 0; i < _scene_fields.length; i++ )
{
if( !dataObject.hasOwnProperty( _scene_fields[ i ] ) )
{
this._log( '插入数据（' + _scene_fields[ i ] + '）不存在，场景(' + _scene + ')，方案（抛出异常）' );
throw new Error( '插入数据（' + _scene_fields[ i ] + '）不存在' );
}
}
break;
case 'update.where':
_scene_fields = this.getConfig().dao.update.input_where_field;
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的条件参与更新' );
throw new Error( '没有允许的条件参与更新' );
}
//过滤场景未指定的字段
dataObject = Apis.Utils.ArrayObject.reserveObjectAttribute( dataObject, _scene_fields );
break;
case 'update.data':
_scene_fields = this.getConfig().dao.update.input_data_field;
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的字段参与更新' );
throw new Error( '没有允许的字段参与更新' );
}
//过滤场景未指定的字段
dataObject = Apis.Utils.ArrayObject.reserveObjectAttribute( dataObject, _scene_fields );
break;
case 'read':
_scene_fields = this.getConfig().dao.read.input_where_field;
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的字段参与读取' );
throw new Error( '没有允许的字段参与读取' );
}
//过滤场景未指定的字段
dataObject = Apis.Utils.ArrayObject.reserveObjectAttribute( dataObject, _scene_fields );
break;
case 'delete':
_scene_fields = this.getConfig().dao.delete.input_where_field;
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的字段参与删除' );
throw new Error( '没有允许的字段参与删除' );
}
//保留场景指定的字段
dataObject = Apis.Utils.ArrayObject.reserveObjectAttribute( dataObject, _scene_fields );
break;
case 'search':
_scene_fields = Object.keys( this.getConfig().dao.search.input_where_field );
//判断场景字段是否为空
if( _scene_fields.length === 0 )
{
this._log( '没有允许的字段参与查询' );
throw new Error( '没有允许的字段参与查询' );
}
for( let key in dataObject )
{
if( !dataObject.hasOwnProperty( key ) )
{
continue;
}
//过滤场景未指定的字段
if( _scene_fields.indexOf( key ) === -1 )
{
//不存在，删除
delete dataObject[ key ];
}
else
{
//存在，转换格式
dataObject[ key ] = [
this.getConfig().dao.search.input_where_field[ key ].condition,
dataObject[ key ]
];
this._log( dataObject[ key ], 'search参数绑定条件' );
}
}
break;
default:
break;
}
//判断过滤后是否为空（排除search）
if( 'search' !== _scene && Object.keys( dataObject ).length === 0 )
{
this._log( '过滤字段后数据对象为空，场景(' + _scene + ')，方案（抛出异常）' );
throw new Error( '过滤字段后数据对象为空' );
}
return dataObject;
};
/**
* 检查唯一值是否存在
* @param dataObject
* @returns {Promise<boolean>}
* @private
*/
static async _checkUniqueExist( dataObject = {} )
{
//判断是否为空
if( Object.keys( dataObject ).length === 0 )
{
return false;
}
//**********************************************************/
//变量
//**********************************************************/
//data
let _data = dataObject;
//唯一值字段
let _unique_field = this.getConfig().dao.unique;
for( let key in _data )
{
if( !_data.hasOwnProperty( key ) )
{
continue;
}
//判断字段是否是唯一值
if( _unique_field.indexOf( key ) !== -1 )
{
let _temp_where = {};
_temp_where[ key ] = _data[ key ];
let _temp_result = await this.checkData( _temp_where );
if( Apis.Utils.Base.checkSuccess( _temp_result ) )
{
return true;
}
}
}
return false;
}
/**
* ==============================================================
* DAO
* ==============================================================
*/
/**
* add
* @param dataObject
* @param options
* @returns {Promise<{result: {}, message: string, status: boolean}>}
*/
static async addData( dataObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( dataObject ).length === 0 )
{
this._log( '插入操作，数据不能为空' );
throw new Error( '插入操作，数据不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '新增数据完成',
result : {}
};
//data
let _data = dataObject;
//配置
let _options = options;
//**********************************************************/
//data
//**********************************************************/
//转换时间字段
for( let key in _data )
{
if( !_data.hasOwnProperty( key ) )
{
continue;
}
_data[ key ] = await this._timestampFieldsFormat( key, _data[ key ] );
}
//追加赋值（时间戳）
_data.create_time = Apis.Utils.Time.getTimestamp();
_data.update_time = 0;
_data.delete_time = 0;
//检测唯一值
let _check_unique = await this._checkUniqueExist( _data );
if( Apis.Utils.Base.checkSuccess( _check_unique ) )
{
this._log( '插入操作，唯一值不能重复' );
throw new Error( '插入操作，唯一值不能重复' );
}
//**********************************************************/
//操作
//**********************************************************/
this._log( _data, '插入数据' );
await this.create( _data, _options )
.then( res =>
{
if( res === null )
{
_result.message = '新增数据失败';
}
else
{
_result.status = true;
_result.result = res.get( { plain : true } );//通过设置plain:true来直接获取文档数据
_result.message = '新增数据完成';
}
} )
.catch( err =>
{
this._log( err, 'addData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* add multiple
* @param dataArray
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async addMultipleData( dataArray = [], options = {} )
{
//判断是否为空
if( dataArray.length === 0 )
{
this._log( '批量插入操作，数据不能为空' );
throw new Error( '批量插入操作，数据不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
let _result = {
status : false,
message : '批量新增数据完成',
result : 0
};
//data
let _data = dataArray;
//配置
let _options = options;
//**********************************************************/
//data
//**********************************************************/
let _temp_data = [];
for( let i = 0; i < _data.length; i++ )
{
let _temp_item = _data[ i ];
//转换时间字段
for( let key in _temp_item )
{
if( !_temp_item.hasOwnProperty( key ) )
{
continue;
}
_temp_item[ key ] = await this._timestampFieldsFormat( key, _temp_item[ key ] );
}
//检测唯一值
let _check_unique = await this._checkUniqueExist( _temp_item );
if( Apis.Utils.Base.checkSuccess( _check_unique ) )
{
this._log( _temp_item, '批量插入数据，数据唯一值重复，方案（跳过）' );
}
else
{
//追加赋值（时间戳）
_temp_item.create_time = Apis.Utils.Time.getTimestamp();
_temp_item.update_time = 0;
_temp_item.delete_time = 0;
//通过唯一值检测在追加到数据
_temp_data.push( _temp_item );
}
}
//再次覆盖赋值
_data = _temp_data;
//**********************************************************/
//操作
//**********************************************************/
this._log( _data, '批量插入数据' );
await this.bulkCreate( _data, _options )
.then( res =>
{
if( Number( res.length ) >= 1 )
{
_result.status = true;
_result.result = Number( res.length );
_result.message = '批量新增数据完成';
}
else
{
_result.message = '批量新增数据失败';
}
} )
.catch( err =>
{
this._log( err, 'addMultipleData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* edit
* @param whereObject
* @param dataObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async editData( whereObject = {}, dataObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '插入操作，条件不能为空' );
}
//判断是否为空
if( Object.keys( dataObject ).length === 0 )
{
throw new Error( '插入操作，数据不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '更新数据完成',
result : 0
};
//where
let _where = whereObject;
//data
let _data = dataObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//data
//**********************************************************/
//转换时间字段
for( let key in _data )
{
if( !_data.hasOwnProperty( key ) )
{
continue;
}
_data[ key ] = await this._timestampFieldsFormat( key, _data[ key ] );
}
//追加赋值（时间戳）
_data.update_time = Apis.Utils.Time.getTimestamp();
//检测唯一值
let _check_unique = await this._checkUniqueExist( _data );
if( Apis.Utils.Base.checkSuccess( _check_unique ) )
{
throw new Error( '更新操作，唯一值不能重复' );
}
//**********************************************************/
//配置
//**********************************************************/
//where
_options.where = _where;
//
_options.individualHooks = true;
//**********************************************************/
//操作
//**********************************************************/
this._log( _data, '更新数据' );
await this.update( _data, _options )
.then( res =>
{
/*
[
1,
[
{"bbb_ccc":"南京南京南京444444-1[41]","id":41,"create_time":1580823530}
]
]
*/
if( res.length >= 1 && res[ 0 ] >= 1 )
{
//结果赋值
_result.status = true;
_result.result = Number( res[ 0 ] );//影响的数量
_result.message = '更新数据完成';
}
else
{
_result.message = '更新数据失败';
}
} )
.catch( err =>
{
this._log( err, 'editData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* delete
* @param whereObject
* @param options
* @returns {Promise<{result, message, status}|*>}
*/
static async deleteData( whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '删除操作，条件不能为空' );
}
//软删除
if( this.getConfig().dao.delete.soft_delete )
{
//软删除
return await this._softDeleteData( whereObject, options );
}
else
{
//真删除
return await this._realDeleteData( whereObject, options );
}
};
static async _realDeleteData( whereObject = {}, options = {} )
{
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '删除数据完成',
result : 0
};
//where
let _where = whereObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//强制删除
_options.force = false;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '删除条件' );
await this.destroy( _options )
.then( res =>
{
if( Number( res ) >= 1 )
{
_result.status = true;
_result.result = Number( res );//影响的数量
_result.message = '删除数据完成';
}
else
{
_result.message = '删除数据失败';
}
} )
.catch( err =>
{
this._log( err, '_realDeleteData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
static async _softDeleteData( whereObject = {}, options = {} )
{
//**********************************************************/
//变量
//**********************************************************/
let _where = whereObject;
let _options = options;
//**********************************************************/
//data
//**********************************************************/
let _data = {
delete_time : Apis.Utils.Time.getTimestamp()
};
//**********************************************************/
//操作
//**********************************************************/
return await this.editData( _where, _data, _options );
};
/**
* read
* @param whereObject
* @param options
* @returns {Promise<{result: {}, message: string, status: boolean}>}
*/
static async readData( whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '读取操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '读取数据完成',
result : {}
};
//where
let _where = whereObject;
//配置
let _options = options;
//主键
let _pk = this.getConfig().dao.primary_key;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//排序
if( !_options.hasOwnProperty( 'order' ) )
{
_options.order = [
[
_pk,
'DESC'
]
]
}
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '读取条件' );
await this.findOne( _options )
.then( res =>
{
if( res === null )
{
_result.message = '读取数据失败';
}
else
{
_result.status = true;
_result.message = '读取数据完成';
_result.result = res.get( { plain : true } );//通过设置plain:true来直接获取文档数据
}
} )
.catch( err =>
{
this._log( err, 'readData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* rand
* @param whereObject
* @param limit
* @param options
* @returns {Promise<{result: {}, message: string, status: boolean}>}
*/
static async randData( whereObject = {}, limit = 1, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '随机操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '随机数据完成',
result : {}
};
//where
let _where = whereObject;
//数量
let _limit = Number( limit );
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//排序
_options.order = [ [ Sequelize.literal( 'rand()' ) ] ];
//数量
_options.limit = _limit;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, 'rand读取条件' );
await this.findAll( _options )
.then( res =>
{
_result.status = true;
_result.result = res;
} )
.catch( err =>
{
this._log( err, 'randData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* count
* @param whereObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async countData( whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '统计操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '统计数据完成',
result : 0
};
//where
let _where = whereObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '统计条件' );
await this.count( _options )
.then( res =>
{
_result.status = true;
_result.result = Number( res );
} )
.catch( err =>
{
this._log( err, 'countData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* check
* @param whereObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async checkData( whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '检测操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '检测数据完成',
result : 0
};
//
let _action = await this.countData( whereObject, options );
if( Apis.Utils.Base.checkSuccess( _action ) && Number( _action.result ) >= 1 )
{
_result.status = true;
_result.result = Number( _action.result );
}
return _result;
};
/**
* sum
* @param field
* @param whereObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async sumData( field, whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '求和操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '求和数据完成',
result : 0
};
//where
let _where = whereObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '求和条件' );
await this.sum( field, _options )
.then( res =>
{
_result.status = true;
_result.result = Number( res );
} )
.catch( err =>
{
this._log( err, 'sumData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* max
* @param field
* @param whereObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async maxData( field, whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '最大值操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '获取数据MAX完成',
result : 0
};
//where
let _where = whereObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '取max条件' );
await this.max( field, _options )
.then( res =>
{
_result.status = true;
_result.result = Number( res );
} )
.catch( err =>
{
this._log( err, 'maxData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* min
* @param field
* @param whereObject
* @param options
* @returns {Promise<{result: number, message: string, status: boolean}>}
*/
static async minData( field, whereObject = {}, options = {} )
{
//判断是否为空
if( Object.keys( whereObject ).length === 0 )
{
throw new Error( '最小值操作，条件不能为空' );
}
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '获取数据MIN完成',
result : 0
};
//where
let _where = whereObject;
//配置
let _options = options;
//**********************************************************/
//where
//**********************************************************/
//转换成标准格式
_where = await this._parameterFormat( _where );
//**********************************************************/
//options
//**********************************************************/
//where
_options.where = _where;
//**********************************************************/
//操作
//**********************************************************/
this._log( _options.where, '取min条件' );
await this.min( field, _options )
.then( res =>
{
_result.status = true;
_result.result = Number( res );
} )
.catch( err =>
{
this._log( err, 'minData操作错误', 'error' );
throw new Error( err.message );
} );
//**********************************************************/
//返回
//**********************************************************/
return _result;
};
/**
* search
* @param dataObject
* @param scope
* @param options
* @returns {Promise<{result: {total: number, data: [], page_limit: number, total_page: number, current_page: number}, message: string, status: boolean}>}
*/
static async searchData( dataObject = {}, scope = null, options = {} )
{
//**********************************************************/
//变量
//**********************************************************/
//结果
let _result = {
status : false,
message : '查询数据完成',
result : {
data : [],
total : 0,
total_page : 1,
current_page : 1,
page_limit : 20
}
};
//主键
let _pk = this.getConfig().dao.primary_key;
//数据总数
let _total_data = 0;
//页面总数
let _total_page = 1;
//where
let _where = (dataObject.hasOwnProperty( 'where' ))
? dataObject.where
: {};
//每页数量
let _limit = (dataObject.hasOwnProperty( 'limit' ))
? Number( dataObject.limit )
: 20;
//当前页数
let _page = (dataObject.hasOwnProperty( 'page' ))
? Number( dataObject.page )
: 1;
//排序字段
let _sort_by = (dataObject.hasOwnProperty( 'sort_by' ))