fix bug

app/controllers/player.js

@@ -166,11 +166,11 @@ proto.createAsync = P.coroutine(function* (playerId, name, sex, headurl,tel,pwd,
 
     let _spreadId = '99999999';////系统
     let _myurl = 'http://fhmj.jzb518.com/';
-    if (spreadId) 
+    if (spreadId)
     {
         _spreadId=spreadId;////20200918TL++,把下面那行放在这里了
         var spreader = yield this.app.models.Player.findByIdReadOnlyAsync(spreadId,'myurl');
-        if (spreader) 
+        if (spreader)
         {
             // _spreadId=spreadId;
             _myurl=spreader.myurl;
@@ -192,7 +192,7 @@ proto.createAsync = P.coroutine(function* (playerId, name, sex, headurl,tel,pwd,
         headurl: playerId+".png" || '',
         spreadId: _spreadId || '',
         formId: formId
-        //myurl: _myurl || 'http://fhmj.jzb518.com/',       
+        //myurl: _myurl || 'http://fhmj.jzb518.com/',
     });
     yield player.saveAsync();
 
@@ -248,7 +248,7 @@ proto.sendMailOnLoginAsync = P.coroutine(function* (playerId,userId) {
     if(!playerId || !userId) return;
     let jrStart = getTodaySJC();////更新今日0时的时间戳
     // console.warn("玩家登陆的时候给玩家发邮件   jrStart   "+jrStart);
-    let opts0 = { 
+    let opts0 = {
         pId: playerId,
         isSend: 0,
         dayTime: { $gte: jrStart-86400000, $lt: jrStart}
@@ -299,7 +299,7 @@ proto.connectAsync = P.coroutine(function* (playerId,name,headurl, connectorId,
     //记录玩家登陆信息
     // console.warn('player ' + playerId )
     let jrStart = getTodaySJC();////更新今日0时的时间戳
-    let opts1 = { 
+    let opts1 = {
         playerId: playerId,
         loginTime: { $gte: jrStart, $lt: jrStart+86400000}
     };

app/models/game.js

@@ -2,250 +2,251 @@
 
 module.exports = function (app) {
     var mdbgoose = app.memdb.goose;
-	var Types = mdbgoose.Schema.Types;
-
-	// // ts++房间创建记录
- //    var CTableRecordSchema = new mdbgoose.Schema({
- //        _id: { type: String },                              // 房间标识
- //        playerId: { type: String, default: '' },            // 玩家标识
- //        registerTime: { type: Number, default: Date.now }   // 记录时间
- //    }, { collection: 'ctableRecord' });
-
- //    mdbgoose.model('CTableRecord', CTableRecordSchema);
-
-	// 玩家战绩
-	var UserSchema = new mdbgoose.Schema({
-		_id: { type: String },								// 玩家标识
-		chairId: { type: Number, default: 0},               // 椅子号
-		userId: { type: Number, default: 0},                // 玩家号码
-		name: { type: String, default: ''},				    // 昵称
-		sex: { type: String, default: ''},					// 性别
-		headurl: { type: String, default: ''},				// 头像
-		over: { type: Number, default: 0},					// 游戏局数
-		score: { type: Number, default: 0}					// 分数
-		//gameCost: { type: Number, default: 0 },				// 游戏消耗
-		//giftCost: { type: Number, default: 0 },				// 礼物消耗
-		//diamond: { type: Number, default: 0 }               // 最新钻石
-		//extend: { type: Types.Mixed, default: {} }		// 扩展
-	});
-	// 实时战绩
-	var SSZJSchema = new mdbgoose.Schema({
-		_id: { type: String },								// 子局数
-		sszjScore: [String],								// 本局成绩
-		sszjAllScore: [String],								// 总成绩
-		banker: { type: Number, default: -1 },				// 庄家
-		hu: { type: Number, default: -1 },					// 胡
-		pao: { type: Number, default: -1 }				    // 放炮
-		//fName: { type: String, default: '' }				// 实时战绩文件
-	});
-
-	// 奉化麻将（10007）
-	var FHMJTablesSchema = new mdbgoose.Schema({
-		_id: { type: String },								// ts++标识
-		gameId: { type: Number , default: 0 },				// 游戏id，10006为长沙麻将，10007为红中麻将，10008为跑得快
-		tableNo: { type: String , default: ''},				// ts++房间号
-		ownerId: { type: String, default: '' },				// 房主标识
-		agentId: { type: String, default: '' },				// 代理ID
-	    type: { type: Number , default: 0 },				// 类型
-		kind: { type: Number, default: 0  },				// 玩法
-		other: { type: Number, default: 0  },				// 其他玩法
-		playerCount: { type: Number, default: 0  },			// 游戏人数
-		round: { type: Number, default: 0  },				// 总局数
-		over: { type: Number , default: 0 },				// 游戏局数
-		ctime: { type: Number, default: 0  },				// 创建时间
-		stime: { type: Number , default: 0 },				// 开始时间
-		time: { type: Number, default: 0  },				// 结束时间
-		endMode: { type: Number, default: 0  },				// 结束模式
-		gameCost: { type: Number, default: 0 },				// 游戏消耗
-		giftCost: { type: Number, default: 0 },				// 礼物消耗
-		agentRebate: { type: Number, default: 0 },			// 代理返利
-		sszjFile: [String],									// 实时战绩文件
-		sszj: [SSZJSchema],									// 实时战绩
-		users: [UserSchema]									// 玩家
-	}, { collection: 'fhmjtables' });
-
-	mdbgoose.model('FHMJTables', FHMJTablesSchema);
-
-	//ts++ 游戏记录 仅在创建房间时候添加，仅用于判断近期内某个玩家是否创建过多的房间
-	var GameTableSchema = new mdbgoose.Schema({
-		_id: { type: String },								// ts++标识
-		tableNo: { type: String , default: ''},				// ts++房间号
-		ownerId: { type: String, default: '' },				// 房主标识
-		agentId: { type: String, default: '' },				// 代理ID
-	    type: { type: Number , default: 0 },				// 类型
-		kind: { type: Number, default: 0  },				// 玩法
-		other: { type: Number, default: 0  },				// 其他玩法
-		playerCount: { type: Number, default: 0  },			// 游戏人数
-		round: { type: Number, default: 0  },				// 总局数
-		over: { type: Number , default: 0 },				// 游戏局数
-		ctime: { type: Number, default: 0  },				// 创建时间
-		// stime: { type: Number , default: 0 },				// 开始时间
-		// time: { type: Number, default: 0  },				// 结束时间
-		endMode: { type: Number, default: 0  },				// 结束模式
-		// gameCost: { type: Number, default: 0 },				// 游戏消耗
-		// agentRebate: { type: Number, default: 0 },			// 代理返利
-	}, { collection: 'gametable' });
-
-	mdbgoose.model('GameTable', GameTableSchema);
-
-	var SXGamerSchema = new mdbgoose.Schema({
+    var Types = mdbgoose.Schema.Types;
+
+    // // ts++房间创建记录
+    //    var CTableRecordSchema = new mdbgoose.Schema({
+    //        _id: { type: String },                              // 房间标识
+    //        playerId: { type: String, default: '' },            // 玩家标识
+    //        registerTime: { type: Number, default: Date.now }   // 记录时间
+    //    }, { collection: 'ctableRecord' });
+
+    //    mdbgoose.model('CTableRecord', CTableRecordSchema);
+
+    // 玩家战绩
+    var UserSchema = new mdbgoose.Schema({
+        _id: { type: String },								// 玩家标识
+        chairId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},               // 椅子号
+        userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                // 玩家号码
+        name: { type: String, default: ''},				    // 昵称
+        sex: { type: String, default: ''},					// 性别
+        headurl: { type: String, default: ''},				// 头像
+        over: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},					// 游戏局数
+        score: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}}					// 分数
+        //gameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏消耗
+        //giftCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 礼物消耗
+        //diamond: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }               // 最新钻石
+        //extend: { type: Types.Mixed, default: {} }		// 扩展
+    });
+    // 实时战绩
+    var SSZJSchema = new mdbgoose.Schema({
+        _id: { type: String },								// 子局数
+        sszjScore: [String],								// 本局成绩
+        sszjAllScore: [String],								// 总成绩
+        banker: { type: Number, default: -1 },				// 庄家
+        hu: { type: Number, default: -1 },					// 胡
+        pao: { type: Number, default: -1 }				    // 放炮
+        //fName: { type: String, default: '' }				// 实时战绩文件
+    });
+
+    // 奉化麻将（10007）
+    var FHMJTablesSchema = new mdbgoose.Schema({
+        _id: { type: String },								// ts++标识
+        gameId: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏id，10006为长沙麻将，10007为红中麻将，10008为跑得快
+        tableNo: { type: String , default: ''},				// ts++房间号
+        ownerId: { type: String, default: '' },				// 房主标识
+        agentId: { type: String, default: '' },				// 代理ID
+        type: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 类型
+        kind: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 玩法
+        other: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 其他玩法
+        playerCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },			// 游戏人数
+        round: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 总局数
+        over: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏局数
+        ctime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 创建时间
+        stime: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 开始时间
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 结束时间
+        endMode: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 结束模式
+        gameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏消耗
+        giftCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 礼物消耗
+        agentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },			// 代理返利
+        sszjFile: [String],									// 实时战绩文件
+        sszj: [SSZJSchema],									// 实时战绩
+        users: [UserSchema]									// 玩家
+    }, { collection: 'fhmjtables' });
+
+    mdbgoose.model('FHMJTables', FHMJTablesSchema);
+
+    //ts++ 游戏记录 仅在创建房间时候添加，仅用于判断近期内某个玩家是否创建过多的房间
+    var GameTableSchema = new mdbgoose.Schema({
+        _id: { type: String },								// ts++标识
+        tableNo: { type: String , default: ''},				// ts++房间号
+        ownerId: { type: String, default: '' },				// 房主标识
+        agentId: { type: String, default: '' },				// 代理ID
+        type: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 类型
+        kind: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 玩法
+        other: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 其他玩法
+        playerCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },			// 游戏人数
+        round: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 总局数
+        over: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏局数
+        ctime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 创建时间
+        // stime: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 开始时间
+        // time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 结束时间
+        endMode: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },				// 结束模式
+        // gameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 游戏消耗
+        // agentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },			// 代理返利
+    }, { collection: 'gametable' });
+
+    mdbgoose.model('GameTable', GameTableSchema);
+
+    var SXGamerSchema = new mdbgoose.Schema({
         _id: { type: String },								// 玩家ID+时期[20190707]
         playerId: { type: String, default: '' },            // 玩家标识
         gameDate: { type: String, default: '' },            // 日期
-		ttCount: { type: Number, default: 0 },				// 总场数
-		noCount: { type: Number, default: 0 },				// 平局数
-		winCount: { type: Number, default: 0 },				// 胜场数
-		runCount: { type: Number, default: 0 },				// 逃跑数
-		history: [String]									// 历史记录
-		//pjhffileName: [String]                            //ts-- 牌局回放记录的文件名
+        ttCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 总场数
+        noCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 平局数
+        winCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 胜场数
+        runCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				// 逃跑数
+        history: [String]									// 历史记录
+        //pjhffileName: [String]                            //ts-- 牌局回放记录的文件名
     }, { collection: 'sxgamer' });
 
-	
+
     mdbgoose.model('SXGamer', SXGamerSchema);
 
-	// 全局记录
-	var RecordSchema = new mdbgoose.Schema({
+    // 全局记录
+    var RecordSchema = new mdbgoose.Schema({
         _id: { type: String },								// UUID
-		gameId: { type: Number },							// 游戏ID
-		tableId: { type: String },							// 房间号
-		type: { type: Number },								// 类型
-		round: { type: Number },							// 局数
-		ctime: { type: Number },							// 创建时间
-		stime: { type: Number },							// 开始时间
-		time: { type: Number },								// 记录时间
-		users: [UserSchema]									// 玩家
+        gameId: { type: Number },							// 游戏ID
+        tableId: { type: String },							// 房间号
+        type: { type: Number },								// 类型
+        round: { type: Number },							// 局数
+        ctime: { type: Number },							// 创建时间
+        stime: { type: Number },							// 开始时间
+        time: { type: Number },								// 记录时间
+        users: [UserSchema]									// 玩家
     }, { collection: 'records' });
 
-	mdbgoose.model('Record', RecordSchema);
+    mdbgoose.model('Record', RecordSchema);
 
-	////下面是水果机相关的数据
-	// 水果机奖池
+    ////下面是水果机相关的数据
+    // 水果机奖池
     var SGJJCchema = new mdbgoose.Schema({
         _id: { type: String, default: ''},    // 主键
-        pools: [Number],		 // 奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        cspools: [Number],		 // 初始奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        levels: [Number],		 // 挡位数组(单位：钻石)（奖池分为几个等级，数组就有几个元素）
-        kouchus: [Number],		 // 扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        topLimits1: [Number],	 // 各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
-        topLimits2: [Number],	 // 各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
-        topLimits3: [Number],	 // 各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
-        lowLimits1: [Number],	 // 各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
-        lowLimits2: [Number],	 // 各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
-        lowLimits3: [Number],	 // 各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
-        paiTopRate1: [Number],	 // 各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
-        paiTopRate2: [Number],	 // 各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
-        paiTopRate3: [Number],	 // 各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
-        paiLowRate1: [Number],	 // 各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
-        paiLowRate2: [Number],	 // 各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
-        paiLowRate3: [Number],	 // 各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
-        bsTopRate1: [Number],	 // 各个挡位对应的倍数上限1调控比例（奖池分为几个等级，数组就有几个元素）
-        bsTopRate2: [Number],	 // 各个挡位对应的倍数上限2调控比例（奖池分为几个等级，数组就有几个元素）
-        bsTopRate3: [Number],	 // 各个挡位对应的倍数上限3调控比例（奖池分为几个等级，数组就有几个元素）
-        bsLowRate1: [Number],	 // 各个挡位对应的倍数下限1调控比例（奖池分为几个等级，数组就有几个元素）
-        bsLowRate2: [Number],	 // 各个挡位对应的倍数下限2调控比例（奖池分为几个等级，数组就有几个元素）
-        bsLowRate3: [Number],	 // 各个挡位对应的倍数下限3调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxpools: [Number],		 // 押大小奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        ydxcspools: [Number],	 // 押大小初始奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        ydxlevels: [Number],	 // 押大小挡位数组(单位：钻石)（奖池分为几个等级，数组就有几个元素）
-        ydxkouchus: [Number],	 // 押大小扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
-        ydxtopLimits1: [Number], // 押大小各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxtopLimits2: [Number], // 押大小各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxtopLimits3: [Number], // 押大小各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxlowLimits1: [Number], // 押大小各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxlowLimits2: [Number], // 押大小各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxlowLimits3: [Number], // 押大小各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
-        ydxTopRate1: [Number],	 // 押大小各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxTopRate2: [Number],	 // 押大小各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxTopRate3: [Number],	 // 押大小各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxLowRate1: [Number],	 // 押大小各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxLowRate2: [Number],	 // 押大小各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
-        ydxLowRate3: [Number],	 // 押大小各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
+        pools: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},		 // 奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        cspools: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},		 // 初始奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        levels: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},		 // 挡位数组(单位：钻石)（奖池分为几个等级，数组就有几个元素）
+        kouchus: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},		 // 扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        topLimits1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
+        topLimits2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
+        topLimits3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
+        lowLimits1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
+        lowLimits2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
+        lowLimits3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
+        paiTopRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
+        paiTopRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
+        paiTopRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
+        paiLowRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
+        paiLowRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
+        paiLowRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
+        bsTopRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数上限1调控比例（奖池分为几个等级，数组就有几个元素）
+        bsTopRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数上限2调控比例（奖池分为几个等级，数组就有几个元素）
+        bsTopRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数上限3调控比例（奖池分为几个等级，数组就有几个元素）
+        bsLowRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数下限1调控比例（奖池分为几个等级，数组就有几个元素）
+        bsLowRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数下限2调控比例（奖池分为几个等级，数组就有几个元素）
+        bsLowRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 各个挡位对应的倍数下限3调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxpools: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},		 // 押大小奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        ydxcspools: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小初始奖池列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        ydxlevels: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小挡位数组(单位：钻石)（奖池分为几个等级，数组就有几个元素）
+        ydxkouchus: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小扣除列表(单位：1/100钻石)（奖池分为几个等级，数组就有几个元素）
+        ydxtopLimits1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的上限1调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxtopLimits2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的上限2调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxtopLimits3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的上限3调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxlowLimits1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的下限1调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxlowLimits2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的下限2调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxlowLimits3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}}, // 押大小各个挡位对应的下限3调控数值（奖池分为几个等级，数组就有几个元素）
+        ydxTopRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌上限1调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxTopRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌上限2调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxTopRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌上限3调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxLowRate1: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌下限1调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxLowRate2: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌下限2调控比例（奖池分为几个等级，数组就有几个元素）
+        ydxLowRate3: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	 // 押大小各个挡位对应的牌下限3调控比例（奖池分为几个等级，数组就有几个元素）
     }, { collection: 'sgjjc' });
 
     mdbgoose.model('SGJJC', SGJJCchema);
 
-	// 划分战绩
-	var HUAFENchema = new mdbgoose.Schema({
-		yddx: { type: Number, default: 0  },		// 本次划分玩家押的大小,1代表押小 = 2代表押大
-		hfxz: { type: Number, default: 0  },		// 本次划分的下注
-		hfjg: { type: Number, default: 0  },		// 本次划分的发牌结果：区间[1,12]
-		bcyd: { type: Number, default: 0  },		// 本次划分赢的
-		ksfs: { type: Number, default: 0  },		// 本次划分开始时的钻石(下注之前的)
-		jsfs: { type: Number, default: 0  },		// 本次划分结束时的钻石(jsfs = ksfs-hfxz+bcyd)
-		time: { type: Number, default: 0  },		// 本条划分记录时间
-	});
-	// 水果机战绩
-	var SGJTablesSchema = new mdbgoose.Schema({
-		_id: { type: String },						// ts++标识
-		tableNo: { type: String , default: ''},		// ts++房间号
-		ownerId: { type: String, default: '' },		// 玩家标识
-		agentId: { type: String, default: '' },		// 代理ID
-		over: { type: Number , default: 0 },		// 游戏局数
-		time: { type: Number, default: 0  },		// 结束时间
-		gameCost: { type: Number, default: 0 },		// 游戏消耗(本局下注总额)
-		giftCost: { type: Number, default: 0 },		// 礼物消耗
-		agentRebate: { type: Number, default: 0 },	// 代理返利
-		yazhuList: [Number],						// 本局押注列表
-		resultList: [Number],						// 本局结果列表
-		winsList: [Number],							// 本局结果赢的列表
-		win: { type: Number, default: 0 },			// 本局结果赢得分数(不包含下注的即winsList元素总和)
-		bsIndex: { type: Number, default: 0 },      //本次发牌对应的倍数下标["10/20","15/30","20/40"];
-		huafenList: [HUAFENchema],					// 本局划分数据列表
-		scoreBefore: { type: Number, default: 0 },	// 本局开始前的分数(钻石)
-		scoreEnd: { type: Number, default: 0 },		// 本局结束后的分数(=scoreBefore-押注总额+win)
-
-	}, { collection: 'sgjtables' });
-
-	mdbgoose.model('SGJTables', SGJTablesSchema);
-
-	var SGJUserTongjiSchema = new mdbgoose.Schema({
+    // 划分战绩
+    var HUAFENchema = new mdbgoose.Schema({
+        yddx: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分玩家押的大小,1代表押小 = 2代表押大
+        hfxz: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分的下注
+        hfjg: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分的发牌结果：区间[1,12]
+        bcyd: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分赢的
+        ksfs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分开始时的钻石(下注之前的)
+        jsfs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本次划分结束时的钻石(jsfs = ksfs-hfxz+bcyd)
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 本条划分记录时间
+    });
+    // 水果机战绩
+    var SGJTablesSchema = new mdbgoose.Schema({
+        _id: { type: String },						// ts++标识
+        tableNo: { type: String , default: ''},		// ts++房间号
+        ownerId: { type: String, default: '' },		// 玩家标识
+        agentId: { type: String, default: '' },		// 代理ID
+        over: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },		// 游戏局数
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}  },		// 结束时间
+        gameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },		// 游戏消耗(本局下注总额)
+        giftCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },		// 礼物消耗
+        agentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	// 代理返利
+        yazhuList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},						// 本局押注列表
+        resultList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},						// 本局结果列表
+        winsList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},							// 本局结果赢的列表
+        win: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },			// 本局结果赢得分数(不包含下注的即winsList元素总和)
+        bsIndex: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      //本次发牌对应的倍数下标["10/20","15/30","20/40"];
+        huafenList: [HUAFENchema],					// 本局划分数据列表
+        scoreBefore: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	// 本局开始前的分数(钻石)
+        scoreEnd: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },		// 本局结束后的分数(=scoreBefore-押注总额+win)
+
+    }, { collection: 'sgjtables' });
+
+    mdbgoose.model('SGJTables', SGJTablesSchema);
+
+    var SGJUserTongjiSchema = new mdbgoose.Schema({
         _id: { type: String },						// ts++标识
-        userId: { type: Number, default: 0 },
-        usdt: { type: Number, default: 0 },                    // 当前身上usdt
-        sgjwinlose: { type: Number, default: 0 },               //水果机盈亏
-        taskquanget: { type: Number, default: 0 },          //获得的奖券
-        taskquanlose: { type: Number, default: 0 },         //奖券消费
-        nowtaskquan:{ type: Number, default: 0 },           //当前奖券
-        todaytime: { type: Number, default: 0 },            //统计时间
-        taskGetU: { type: Number, default: 0 },             //任务获得的U
-        rechargeusdt: { type: Number, default: 0 },         //充值获得的U
-        withdrawusdt: { type: Number, default: 0 },         //提现的U
-        feeconfigusdt: { type: Number, default: 0 },        //提现每次3U的手续费
-        feeusdt: { type: Number, default: 0 },              //提现第三方扣的手续费
+        userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        usdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 当前身上usdt
+        sgjwinlose: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               //水果机盈亏
+        taskquanget: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          //获得的奖券
+        taskquanlose: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         //奖券消费
+        nowtaskquan:{ type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },           //当前奖券
+        todaytime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },            //统计时间
+        taskGetU: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             //任务获得的U
+        rechargeusdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         //充值获得的U
+        withdrawusdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         //提现的U
+        feeconfigusdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        //提现每次3U的手续费
+        feeusdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              //提现第三方扣的手续费
     }, { collection: 'sgjusertongji' });
 
     mdbgoose.model('SGJUserTongji', SGJUserTongjiSchema);
-	//水果机玩家信息
+    //水果机玩家信息
     var SGJUserSchema = new mdbgoose.Schema({
         _id: { type: String },                       // 标识
-        cost: { type: Number, default: 0 },          // 消费
-        win: { type: Number, default: 0 },           // 总赢得分
+        userId: { type: Number },                    // 号码
+        cost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 消费
+        win: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },           // 总赢得分
         zfbAcc: { type: String , default: ''},		 // 支付宝账号
         zfbName: { type: String , default: ''},		 // 支付宝姓名
-        zfbBindTime: { type: Number, default: 0 },	 // 玩家支付宝信息正确性验证成功时间(0时表示验证未通过)
-        gameCount: { type: Number, default: 0 },     // 总小局次数
-        wingames: { type: Number, default: 0 },      // 总赢的小局次数
-        taskReward: { type: Number, default: 0 },    // 已获得的任务奖励（RMB）在zfb到账之后增加
-        jxzReward: { type: Number, default: 0 },     // 进行中的任务奖励（RMB）在领取任务时增加，在zfb到账之后减少
-        ylzsReward: { type: Number, default: 0 },    // 已领取的任务奖励（钻石）
-        taskQuan: { type: Number, default: 0 },      // 任务券（用于领任务）
-        yazhuList: [Number],						 // 上局押注列表
+        zfbBindTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	 // 玩家支付宝信息正确性验证成功时间(0时表示验证未通过)
+        gameCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },     // 总小局次数
+        wingames: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 总赢的小局次数
+        taskReward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    // 已获得的任务奖励（RMB）在zfb到账之后增加
+        jxzReward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },     // 进行中的任务奖励（RMB）在领取任务时增加，在zfb到账之后减少
+        ylzsReward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    // 已领取的任务奖励（钻石）
+        taskQuan: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 任务券（用于领任务）
+        yazhuList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},						 // 上局押注列表
         // [大苹果个数,大橙子个数,大芒果个数,大铃铛个数,大西瓜个数,大星星个数,大七七个数,大王王个数,幸运运个数,
         // 小苹果个数,小橙子个数,小芒果个数,小铃铛个数,小西瓜个数,小星星个数,小七七个数,小王王个数]
-        getList: [Number],						     // 获得的列表(用于计算任务是否完成)
-        getTime: { type: Number, default: 0 },       // 获得列表更新的时间
+        getList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},						     // 获得的列表(用于计算任务是否完成)
+        getTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 获得列表更新的时间
         // 今日可补充带入数量（例如玩家今天第一次进游戏时身上只有2w钻石，玩一会儿之后今日带入剩了1w了，
         // 出去充值之后身上钻石变多之后那今日的可带入应该为上次剩的1w+刚刚充值之后的最多9w）
-        jrkbcdrs: { type: Number, default: 0 },      // 今日可补充带入数量
-        drCount: { type: Number, default: 0 },       // 带入数量(钻石)（1分=10钻石，每日上限1w分）
-        drTime: { type: Number, default: 0 },        // 带入时间
-        jzjrldzcz: { type: Number, default: 0 },       // 玩家截至今日零点总充值数量（分），用于判断任务
-        jzjrldzczjlsj: { type: Number, default: 0 },   // 玩家截至今日零点总充值记录对应的时间戳，用于判断jzjrldzcz是否需要更新
-        registerTime: { type: Number, default: 0 },	  // 玩家首次进入水果游戏时间
-        lastJoinTime: { type: Number, default: 0 },   // 玩家上次进入果游戏时间(留存人数)
-        lastPlayTime: { type: Number, default: 0 },   // 玩家上次玩水果游戏时间(用于统计游戏人数)
-        lastYDXTime: { type: Number, default: 0 }     // 玩家上次水果押大小时间(用于统计押大小人数)
-        
+        jrkbcdrs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 今日可补充带入数量
+        drCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 带入数量(钻石)（1分=10钻石，每日上限1w分）
+        drTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 带入时间
+        jzjrldzcz: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 玩家截至今日零点总充值数量（分），用于判断任务
+        jzjrldzczjlsj: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 玩家截至今日零点总充值记录对应的时间戳，用于判断jzjrldzcz是否需要更新
+        registerTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	  // 玩家首次进入水果游戏时间
+        lastJoinTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 玩家上次进入果游戏时间(留存人数)
+        lastPlayTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 玩家上次玩水果游戏时间(用于统计游戏人数)
+        lastYDXTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }     // 玩家上次水果押大小时间(用于统计押大小人数)
+
     }, { collection: 'sgjuser' });
 
     mdbgoose.model('SGJUser', SGJUserSchema);
@@ -256,39 +257,39 @@ module.exports = function (app) {
         playerId: { type: String },  // 玩家标识
         userId: { type: Number },    // 号码
         des: { type: String },   // 玩家标识
-        cost: { type: Number, default: 0 }, // 消费
-        reachs: [Number],	//达成该条任务所需的条件列表[1(1号牌),2(2号牌)]]
-        reachC: [Number],	//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
-        rewardt: { type: Number, default: 0 },  //该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
-        rewards: { type: Number, default: 0 },	//该条任务达成之后的奖品数量
-        state: { type: Number, default: 0 },  //任务状态0:未完成，1:已完成，2:发奖中，3:已发奖，
-        lqTime: { type: Number, default: 0 },  //领取任务时间
-        wcTime: { type: Number, default: 0 },  //完成时间
-        fjTime: { type: Number, default: 0 },  //发奖时间
-        
+        cost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }, // 消费
+        reachs: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	//达成该条任务所需的条件列表[1(1号牌),2(2号牌)]]
+        reachC: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
+        rewardt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
+        rewards: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	//该条任务达成之后的奖品数量
+        state: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //任务状态0:未完成，1:已完成，2:发奖中，3:已发奖，
+        lqTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //领取任务时间
+        wcTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //完成时间
+        fjTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //发奖时间
+
     }, { collection: 'sgjtask' });
 
     mdbgoose.model('SGJTask', SGJTaskSchema);
 
 
     // 水果机玩家今日任务池信息item
-	var SGJRWCItemchema = new mdbgoose.Schema({
-		index: { type: Number, default: -1 },  //该条任务编号
-		des: { type: String, default: "" },   // 任务描述
-		times: { type: Number, default: 1 },  //该条任务今日可领总次数
-        cost: { type: Number, default: 0 }, // 该条任务需要的消耗
-        reachs: [Number],	//达成该条任务所需的条件列表[1(1号牌),2(2号牌)]]
-        reachC: [Number],	//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
-        rewardt: { type: Number, default: 0 },  //该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
-        rewards: { type: Number, default: 0 },	//该条任务达成之后的奖品数量
-	});
+    var SGJRWCItemchema = new mdbgoose.Schema({
+        index: { type: Number, default: -1 },  //该条任务编号
+        des: { type: String, default: "" },   // 任务描述
+        times: { type: Number, default: 1 },  //该条任务今日可领总次数
+        cost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }, // 该条任务需要的消耗
+        reachs: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	//达成该条任务所需的条件列表[1(1号牌),2(2号牌)]]
+        reachC: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},	//达成该条任务所需的个数列表[reachs[0]出现次数,reachs[1]出现次数]
+        rewardt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该条任务达成之后的奖品类型 0:未定义 1:钻石,2:RMB(分)
+        rewards: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },	//该条任务达成之后的奖品数量
+    });
 
     //水果玩家今日任务池信息（为了实现每个玩家每天的任务随机）
     var SGJWJJRRWCSchema = new mdbgoose.Schema({
         _id: { type: String },  // 标识，玩家的_id
-        time: { type: Number, default: 0 },  //任务池对应的时间
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //任务池对应的时间
         rwcList: [SGJRWCItemchema]	// 该玩家对应时间的任务池列表
-        
+
     }, { collection: 'sgjwjjrrwc' });
 
     mdbgoose.model('SGJWJJRRWC', SGJWJJRRWCSchema);
@@ -296,36 +297,36 @@ module.exports = function (app) {
     //水果总统计信息
     var SGJTongjiSchema = new mdbgoose.Schema({
         _id: { type: String, default: 'sgztj'},    // 主键
-        allCost: { type: Number, default: 0 },  //所有玩家总下注
-        allwin: { type: Number, default: 0 },   //所有玩家总赢得
-        allxh: { type: Number, default: 0 },    //所有玩家总消耗（总下注-总赢得）
-        zqqCost: { type: Number, default: 0 },  //所有玩家游戏转圈总下注
-        zqqwin: { type: Number, default: 0 },   //所有玩家游戏转圈总赢得
-        zqqxh: { type: Number, default: 0 },    //所有玩家游戏转圈总消耗（总下注-总赢得）
-        ydxCost: { type: Number, default: 0 },  //所有玩家押大小总下注
-        ydxwin: { type: Number, default: 0 },   //所有玩家押大小总赢得
-        ydxxh: { type: Number, default: 0 },    //所有玩家押大小总消耗（总下注-总赢得）
-        allrwq: { type: Number, default: 0 },   //所有奖券产生总量
-        rwxhjq1: { type: Number, default: 0 },  //钻石任务消耗奖券总量（领任务时记录）
-        rwxhjq2: { type: Number, default: 0 },  //RMB任务消耗奖券总量（领任务时记录）
-        rwxhjq3: { type: Number, default: 0 },  //备用任务1消耗奖券总量（领任务时记录）
-        rwxhjq4: { type: Number, default: 0 },  //备用任务2消耗奖券总量（领任务时记录）
-        rwdcze1: { type: Number, default: 0 },  //钻石任务兑出总额（领奖时记录）
-        rwdcze2: { type: Number, default: 0 },  //RMB（分）任务兑出总额（领奖时记录）
-        rwdcze3: { type: Number, default: 0 },  //备用任务兑出总额（领奖时记录）
-        rwdcze4: { type: Number, default: 0 },  //备用任务兑出总额（领奖时记录）
+        allCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //所有玩家总下注
+        allwin: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有玩家总赢得
+        allxh: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    //所有玩家总消耗（总下注-总赢得）
+        zqqCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //所有玩家游戏转圈总下注
+        zqqwin: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有玩家游戏转圈总赢得
+        zqqxh: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    //所有玩家游戏转圈总消耗（总下注-总赢得）
+        ydxCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //所有玩家押大小总下注
+        ydxwin: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有玩家押大小总赢得
+        ydxxh: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    //所有玩家押大小总消耗（总下注-总赢得）
+        allrwq: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有奖券产生总量
+        rwxhjq1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //钻石任务消耗奖券总量（领任务时记录）
+        rwxhjq2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //RMB任务消耗奖券总量（领任务时记录）
+        rwxhjq3: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //备用任务1消耗奖券总量（领任务时记录）
+        rwxhjq4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //备用任务2消耗奖券总量（领任务时记录）
+        rwdcze1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //钻石任务兑出总额（领奖时记录）
+        rwdcze2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //RMB（分）任务兑出总额（领奖时记录）
+        rwdcze3: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //备用任务兑出总额（领奖时记录）
+        rwdcze4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //备用任务兑出总额（领奖时记录）
         // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
-        allyzze: [Number],					//总押注总额列表
-        allydze: [Number],					//总赢得总额列表(不包含特殊项)
+        allyzze: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//总押注总额列表
+        allydze: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//总赢得总额列表(不包含特殊项)
         // 下面这数据是长度为16的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
         //小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
-        gxzydze: [Number],					//各项总赢得总额列表(不包含特殊项)
+        gxzydze: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//各项总赢得总额列表(不包含特殊项)
         // 下面这数据是长度为17的数组，分别代表[大苹果,大橙子,大芒果,大铃铛,大西瓜,大星星,大七七,大王王,
         //幸运运,小苹果,小橙子,小芒果,小铃铛,小西瓜,小星星,小七七,小王王]
-        gxcxzcs: [Number],					//各项出现总次数列表(不包含特殊项)
+        gxcxzcs: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//各项出现总次数列表(不包含特殊项)
         // 下面这两个数据是长度为3的数组，分别代表[小三元,大三元,大四喜]
-        tsxzydze: [Number],					//特殊项总赢得总额列表
-        tsxcxzcs: [Number],					//特殊项出现总次数列表
+        tsxzydze: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//特殊项总赢得总额列表
+        tsxcxzcs: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					//特殊项出现总次数列表
         errstr: { type: String, default: ''},    //错误或者异常记录
     }, { collection: 'sgjtongji' });
 
@@ -334,20 +335,20 @@ module.exports = function (app) {
     //水果每日统计信息
     var SGJMRTJSchema = new mdbgoose.Schema({
         _id: { type: String },                  // 标识
-        zqqCost: { type: Number, default: 0 },  //所有玩家游戏转圈总下注
-        zqqwin: { type: Number, default: 0 },   //所有玩家游戏转圈总赢得
-        zqqxh: { type: Number, default: 0 },    //所有玩家游戏转圈总消耗（总下注-总赢得）
-        ydxCost: { type: Number, default: 0 },  //所有玩家押大小总下注
-        ydxwin: { type: Number, default: 0 },   //所有玩家押大小总赢得
-        ydxxh: { type: Number, default: 0 },    //所有玩家押大小总消耗（总下注-总赢得）
-        ydxzcs: { type: Number, default: 0 },   //该日押大小总次数
-        allrwq: { type: Number, default: 0 },   //所有奖券产生总量   
-        rwxhjq1: { type: Number, default: 0 },  //钻石任务消耗奖券总量（领任务时记录）
-        rwxhjq2: { type: Number, default: 0 },  //RMB任务消耗奖券总量（领任务时记录）
-        rwdcze1: { type: Number, default: 0 },  //钻石任务兑出总额（领奖时记录）
-        rwdcze2: { type: Number, default: 0 },  //RMB（分）任务兑出总额（领奖时记录）
-        // yazhuList: [Number],					// 本局押注列表
-        registerTime: { type: Number, default: 0 }// 记录时间（该日0点时间戳）
+        zqqCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //所有玩家游戏转圈总下注
+        zqqwin: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有玩家游戏转圈总赢得
+        zqqxh: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    //所有玩家游戏转圈总消耗（总下注-总赢得）
+        ydxCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //所有玩家押大小总下注
+        ydxwin: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有玩家押大小总赢得
+        ydxxh: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    //所有玩家押大小总消耗（总下注-总赢得）
+        ydxzcs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //该日押大小总次数
+        allrwq: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //所有奖券产生总量
+        rwxhjq1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //钻石任务消耗奖券总量（领任务时记录）
+        rwxhjq2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //RMB任务消耗奖券总量（领任务时记录）
+        rwdcze1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //钻石任务兑出总额（领奖时记录）
+        rwdcze2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //RMB（分）任务兑出总额（领奖时记录）
+        // yazhuList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},					// 本局押注列表
+        registerTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }// 记录时间（该日0点时间戳）
     }, { collection: 'sgjmrtj' });
 
     mdbgoose.model('SGJMRTJ', SGJMRTJSchema);
@@ -355,16 +356,16 @@ module.exports = function (app) {
     //水果每日统计信息
     var SGJMRRSSchema = new mdbgoose.Schema({
         _id: { type: String },                 // 标识(日期)
-        grzcrs: { type: Number, default: 0 },  //该日注册人数(按照进入时间算)
-        xzyxrs: { type: Number, default: 0 },  //该日新增有效人数（玩过游戏的算为有效）
-        grzqrs: { type: Number, default: 0 },  //该日转圈人数
-        ydxzrs: { type: Number, default: 0 },  //该日押大小总人数
-        grzqcs: { type: Number, default: 0 },  //该日转圈次数
-        ydxzcs: { type: Number, default: 0 },  //该日押大小总次数
-        lcrs1: { type: Number, default: 0 },   //该日的次日留存人数(按照进入算)
-        lcrs7: { type: Number, default: 0 },   //该日的7日留存人数(按照进入算)
+        grzcrs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日注册人数(按照进入时间算)
+        xzyxrs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日新增有效人数（玩过游戏的算为有效）
+        grzqrs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日转圈人数
+        ydxzrs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日押大小总人数
+        grzqcs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日转圈次数
+        ydxzcs: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //该日押大小总次数
+        lcrs1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //该日的次日留存人数(按照进入算)
+        lcrs7: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   //该日的7日留存人数(按照进入算)
         time: { type: Number, default: Date.now },// 精确时间
-        registerTime: { type: Number, default: 0 }// 记录时间（该日0点时间戳）
+        registerTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }// 记录时间（该日0点时间戳）
     }, { collection: 'sgjmrrs' });
 
     mdbgoose.model('SGJMRRS', SGJMRRSSchema);
@@ -375,12 +376,12 @@ module.exports = function (app) {
         name: { type: String, default: '' },         // 昵称
         headurl: { type: String, default: '' },      // 头像
         userId: { type: Number },                    // 号码
-        cost1: { type: Number, default: 0 },         // 最近一天总下注
-        quan1: { type: Number, default: 0 },         // 最近一天总得奖券
-        time1: { type: Number, default: 0 },   // 最近游戏那天的0点时间戳
-        cost2: { type: Number, default: 0 },         // 次近一天总下注
-        quan2: { type: Number, default: 0 },         // 次近一天总得奖券
-        time2: { type: Number, default: 0 },   // 次近游戏那天的0点时间戳
+        cost1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // 最近一天总下注
+        quan1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // 最近一天总得奖券
+        time1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 最近游戏那天的0点时间戳
+        cost2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // 次近一天总下注
+        quan2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // 次近一天总得奖券
+        time2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 次近游戏那天的0点时间戳
         registerTime: { type: Number, default: Date.now },// 记录时间
     }, { collection: 'sgjpaihang' });
 
@@ -389,7 +390,7 @@ module.exports = function (app) {
     //水果全局配置信息
     var SGJConfigSchema = new mdbgoose.Schema({
         _id: { type: String, default: 'sgconfigs'},    // 主键
-        phbyfjlrq: { type: Number, default: 0 },  //排行榜已发奖励的日期（0点时间戳）
+        phbyfjlrq: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  //排行榜已发奖励的日期（0点时间戳）
         istelegram: { type: Number, default: 1 },  //排行榜已发奖励的日期（0点时间戳）
         withdrawfee: { type: Number, default: 3 },  //排行榜已发奖励的日期（0点时间戳）
         withdrawlowlimit: { type: Number, default: 10 },  //排行榜已发奖励的日期（0点时间戳）

app/models/hall.js

@@ -3,16 +3,16 @@
 module.exports = function (app) {
     var mdbgoose = app.memdb.goose;
 
-	// 充值订单
+    // 充值订单
     var PayRecordSchema = new mdbgoose.Schema({
         _id: { type: String },                                      // 订单号
         playerId: { type: String },                                 // 玩家ID
         payplayerId: { type: String, default: '' },                 // 支付玩家ID
         total_fee: { type: Number },							    // 总金额
-        payment: { type: Number, default: 0 },                      // 支付方式 0为微信 1为支付宝
-        paystate: { type: Number, default: 0 },                     // 支付状态 0未支付 1成功
-        paydiamond: { type: Number, default: 0 },                   // 充值钻石
-        payreward: { type: Number, default: 0 },                    // 充值奖励
+        payment: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                      // 支付方式 0为微信 1为支付宝
+        paystate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 支付状态 0未支付 1成功
+        paydiamond: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 充值钻石
+        payreward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 充值奖励
         time: { type: Number, default: Date.now }				    // 时间戳
     }, { collection: 'pay_records' });
 
@@ -23,10 +23,10 @@ module.exports = function (app) {
         playerId: { type: String },                                 // 玩家ID
         payplayerId: { type: String, default: '' },                 // 支付玩家ID
         total_fee: { type: Number },							    // 总金额
-        payment: { type: Number, default: 0 },                      // 支付方式 0为微信 1为支付宝
-        paystate: { type: Number, default: 0 },                     // 支付状态 0未支付 1成功
-        paydiamond: { type: Number, default: 0 },                   // 充值钻石
-        payreward: { type: Number, default: 0 },                    // 充值奖励
+        payment: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                      // 支付方式 0为微信 1为支付宝
+        paystate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 支付状态 0未支付 1成功
+        paydiamond: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 充值钻石
+        payreward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 充值奖励
         time: { type: Number, default: Date.now }				    // 时间戳
     }, { collection: 'config' });
 
@@ -38,19 +38,19 @@ module.exports = function (app) {
         chainCode: { type: String, default: ''  },                                 // 玩家ID
         clientId: { type: String, default: '' },                 // 支付玩家ID
         code:  {type: String, default: '' },							    // 总金额
-        amount: { type: Number, default: 0 },                      // 支付方式 0为微信 1为支付宝
+        amount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                      // 支付方式 0为微信 1为支付宝
         hash: { type: String, default: '' },                     // 支付状态 0未支付 1成功
-        status : { type: Number, default: 0 },
-        fees: { type: Number, default: 0 },
-        feesU: { type: Number, default: 0 },
+        status : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        fees: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        feesU: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
         sourceAddress: { type: String, default: '' },                   // 充值钻石
         targetAddress: { type: String, default: '' },                    // 充值奖励
         risk: { type: Boolean, default: true },                    // 充值奖励
-        timestamp: { type: Number, default: 0 },                    // 充值奖励
+        timestamp: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 充值奖励
         sign: { type: String, default: '' },                    // 充值奖励
-        time: { type: Number, default: 0 },				    // 时间戳
-        beforeusdt : { type: Number, default: 0 },
-        afterusdt : { type: Number, default: 0 }
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				    // 时间戳
+        beforeusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        afterusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }
     }, { collection: 'usdtPayRecord' });
 
     mdbgoose.model('UsdtPayRecord', UsdtPayRecordSchema);
@@ -60,22 +60,22 @@ module.exports = function (app) {
         _id: { type: String },                                      // 订单号
         chainCode: { type: String, default: ''  },                                 // 玩家ID
         userId: { type: String, default: '' },                 // 支付玩家ID
-        amount: { type: Number, default: 0 },                      // 支付方式 0为微信 1为支付宝
+        amount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                      // 支付方式 0为微信 1为支付宝
         tokenCode: { type: String, default: '' },                     // 支付状态 0未支付 1成功
         refOrderId: { type: String, default: '' },                   // 充值钻石
         msg: { type: String, default: '' },                   // 充值钻石
         targetAddress: { type: String, default: '' },                    // 充值奖励
         additionalAudit: { type: Boolean, default: true },                    // 充值奖励
         submifee: { type: Number, default: 3 },
-        submitTime: { type: Number, default: 0 },
-        callBackTime: { type: Number, default: 0 },                    // 充值奖励
+        submitTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        callBackTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 充值奖励
         sign: { type: String, default: '' },                    // 充值奖励
-        time: { type: Number, default: 0 },				    // 时间戳
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },				    // 时间戳
         status: { type: Number, default: 100 },
-        beforeusdt : { type: Number, default: 0 },
-        afterusdt : { type: Number, default: 0 },
-        resultbeforeusdt : { type: Number, default: 0 },
-        resultafterusdt : { type: Number, default: 0 },
+        beforeusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        afterusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        resultbeforeusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
+        resultafterusdt : { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },
     }, { collection: 'usdtWithdrawRecord' });
 
     mdbgoose.model('UsdtWithdrawRecord', UsdtWithdrawRecordSchema);
@@ -85,9 +85,9 @@ module.exports = function (app) {
         _id: { type: String },                                      // 标识
         userId: { type: Number },                                   // 号码
         name: { type: String, default: '' },                        // 昵称
-        paytop: { type: Number, default: 0 },                       // 充值上限,-1表示没有设置上限
-        paytotal: { type: Number, default: 0 },                     // 充值总额
-        dataTime: { type: Number, default: 0 },                     // 充值总额对应的日期时间
+        paytop: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 充值上限,-1表示没有设置上限
+        paytotal: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 充值总额
+        dataTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 充值总额对应的日期时间
         registerTime: { type: Number, default: Date.now },          // 记录/更新时间
     }, { collection: 'paylimit' });
 
@@ -96,9 +96,9 @@ module.exports = function (app) {
     // 签到相关
     var SignInfoSchema = new mdbgoose.Schema({
         _id: { type: String },                                      // 玩家ID
-        keep: { type: Number, default: 0 },                         // 连续天数
-        lastTime: { type: Number, default: 0 },                     // 最后签到
-        shareTime: { type: Number, default: 0 }                     // 分享时间
+        keep: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                         // 连续天数
+        lastTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 最后签到
+        shareTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }                     // 分享时间
     }, { collection: 'sign_infos' });
 
     var SignRecordSchema = new mdbgoose.Schema({
@@ -111,18 +111,18 @@ module.exports = function (app) {
     mdbgoose.model('SignInfo', SignInfoSchema);
     mdbgoose.model('SignRecord', SignRecordSchema);
 
-	// 红包相关
-	var RedpackSchema = new mdbgoose.Schema({
-		_id: { type: String },                                      // UUID
-		recvd: { type: Number, default: 0 },						// 是否已领取
+    // 红包相关
+    var RedpackSchema = new mdbgoose.Schema({
+        _id: { type: String },                                      // UUID
+        recvd: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },						// 是否已领取
         diamond: { type: Number },                                  // 钻石数量
         sid: { type: String },                                      // 发放玩家
-		rid: { type: String, default: '' },							// 领取玩家
-		stime: { type: Number, default: Date.now },					// 发放时间
-		rtime: { type: Number, default: 0 },						// 领取时间
-	}, { collection: 'redpacks' });
+        rid: { type: String, default: '' },							// 领取玩家
+        stime: { type: Number, default: Date.now },					// 发放时间
+        rtime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },						// 领取时间
+    }, { collection: 'redpacks' });
 
-	mdbgoose.model('RedPack', RedpackSchema);
+    mdbgoose.model('RedPack', RedpackSchema);
 
     //bug记录
     var BugRecordSchema = new mdbgoose.Schema({
@@ -133,26 +133,26 @@ module.exports = function (app) {
         bugFileName2: { type: String },                             // bug图片文件2
         bugFileName3: { type: String },                             // bug图片文件3
         answerStr: { type: String , default: "感谢您的反馈，我们正在积极处理。"},                             // bug图片文件3
-        bugState: { type: Number, default: 0},                      // bug状态
+        bugState: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                      // bug状态
         registerTime: { type: Number, default: Date.now }           // 注册时间
     }, { collection: 'bugRecords' });
 
     mdbgoose.model('BugRecords', BugRecordSchema);
-    
+
     // 活动推广奖励产生记录
     var ActiveRewardRecordSchema = new mdbgoose.Schema({
         _id: { type: String },                                      // UUID
-        rewardtype: { type: Number, default: 0 },                     // 奖励类型，0红包
-        totalfee: { type: Number, default: 0 },                     // 产生金额，红包为分
-        type:{ type: Number, default: 0 }, //活动类型：1国庆签到2国庆邀请
+        rewardtype: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 奖励类型，0红包
+        totalfee: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 产生金额，红包为分
+        type:{ type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }, //活动类型：1国庆签到2国庆邀请
         sid: { type: String, default: '' },                         // 产生奖励的玩家id
         sname: { type: String, default: '' },                       // 产生奖励的玩家name
-        suid: { type: Number, default: 0 },                         // 产生奖励的玩家userId
+        suid: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                         // 产生奖励的玩家userId
         rid: { type: String, default: '' },                         // 此条奖励的受益玩家userId
-        gameCount: { type: Number, default: 0 },                    // 游戏局数
+        gameCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 游戏局数
         stime: { type: Number, default: Date.now },                 // 记录产生时间
-        succtime: { type: Number, default: 0 },                     // 任务完成时间，任务未完成的时候这里是0
-        succState: { type: Number, default: 0 },                    // 任务是否完成的状态，0：未完成1：已达成
+        succtime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 任务完成时间，任务未完成的时候这里是0
+        succState: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 任务是否完成的状态，0：未完成1：已达成
     }, { collection: 'activerewardrecord' });
 
     mdbgoose.model('ActiveRewardRecord', ActiveRewardRecordSchema);
@@ -160,14 +160,14 @@ module.exports = function (app) {
     // 活动推广奖励领取记录
     var ActiveReceiveRecordSchema = new mdbgoose.Schema({
         _id: { type: String },                              // UUID
-        rewardtype: { type: Number, default: 0 },           // 奖励类型，0红包
-        type:{ type: Number, default: 0 }, //活动类型：1国庆签到2国庆邀请
+        rewardtype: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },           // 奖励类型，0红包
+        type:{ type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }, //活动类型：1国庆签到2国庆邀请
         rid: { type: String, default: '' },                 // 此条奖励领取的玩家id
-        ruid: { type: Number, default: 0 },                 // 此条奖励领取的玩家userId
-        outSwap: { type: Number, default: 0 },              // 领取金额
-        totalFee: { type: Number, default: 0 },             // 发放金额
+        ruid: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 此条奖励领取的玩家userId
+        outSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 领取金额
+        totalFee: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             // 发放金额
         payState: { type: Number, default: 1 },             // 支付状态 1为未支付   2人工支付 3支付成功
-        registerTime: { type: Number, default: Date.now }   // 记录时间 
+        registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'activereceiverecord' });
 
     mdbgoose.model('ActiveReceiveRecord', ActiveReceiveRecordSchema);
@@ -175,21 +175,21 @@ module.exports = function (app) {
     // // 邮件相关
     var MailInfoSchema = new mdbgoose.Schema({
         _id: { type: String, default: ''  }, //没啥用但是没有不行
-        index: { type: Number, default: 0 }, // 邮件下标
-        tittleT: { type: Number, default: 0 },  // 邮件标题类型 0:未定义 1:普通通知 2:有奖励通知 3:补偿通知 4:版本更新通知
-        descT: { type: Number, default: 0 },  // 邮件内容类型 0:未定义 1:普通通知 2:有奖励通知 3:补偿通知 4:版本更新通知
-        reward: { type: Number, default: 0 },              // 有无奖励 0:无奖励 1:有奖励
-        rewardT: { type: Number, default: 0 },              // 奖励类型 0:未定义 1:钻石,
-        rewardC: { type: Number, default: 0 },              // 奖励数量
-        receive: { type: Number, default: 0 },              // 是否领取 0:未领取 1:已领取
-        read: { type: Number, default: 0 },              // 是否已读 0:未读 1:已读
+        index: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }, // 邮件下标
+        tittleT: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 邮件标题类型 0:未定义 1:普通通知 2:有奖励通知 3:补偿通知 4:版本更新通知
+        descT: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 邮件内容类型 0:未定义 1:普通通知 2:有奖励通知 3:补偿通知 4:版本更新通知
+        reward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 有无奖励 0:无奖励 1:有奖励
+        rewardT: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 奖励类型 0:未定义 1:钻石,
+        rewardC: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 奖励数量
+        receive: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 是否领取 0:未领取 1:已领取
+        read: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 是否已读 0:未读 1:已读
         form: { type: String, default: '' },             // 邮件来源
         sendTime: { type: Number,  default: Date.now }    // 发送日期
     });
 
     var MailsSchema = new mdbgoose.Schema({
         _id: { type: String, default: '' },                // 用户id（player表的主键）
-        userId: { type: Number, default: 0 },              // 用户的userId
+        userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 用户的userId
         mailInfos: [MailInfoSchema]// 该活动的达成条件和奖励信息列表
     }, { collection: 'mails' });
 
@@ -201,23 +201,23 @@ module.exports = function (app) {
         _id: { type: String },                 // UUID 标识
         aid: { type: String },                 // 比赛代理的标识
         agentNo: { type: Number },             // 比赛代理编号
-        stime: { type: Number, default: 0 },   // 该次比赛的开始时间
-        etime: { type: Number, default: 0 },   // 该次比赛的结束时间
+        stime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 该次比赛的开始时间
+        etime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },   // 该次比赛的结束时间
         bigRound: { type: Number, default: 3 },// 该次比赛的大局数量，统计战绩时使用
-        gameId: { type: Number, default: 0 },  // 该次比赛的游戏id 10006为长沙麻将，10007为红中麻将，10008为跑得快
-        round: { type: Number, default: 0 },  // 该次比赛的游戏局数
-        playerCount: { type: Number, default: 0 },  // 该次比赛的游戏人数
-        other: { type: Number, default: 0 },  // 该次比赛的游戏规则
+        gameId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 该次比赛的游戏id 10006为长沙麻将，10007为红中麻将，10008为跑得快
+        round: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 该次比赛的游戏局数
+        playerCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 该次比赛的游戏人数
+        other: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 该次比赛的游戏规则
         outTime:{ type: Number, default: 1 },  // 过期时间（须大于结束时间40分钟之后）
-        yljList: [Number],                    // 该次比赛已领奖人员id数组
-        staticFlag: { type: Number, default: 0 },//是否统计过战绩，用于java定时器
+        yljList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},                    // 该次比赛已领奖人员id数组
+        staticFlag: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },//是否统计过战绩，用于java定时器
         registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'racetimeinfo' });
     mdbgoose.model('RaceTimeInfos', RaceTimeInfosSchema);
 
     var JinSaiInfoSchema = new mdbgoose.Schema({
         _id: { type: String, default: '' },                // 用户id（player表的主键）
-        userId: { type: Number, default: 0 },              // 用户的userId
+        userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 用户的userId
     }, { collection: 'jinsaiinfo' });
     mdbgoose.model('JinSaiInfo', JinSaiInfoSchema);
 };

app/models/player.js

@@ -13,45 +13,45 @@ module.exports = function (app) {
         name: { type: String, default: '' },                        // 昵称
         sex: { type: String, default: '1' },                        // 性别
         headurl: { type: String, default: '' },                     // 头像
-        myurl: { type: String, default: ''},  
+        myurl: { type: String, default: ''},
         grade: { type: Number, default: 1},                         // 等级
         diamond: { type: Number, default: 5 },                    // 钻石
-        cost: { type: Number, default: 0 },                         // 消费
-        usdt: { type: Number, default: 0 },                         // ustd
+        cost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                         // 消费
+        usdt: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                         // ustd
         address: { type: String, default: '' },
-        score: { type: Number, default: 0 },                        // 积分
-        nnLuck: { type: Number, default: 0 },                       // 运气(牛牛)
+        score: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                        // 积分
+        nnLuck: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 运气(牛牛)
         tableId: { type: String, default: '' },                     // 桌子
-        rTableId: { type: Number, default: 0 },                     // 重入的房间号
-        gameId: { type: Number, default: 0 },                       // 游戏
+        rTableId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 重入的房间号
+        gameId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 游戏
         gameServerId: { type: String, default: '' },                // 游戏点
         connectorId: { type: String, default: '' },                 // 连接点
-        totalMoney: { type: Number, default: 0 },                   // 总充值
-        payReward: { type: Number, default: 0 },                    // 充值奖励
+        totalMoney: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 总充值
+        payReward: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 充值奖励
         registerIp: { type: String, default: '' },                  // 注册IP
         registerTime: { type: Number, default: Date.now },          // 注册时间
-        roleTime: { type: Number, default: 0 },                     // 角色时间
+        roleTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                     // 角色时间
         lastLoginIp: { type: String, default: '' },                 // 登陆IP
-        lastLoginTime: { type: Number, default: 0 },                // 最近登录
-        offlineTime: { type: Number, default: 0 },                  // 离线时间
+        lastLoginTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 最近登录
+        offlineTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                  // 离线时间
 
         enable: { type: Number, default: 1 },             // (0表示该玩家不可用被冻结，1正常)
-        regression: { type: Number, default: 0 },         // (0表示该玩家不是回归用户，1：是回归用户)
-        getacttime: { type: Number, default: 0 },         // (毫秒级时间戳类型，用于记录该玩家上次领取回归奖励的时间,和regression 搭配起来使用)
+        regression: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // (0表示该玩家不是回归用户，1：是回归用户)
+        getacttime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // (毫秒级时间戳类型，用于记录该玩家上次领取回归奖励的时间,和regression 搭配起来使用)
         tel: { type: String, default: '' },               // 手机号码
         pwd: { type: String, default: '' },               // 密码
         _class: { type: String, default: '' },
-        
+
         spreadId: { type: String, default: '' },          // 推荐人id
-        spreadCount: { type: Number, default: 0 },        // 推荐 人数
-        spreadRebate: { type: Number, default: 0 },       // 推荐 返利
-        spreadRebateOut: { type: Number, default: 0 },    // 推荐 已经提现
-        formId: { type: Number, default: 0 },             // 来源平台 0为微信 1为闲聊
+        spreadCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 推荐 人数
+        spreadRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 推荐 返利
+        spreadRebateOut: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    // 推荐 已经提现
+        formId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             // 来源平台 0为微信 1为闲聊
         form: { type: String, default: '' },              // 来源,新用户来源（如果是来自于推广的链接这里存储agentNo）
         smName: { type: String, default: '' },            // 实名认证姓名
         smCardId: { type: String, default: '' },          // 实名认证身份证号
         synPlayer: { type: String, default: '' }          // 钻石同步的用户
-        
+
     }, { collection: 'player' });
 
     mdbgoose.model('Player', PlayerSchema);
@@ -61,7 +61,7 @@ module.exports = function (app) {
         _id: { type: String },                    // 标识
         tel: { type: String, default: '' },       // 手机号码
         pwd: { type: String, default: '' },       // 密码
-        bindTime: { type: Number, default: 0 }    // 验证通过时间，=0时表示短信过去了待验证
+        bindTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }    // 验证通过时间，=0时表示短信过去了待验证
     }, { collection: 'tel' });
     mdbgoose.model('Tel', TelSchema);
 
@@ -77,7 +77,7 @@ module.exports = function (app) {
     var InviteSchema = new mdbgoose.Schema({
         _id: { type: String },                     // 被邀请人标识
         yId: { type: String },                     // 邀请人标识
-        yuId: { type: String, default: 0 },        // 邀请人用户id
+        yuId: { type: String, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 邀请人用户id
         yTime: { type: Number, default: Date.now } // 邀请时间
     }, { collection: 'invite' });
     mdbgoose.model('Invite', InviteSchema);
@@ -87,8 +87,8 @@ module.exports = function (app) {
         _id: { type: String },                       // UUID
         pId: { type: String },                       // 邀请人标识
         uId: { type: Number },                       // 邀请人用户id
-        all: { type: Number, default: 0 },           // 邀请人邀请的所有新人在该天的全部消耗
-        isSend: { type: Number, default: 0 },        //该天产生的奖励是否通过邮件已发送出去
+        all: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },           // 邀请人邀请的所有新人在该天的全部消耗
+        isSend: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        //该天产生的奖励是否通过邮件已发送出去
         dayTime: { type: Number, default: Date.now } // 统计时间，以天为单位
     }, { collection: 'invitesCost' });
     mdbgoose.model('InvitesCost', InvitesCostSchema);
@@ -102,10 +102,10 @@ module.exports = function (app) {
             16活动期间回归用户每日充值奖励钻石,17绑定手机,18邀新人按消耗比例返钻,
             19比赛4~10名送钻,20水果游戏,21水果任务,22水果排行榜,  只有11没有统计
         */
-        dType: { type: Number },                            
-        dSource: { type: Number, default: 0 },              // 原钻石
-        dSwap: { type: Number, default: 0 },                // 变化钻石 游戏
-        dNow: { type: Number, default: 0 },                 // 新钻石
+        dType: { type: Number },
+        dSource: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 原钻石
+        dSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 变化钻石 游戏
+        dNow: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 新钻石
         tableId: { type: String, default: '' },             // 房间标识
         registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'diamondRecord' });
@@ -122,9 +122,9 @@ module.exports = function (app) {
             19比赛4~10名送钻,20水果游戏,21水果任务,22水果排行榜,  只有11没有统计
         */
         dType: { type: Number },
-        dSource: { type: Number, default: 0 },              // 原钻石
-        dSwap: { type: Number, default: 0 },                // 变化钻石 游戏
-        dNow: { type: Number, default: 0 },                 // 新钻石
+        dSource: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 原钻石
+        dSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 变化钻石 游戏
+        dNow: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 新钻石
         tableId: { type: String, default: '' },             // 房间标识
         registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'taskQuanRecord' });
@@ -144,42 +144,42 @@ module.exports = function (app) {
         tel: { type: String, default: '' },                      // 手机号码
         pwd: { type: String, default: '' },                      // 密码
         rewardRate: { type: Number, default: 70},                   //奖励比例（0~100）占比业绩
-        myUrl: { type: String,default: '' },  
-        levelFlag: { type: Number, default: 0},                     // 推广等级0：实习，1：普通推广，2：金牌推广，3：比赛推广，4：传单推广
+        myUrl: { type: String,default: '' },
+        levelFlag: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                     // 推广等级0：实习，1：普通推广，2：金牌推广，3：比赛推广，4：传单推广
         enabled: { type: Number, default: 1},                       // 是否可用，0：不可用，1：可用，
         parentAgenterId: { type: String, default: '' },             // 上级推广ID，没有上级的此值为""
-        parentRate: { type: Number, default: 0 },                   // 上级推广的比例,无上级时此值为0，有上级此值才可能不为0
-        rebateAll2: { type: Number, default: 0 },      // 自己小组可提现总返利（包括审核中的） 单位是钻石且乘过比例的 在每局结束后增加
-        rebateNow2: { type: Number, default: 0 },                   // 自己小组（下级推广）的可提现返利
-        verifyRebate2: { type: Number, default: 0 },                // 自己小组（下级推广）的审核的返利
-        verifyDate2: { type: Number, default: 0 },                  // 自己小组（下级推广） 审核日期
-        rebateOut2: { type: Number, default: 0 },                   // 自己小组（下级推广）的已提现返利
-
-        agentRate: { type: Number, default: 0},                     // 额外返利的比例
-        rebateOther: { type: Number, default: 0 },                  // 其他 额外返利
-        rebateCount: { type: Number, default: 0 },    // 返利合计 = 基础 + 额外 单位是钻石且乘过比例的
-        rebateAll: { type: Number, default: 0 },      // 可提现总返利（不包含额外）单位是钻石且乘过比例的
-        rebateNow: { type: Number, default: 0 },                    // 可提现返利（已审核的自己基础的+额外的），
-        rebateOut: { type: Number, default: 0 },                    // 已提现返利
-        verifyDate: { type: Number, default: 0 },                   // 审核日期
-        verifyRebate: { type: Number, default: 0 },                 // 审核的返利
+        parentRate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 上级推广的比例,无上级时此值为0，有上级此值才可能不为0
+        rebateAll2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 自己小组可提现总返利（包括审核中的） 单位是钻石且乘过比例的 在每局结束后增加
+        rebateNow2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 自己小组（下级推广）的可提现返利
+        verifyRebate2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 自己小组（下级推广）的审核的返利
+        verifyDate2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                  // 自己小组（下级推广） 审核日期
+        rebateOut2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 自己小组（下级推广）的已提现返利
+
+        agentRate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                     // 额外返利的比例
+        rebateOther: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                  // 其他 额外返利
+        rebateCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },    // 返利合计 = 基础 + 额外 单位是钻石且乘过比例的
+        rebateAll: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 可提现总返利（不包含额外）单位是钻石且乘过比例的
+        rebateNow: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 可提现返利（已审核的自己基础的+额外的），
+        rebateOut: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                    // 已提现返利
+        verifyDate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                   // 审核日期
+        verifyRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 审核的返利
         //以下字段是用来展示和计算额外返利使用的，目前没有额外比例所以去掉以下字段
-        // dateGameTimes02: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes03: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes0: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes42: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes43: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes4: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes82: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes83: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes8: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes162: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameTimes163: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameTimes164: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameCost0: { type: Number, default: 0 },                // 冲刺游戏消耗
-        // dateGameCost4: { type: Number, default: 0 },                // 4局游戏消耗
-        // dateGameCost8: { type: Number, default: 0 },                // 8局游戏消耗
-        // dateGameCost16: { type: Number, default: 0 },               // 16局游戏消耗
+        // dateGameTimes02: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes03: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes0: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes42: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes43: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes82: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes83: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes8: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes162: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameTimes163: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameTimes164: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameCost0: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 冲刺游戏消耗
+        // dateGameCost4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 4局游戏消耗
+        // dateGameCost8: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 8局游戏消耗
+        // dateGameCost16: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 16局游戏消耗
         registerTime: { type: Number, default: Date.now }           // 注册时间
     }, { collection: 'agenter' });
 
@@ -204,24 +204,24 @@ module.exports = function (app) {
 
     mdbgoose.model('AgenterAgree', AgenterAgreeSchema);
 
-    
+
 
     // 返利记录
     var RebateRecordSchema = new mdbgoose.Schema({
         _id: { type: String },                              // UUID
         agentId: { type: String, default: '' },             // 代理标识
         tableId: { type: String, default: '' },             // 房间标识
-        rType: { type: Number, default: 0 },                // 类型 1为锁定返利增加 2为提现 3为前日结算 4为小组锁定返利增加 5为小组前日结算 6为小组提现 
-        rCount: { type: Number, default: 0 },               // 合计
-        rOther: { type: Number, default: 0 },               // 总奖励
-        rAll: { type: Number, default: 0 },                 // 总返利
-        rNow: { type: Number, default: 0 },                 // 可提取返利
-        rOut: { type: Number, default: 0 },                 // 已经提取返利
-        rSwap: { type: Number, default: 0 },                // 返利金额
-        rKouZuan: { type: Number, default: 0 },             // 扣业绩钻石数量
-        rDateSwap: { type: Number, default: 0 },            // 日奖励
-        rVerifyDate: { type: Number, default: 0 },          // 审核返利日期
-        rVerifyRebate: { type: Number, default: 0 },        // 审核返利金额
+        rType: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 类型 1为锁定返利增加 2为提现 3为前日结算 4为小组锁定返利增加 5为小组前日结算 6为小组提现
+        rCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 合计
+        rOther: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 总奖励
+        rAll: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 总返利
+        rNow: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 可提取返利
+        rOut: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 已经提取返利
+        rSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 返利金额
+        rKouZuan: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             // 扣业绩钻石数量
+        rDateSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },            // 日奖励
+        rVerifyDate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 审核返利日期
+        rVerifyRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 审核返利金额
         registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'rebateRecord' });
 
@@ -231,39 +231,39 @@ module.exports = function (app) {
     var DateRebateRecordSchema = new mdbgoose.Schema({
         _id: { type: String },                              // UUID
         agentId: { type: String, default: '' },             // 代理标识
-        verifyDate: { type: Number, default: 0 },          // 数据的日期
-        verifyRebate: { type: Number, default: 0 },        // 返利金额（该日期自己的返利，单位是钻石，已乘过自己比例）
-        dateAgentRate: { type: Number, default: 0 },       // 该日期当日额外返利的比例
-        dateRebate: { type: Number, default: 0 },          // 该日期 额外返利金额
+        verifyDate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 数据的日期
+        verifyRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 返利金额（该日期自己的返利，单位是钻石，已乘过自己比例）
+        dateAgentRate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 该日期当日额外返利的比例
+        dateRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 该日期 额外返利金额
 
-        dateRewardRate: { type: Number, default: 0 },       // 进行日结当日该推广自己的返利的比例
+        dateRewardRate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 进行日结当日该推广自己的返利的比例
         parentaId: { type: String, default: '' },           // 代理上级的标识
-        dateParentRate: { type: Number, default: 0 },       // 进行日结当日该推广上级的返利的比例
-        parentRebate: { type: Number, default: 0 },         // 该日期 该推广上级的返利金额
-        allGameCost: { type: Number, default: 0 },          // 该日期该推广产生的总游戏消耗
-        allGiftCost: { type: Number, default: 0 },          // 该日期该推广产生的总礼物消耗
-        allGameTimes1: { type: Number, default: 0 },        // 该日期该推广产生的总游戏1次数
-        allGameTimes2: { type: Number, default: 0 },        // 该日期该推广产生的总游戏2次数
-        allGameTimes3: { type: Number, default: 0 },        // 该日期该推广产生的总游戏3次数
-        allGameTimes4: { type: Number, default: 0 },        // 该日期该推广产生的总游戏4次数
-        allPlayeCount: { type: Number, default: 0 },       // 该日期该推广活跃玩家个数
-
-        // dateGameTimes02: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes03: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes0: { type: Number, default: 0 },               // 冲刺游戏次数
-        // dateGameTimes42: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes43: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes4: { type: Number, default: 0 },               // 4局游戏游戏次数
-        // dateGameTimes82: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes83: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes8: { type: Number, default: 0 },               // 8局游戏次数
-        // dateGameTimes162: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameTimes163: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameTimes16: { type: Number, default: 0 },              // 16局游戏次数
-        // dateGameCost0: { type: Number, default: 0 },                // 冲刺游戏消耗
-        // dateGameCost4: { type: Number, default: 0 },                // 4局游戏消耗
-        // dateGameCost8: { type: Number, default: 0 },                // 8局游戏消耗
-        // dateGameCost16: { type: Number, default: 0 },               // 16局游戏消耗
+        dateParentRate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 进行日结当日该推广上级的返利的比例
+        parentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },         // 该日期 该推广上级的返利金额
+        allGameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 该日期该推广产生的总游戏消耗
+        allGiftCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 该日期该推广产生的总礼物消耗
+        allGameTimes1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 该日期该推广产生的总游戏1次数
+        allGameTimes2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 该日期该推广产生的总游戏2次数
+        allGameTimes3: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 该日期该推广产生的总游戏3次数
+        allGameTimes4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 该日期该推广产生的总游戏4次数
+        allPlayeCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 该日期该推广活跃玩家个数
+
+        // dateGameTimes02: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes03: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes0: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 冲刺游戏次数
+        // dateGameTimes42: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes43: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 4局游戏游戏次数
+        // dateGameTimes82: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes83: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes8: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 8局游戏次数
+        // dateGameTimes162: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameTimes163: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameTimes16: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 16局游戏次数
+        // dateGameCost0: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 冲刺游戏消耗
+        // dateGameCost4: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 4局游戏消耗
+        // dateGameCost8: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                // 8局游戏消耗
+        // dateGameCost16: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 16局游戏消耗
         registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'daterebateRecord' });
 
@@ -272,18 +272,18 @@ module.exports = function (app) {
 
 
 
-     // 玩家局数统计
+    // 玩家局数统计
     var PlayerCountSchema = new mdbgoose.Schema({
         _id: { type: String },                              // UUID
         agentId: { type: String, default: '' },             // 代理标识
         playerId: { type: String, default: '' },            // 玩家标识
-        userId: { type: Number, default: 0 },               // 玩家号码
+        userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },               // 玩家号码
         name: { type: String, default: '' },                // 昵称
-        date: { type: Number, default: 0 },                 // 日期
-        gameCount: { type: Number, default: 0},             // 局数统计
-        gameCost: { type: Number, default: 0 },             // 游戏消耗
-        agentRebate: { type: Number, default: 0 },          // 代理返利
-        time: { type: Number, default: 0 }                  // 记录时间
+        date: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                 // 日期
+        gameCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},             // 局数统计
+        gameCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             // 游戏消耗
+        agentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 代理返利
+        time: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} }                  // 记录时间
     }, { collection: 'playercount' });
 
     mdbgoose.model('PlayerCount', PlayerCountSchema);
@@ -292,13 +292,13 @@ module.exports = function (app) {
     // var DateAgentInfoSchema = new mdbgoose.Schema({
     //     _id: { type: String },                           // UUID
     //     agentId: { type: String, default: '' },          // 代理标识
-    //     dataDate: { type: Number, default: 0 },          // 数据产生的日期
-    //     allCost: { type: Number, default: 0 },           // 该日该推广总消耗 单位是钻石 在每局结束之后修改，增量=该局消耗
-    //     zjjcRebate: { type: Number, default: 0 },        // 该日该推广自己的基础返利 单位是钻石 在每局结束之后修改，增量=该局消耗*rewardRate
-    //     otherRebate: { type: Number, default: 0 },       // 该日该推广自己的额外返利 单位是钻石 在每局结束之后修改，增量=该局消耗*agentRate
-    //     parentRebate: { type: Number, default: 0 },      // 该日该推广贡献给自己上级的返利 单位是钻石 在每局结束之后修改，增量=该局消耗*parentRate
-    //     pCount: { type: Number, default: 0 },            // 该日该推广活跃人数
-    //     gameCount: { type: Number, default: 0},          //该日该推广局数统计 在每局结束之后修改，增量=1
+    //     dataDate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },          // 数据产生的日期
+    //     allCost: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },           // 该日该推广总消耗 单位是钻石 在每局结束之后修改，增量=该局消耗
+    //     zjjcRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },        // 该日该推广自己的基础返利 单位是钻石 在每局结束之后修改，增量=该局消耗*rewardRate
+    //     otherRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },       // 该日该推广自己的额外返利 单位是钻石 在每局结束之后修改，增量=该局消耗*agentRate
+    //     parentRebate: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },      // 该日该推广贡献给自己上级的返利 单位是钻石 在每局结束之后修改，增量=该局消耗*parentRate
+    //     pCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },            // 该日该推广活跃人数
+    //     gameCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},          //该日该推广局数统计 在每局结束之后修改，增量=1
     //     registerTime: { type: Number, default: Date.now }// 记录时间
     // }, { collection: 'dateAgentInfo' });
     // mdbgoose.model('DateAgentInfo', DateAgentInfoSchema);
@@ -308,11 +308,11 @@ module.exports = function (app) {
         _id: { type: String },                              // UUID
         agentId: { type: String, default: '' },             // 代理标识
         outType: { type: Number, default: 1 },              // 提现类型：1为提取自己的，2为提取自己下级的
-        outSwap: { type: Number, default: 0 },              // 提现金额
-        kouZuan: { type: Number, default: 0 },              // 扣业绩钻石数量
-        totalFee: { type: Number, default: 0 },             // 发放金额
+        outSwap: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 提现金额
+        kouZuan: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },              // 扣业绩钻石数量
+        totalFee: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },             // 发放金额
         payState: { type: Number, default: 1 },             // 支付状态 1为未支付   2人工支付 3支付成功
-        registerTime: { type: Number, default: Date.now }   // 记录时间 
+        registerTime: { type: Number, default: Date.now }   // 记录时间
     }, { collection: 'outRebate' });
 
     mdbgoose.model('OutRebate', OutRebateSchema);
@@ -320,7 +320,7 @@ module.exports = function (app) {
     // 申请推广员TL++10月16日
     var applyTGchema = new mdbgoose.Schema({
         _id: { type: String },                    // 标识
-        // userId: { type: Number, default: 0 },  // 玩家号码
+        // userId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },  // 玩家号码
         applyType: { type: Number, default: 1 },  // 申请推广的类型，1：普通，通过大厅自主申请，2：金牌推广员邀请小组新成员申请
         parenteId:{ type: String, default: '' },  // 申请推广的上级id，目前只有applyType=2时此值为操作邀请的推广id
         tgName: { type: String, default: '' },    // 申请推广的姓名
@@ -335,32 +335,32 @@ module.exports = function (app) {
     // 某一单款或玩法后台可配置维护中
     var WHZGameSchema = new mdbgoose.Schema({
         _id: { type: String, default: '' },                 // 记录标识
-        gameId: { type: Number, default: 0},                // 维护中的游戏id
-        whAll: { type: Number, default: 0},                 // 1:表示整个游戏的所有玩法均维护，0：部分玩法维护
-        round: { type: Number, default: 0},                 // 维护中的游戏局数
-        playerCount: { type: Number, default: 0},           // 维护中的游戏人数
-        other: { type: Number, default: 0},                 // 维护中的游戏规则
-        type: { type: Number, default: 0},                  // 维护中的游戏type
-        gameKind: { type: Number, default: 0}               // 维护中的游戏gameKind
+        gameId: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                // 维护中的游戏id
+        whAll: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                 // 1:表示整个游戏的所有玩法均维护，0：部分玩法维护
+        round: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                 // 维护中的游戏局数
+        playerCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},           // 维护中的游戏人数
+        other: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                 // 维护中的游戏规则
+        type: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                  // 维护中的游戏type
+        gameKind: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}}               // 维护中的游戏gameKind
 
     });
 
     // 活动的达成条件和奖励信息列表
     // var ActiveReachAndRewardInfoSchema = new mdbgoose.Schema({
     //     _id: { type: String, default: ''  },                // 记录标识
-    //     reachType: { type: Number, default: 0},             // 达成条件类型1:邀新,2:完成游戏局数,3:充值,4:回归
-    //     reachCount: { type: Number, default: 0},            // 达成条件所需数量
-    //     reachType: { type: Number, default: 0},             // 奖励类型1:钻石,
-    //     reachType: { type: Number, default: 0}             // 达成之后奖励的数量
-        
+    //     reachType: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},             // 达成条件类型1:邀新,2:完成游戏局数,3:充值,4:回归
+    //     reachCount: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},            // 达成条件所需数量
+    //     reachType: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},             // 奖励类型1:钻石,
+    //     reachType: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}}             // 达成之后奖励的数量
+
     // });
 
     // // 活动配置信息
     // var ActiveSchema = new mdbgoose.Schema({
     //     _id: { type: String, default: '' },                 // 记录标识
-    //     type: { type: Number, default: 0},                  // 1:邀新送钻,2:累充送钻,3:组局领钻,4回归福利
+    //     type: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                  // 1:邀新送钻,2:累充送钻,3:组局领钻,4回归福利
     //     des: { type: String, default: '' },                 // 活动描述
-    //     open: { type: Number, default: 0},                  // 0关闭,1:开启
+    //     open: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                  // 0关闭,1:开启
     //     startTime: { type: Number,  default: Date.now },    // 开始日期
     //     endTime: { type: Number,  default: Date.now },      // 结束日期
     //     reachAndRewardInfo: [ActiveReachAndRewardInfoSchema]// 该活动的达成条件和奖励信息列表
@@ -369,38 +369,38 @@ module.exports = function (app) {
     // 是否维护
     var WHstatechema = new mdbgoose.Schema({
         _id: { type: String, default: 'wh'},                              // UUID
-        stateWH: {type: Number, default: 0},             // 维护状态0为正常1为维护中
+        stateWH: {type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},             // 维护状态0为正常1为维护中
         whTip: { type: String, default: '游戏正在维护，请稍后创建房间' },            // 维护提示
         rebaterate: { type: Number, default: 60},           // 返利比例
         shareGive: { type: Number, default: 50},            // 分享赠钻
-        yxndlbTime: {type: Number, default: 0},             // 游戏内大喇叭(跑马灯)通知间隔时间
+        yxndlbTime: {type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},             // 游戏内大喇叭(跑马灯)通知间隔时间
         yxndlbTip: { type: String, default: '' },           // 游戏内大喇叭(跑马灯)通知内容
         whzGame: [WHZGameSchema]                           // 某一单款或玩法后台可配置维护中
     }, { collection: 'whstate' });
 
     mdbgoose.model('WHstate', WHstatechema);
 
-    
+
     // 不能在一起（同一桌）游戏的玩家信息 TL++
     var NotGameTogtherSchema = new mdbgoose.Schema({
         _id: { type: String },                     // UUID
-        uidList: [Number],                         //不能在同一桌的玩家userid列表
+        uidList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},                         //不能在同一桌的玩家userid列表
         pidList: [String],                         //不能在同一桌的玩家_id列表
     }, { collection: 'notGameTogther' });
 
     mdbgoose.model('NotGameTogther', NotGameTogtherSchema);
-    
+
     // 每日峰值统计 TL++
     var EverytopSchema = new mdbgoose.Schema({
         _id: { type: String },                                      // UUID
         daytime: { type: Number, default: Date.now  },              // 写入时间
-        onlineList: [Number],                                       // 整点在线人数列表
-        onlineTop: { type: Number , default: 0},                    // 今日在线峰值
+        onlineList: {type: [Number],set: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});},get: function(arr) {if (!Array.isArray(arr)) return arr;return arr.map(num => {return Number(Number(num).toFixed(2));});}},                                       // 整点在线人数列表
+        onlineTop: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                    // 今日在线峰值
         onlineTop_t: { type: Number, default: Date.now  },          // 今日在线峰值出现时间
-        registCount: { type: Number , default: 0},                  // 今日注册的用户数量
-        loginCount: { type: Number , default: 0},                   // 今日登录过的用户数量
-        payCount: { type: Number , default: 0},                     // 今日充值总额
-        outRebateCount: { type: Number , default: 0}                // 今日提现总额
+        registCount: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                  // 今日注册的用户数量
+        loginCount: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                   // 今日登录过的用户数量
+        payCount: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}},                     // 今日充值总额
+        outRebateCount: { type: Number , default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));}}                // 今日提现总额
     }, { collection: 'everytop' });
 
     mdbgoose.model('EveryTop', EverytopSchema);
@@ -409,13 +409,13 @@ module.exports = function (app) {
     var JiPaiQiSchema = new mdbgoose.Schema({
         _id: { type: String },                                      // 标识
         userId: { type: Number },                                   // 用户编号
-        times0: { type: Number, default: 0 },                       // 免费试用次数
-        times1: { type: Number, default: 0 },                       // 7天卡购买次数
-        times2: { type: Number, default: 0 },                       // 30天卡购买次数
-        jpqdqsj: { type: Number, default: 0 },                      // 记牌器到期时间
-        lastBuyTime: { type: Number, default: 0 },                  // 最近试用或购买时间
+        times0: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 免费试用次数
+        times1: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 7天卡购买次数
+        times2: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                       // 30天卡购买次数
+        jpqdqsj: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                      // 记牌器到期时间
+        lastBuyTime: { type: Number, default: 0, set: function(value) {return Number(Number(value).toFixed(2));}, get: function(value) {return Number(Number(value).toFixed(2));} },                  // 最近试用或购买时间
         registerTime: { type: Number,  default: Date.now }          // 首次试用或购买时间
-        
+
     }, { collection: 'jipaiqi' });
     mdbgoose.model('JiPaiQi', JiPaiQiSchema);
 };

app/servers/hall/handler/hallHandler.js

@@ -2848,6 +2848,17 @@ proto.mailInfo = P.coroutine(function* (msg, session, next) {
     return next(null, { code: C.OK, data: data });
 });
 
+proto.getTodaySJC = function (){
+    var today = new Date();
+    today.setHours(0);
+    today.setMinutes(0);
+    today.setSeconds(0);
+    today.setMilliseconds(0);
+    let jrsjc = today.getTime();
+    // console.warn("111得到今日0点的时间戳   ",jrsjc, typeof jrsjc);
+    return jrsjc;
+};
+
 // tl++处理单个邮件
 proto.dealMail = P.coroutine(function* (msg, session, next) {
     // console.warn("处理单个邮件111   "+session.uid + "  msg.index  "+msg.index);

app/shuiguo/table.js

@@ -453,7 +453,7 @@ proto.getUSDTSum = cor(function* () {
     let jrsjc = today.getTime()- 24 * 60 * 60 * 1000;
 
     jrsjc = today.getTime()
-    console.warn("jrsjc:",jrsjc)
+
     var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:jrsjc})
     var limit = 1000
     var page = 0
@@ -466,12 +466,11 @@ proto.getUSDTSum = cor(function* () {
                 skip: skip,
                 limit: Number(limit)
             });
-            console.warn("players:",players.length)
             if (players.length > 0) {
                 for (let player of players) {
-                    console.warn("player.diamond:",player.diamond)
+                    //console.warn("player.diamond:",player.diamond)
                     all += player.diamond
-                    console.warn("all:",all)
+                    //console.warn("all:",all)
                 }
             }else {
                 break
@@ -495,7 +494,7 @@ proto.joinAsync = cor(function* (user) {
     let drCount = 0;
     var sgjUser = yield this.app.models.SGJUser.findByIdAsync(user.id, 'taskQuan yazhuList jrkbcdrs drCount drTime lastJoinTime');
     if (!this.calculateTimer) {
-        this.calculateTimer = this.app.timer.setTimeout(() => this.getUSDTSum(), 100000);
+        this.calculateTimer = this.app.timer.setInterval(() => this.getUSDTSum(), 100000);
     }
     if (sgjUser) {
         sgjUser.drCount = sgjUser.drCount.toFixed(2)
@@ -741,6 +740,7 @@ proto.zsbgjlAsync = cor(function* (user, chairId) {
             sgjztj.rwdcze3 = 0;  //备用任务兑出总额（领奖时记录）
             sgjztj.rwdcze4 = 0;  //备用任务兑出总额（领奖时记录）
             let cwindx = 0;
+            console.warn("sgjztj.allyzze.length:",sgjztj.allyzze.length," this.allyzze.length:",this.allyzze.length)
             if(sgjztj.allyzze.length != this.allyzze.length) cwindx = 1;
             if(sgjztj.allydze.length != this.allydze.length) cwindx = 2;
             if(sgjztj.gxzydze.length != this.gxzydze.length) cwindx = 3;
@@ -757,6 +757,7 @@ proto.zsbgjlAsync = cor(function* (user, chairId) {
                 // 下面这两个数据是长度为8的数组，分别代表[苹果,橙子,芒果,铃铛,西瓜,星星,七七,王王]
                 for (var i = 0; i < sgjztj.allyzze.length; i++) {
                     allyzze[i] = sgjztj.allyzze[i] + this.allyzze[i];
+                    console.warn("760 this.allyzze:",this.allyzze)
                 }
                 for (var i = 0; i < sgjztj.allydze.length; i++) {
                     allydze[i] = sgjztj.allydze[i] + this.allydze[i];
@@ -782,7 +783,7 @@ proto.zsbgjlAsync = cor(function* (user, chairId) {
                 sgjztj.gxcxzcs = _.cloneDeep(gxcxzcs);
                 sgjztj.tsxzydze = _.cloneDeep(tsxzydze);
                 sgjztj.tsxcxzcs = _.cloneDeep(tsxcxzcs);
-
+                console.warn("784 allyzze:",sgjztj.allyzze)
             }
             else{
                 let nowTime = Date.now();
@@ -790,6 +791,7 @@ proto.zsbgjlAsync = cor(function* (user, chairId) {
                 sgjztj.errstr += errstr;
 
             }
+            console.warn("792 sgjztj:",sgjztj)
             yield sgjztj.saveAsync();
             // console.warn("更改总的  ",cwindx,sgjztj);
         }
@@ -824,6 +826,7 @@ proto.zsbgjlAsync = cor(function* (user, chairId) {
                 tsxzydze: _.cloneDeep(this.tsxzydze),                //特殊项总赢得总额列表
                 tsxcxzcs: _.cloneDeep(this.tsxcxzcs),                //特殊项出现总次数列表
             });
+            console.warn("829 allyzze:",sgjtj.allyzze)
             yield sgjtj.saveAsync();
             // console.warn("创建总的  ",sgjtj);
         }
@@ -1280,7 +1283,6 @@ proto.startGameAsync = cor(function* (yazhus) {
     let bczxz = _.sum(this.yazhus);//本次总下注
     console.warn("bczxz:",bczxz)
     let jcPools = yield this.app.models.SGJJC.findByIdAsync('sgjjcs');
-    console.warn("jcpools:",jcPools)
     let mqdw = -1;//目前挡位
     let cjjcsjk = 1;//是否创建奖池数据库
     if (jcPools) {
@@ -1584,6 +1586,7 @@ proto.startGameAsync = cor(function* (yazhus) {
     for (var i = 0; i < this.yazhus.length; i++) {
         if(!this.allyzze [i]) this.allyzze [i] = 0;
         this.allyzze [i] += this.yazhus[i]
+        console.warn("1589 this.allyzze:",this.allyzze)
     } 
     for (var i = 0; i < winList.length; i++) {
         if(!this.allydze [i]) this.allydze [i] = 0;
@@ -2603,7 +2606,7 @@ proto.dealRenWuAsync = cor(function* (playerId,chairId,item) {
         this.users[0].taskQuan = sgjUser.taskQuan;
         yield sgjUser.saveAsync();
     }
-    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:this.getTodaySJC()})
+    var SGJUserTongjis = yield this.app.models.SGJUserTongji.findMongoAsync({todaytime:this.logic.getTodaySJC()})
     var SGJUserTongji = null
     if (SGJUserTongjis.length == 0) {
         SGJUserTongji = this.app.models.SGJUserTongji({
@@ -2678,12 +2681,15 @@ proto.renWuLingjiangAsync = cor(function* (playerId,chairId,item) {
             return { code: C.FAILD, msg: "未绑定支付宝信息" };//领任务的时候绑定支付宝信息
         }
     }
+    console.warn("rewardt:",rewardt)
+    console.warn("item:",item)
     if(rewardt == 1){
         //钻石
         let diamond = ywcrwList[0].rewards;
         ywcrwList[0].state = 3;
         ywcrwList[0].fjTime = Date.now();
         yield ywcrwList[0].saveAsync();
+        console.warn("2687")
         yield this.lconfigCommon.senMailToPlayer(playerId,userid,15,15,1,1,diamond,"sgjSys");
         if (sgjUser) {
             sgjUser.ylzsReward += diamond;