import GameUtil from '../core/GameUtil';
import EquipMgr from "../object/EquipMgr";
import DBFrom from "./DBForm";
import SKDataUtil from "../gear/SKDataUtil";
import SKRedisUtil from "../gear/SKRedisUtil";
import SKLogger from '../gear/SKLogger';
import Pet from '../object/Pet';
import SKDBUtil from '../gear/SKDBUtil';
import SkillBase from "../skill/core/SkillBase";
import Horse from '../horse/Horse';
import { MsgCode } from '../role/EEnum';
import Scheme from '../object/Scheme';
import RobotMgr from '../core/RobotMgr';
import MailData from '../mail/MailData';
import MagicWeaponMgr from '../object/MagicWeaponMgr';

export default class DB {

    static init() {
    };

    static query(sql: string, callback: (error: any, rows: any[]) => void) {
        if (SKDataUtil.isEmptyString(sql)) {
            let msg = `SQL错误:[SQL不能为空]!`
            SKLogger.warn(msg);
            callback(new Error(msg), null);
            return;
        }
        DBFrom.shared.query(sql, callback);
    };
    // 设置
    static set(key: any, value: any, callback: (success: boolean) => void) {
        if (key == null) {
            callback(false);
            return;
        }
        let sql = `INSERT INTO t_tbl(t_key,t_value )VALUES('${key}','${value}') ON DUPLICATE KEY UPDATE t_value='${value}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(false);
                return;
            }
            if (rows.length == 0) {
                callback(false);
                return;
            }
            callback(true);
        });
    };
    // 获取
    static get(key: any, callback: (result: any) => void) {
        if (key == null) {
            callback(null);
            return;
        }
        var sql = `SELECT * FROM t_tbl WHERE t_key='${key}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(null);
                return;
            }
            if (rows.length == 0) {
                callback(null);
                return;
            }
            callback(rows[0].t_value);
        });
    };
    // 更新登录信息  TODO 加入 version
    static updateLoginInfo(accountid: any, ip: any, mac: any) {
        let sql = `UPDATE qy_account SET last_login_time=now(),login_ip='${ip}',mac='${mac}' WHERE accountid =${accountid};`;
        DB.query(sql, (error: any, rows: any) => {
        })
    }
    // 帐号登录
    static accountLogin(logininfo: any, callback: (code: number, msg: string, data: any) => void) {
        let account = logininfo.account;
        let password = logininfo.password;
        let ip = logininfo.ip == null ? "" : logininfo.ip;
        let mac = logininfo.mac;
        if (account == null || password == null) {
            SKLogger.warn(`$警告:[${account}:${password}]帐号或密码不能为空!`);
            callback(MsgCode.FAILED, "帐号或密码不能为空", null);
            return;
        }
        account.replace("\'", "\\\'");
        password.replace("\"", "\\\"");
        let sql = `SELECT * FROM qy_account WHERE account = "${account}";`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, "登录数据库错误!", null);
                return;
            }
            if (rows.length > 0) {
                let data = rows[0];
                if (password == data.password) {
                    callback(MsgCode.SUCCESS, "登录成功", data);
                    SKLogger.debug(`用户[${account}:${password}]登录帐号成功!`);
                    data.login_ip = ip;
                    data.mac = mac;
                    DB.updateLoginInfo(data.accountid, ip, mac);
                    // SKRedisUtil.setValue(`${account}_login_data`, data);
                } else {
                    SKLogger.warn(`$警告:[${account}:${password}]登录帐号密码错误!`);
                    callback(MsgCode.LOGIN_ACCOUNT_PWD_ERROR, "登录帐号密码错误", null);
                }
            } else {
                SKLogger.warn(`$警告:[${account}:${password}]登录帐号不存在!`);
                let msg = `登录帐号不存在`
                callback(MsgCode.LOGIN_ACCOUNT_PWD_ERROR, msg, null);
            }
        })
    }
    // 帐号注册
    static accountRegister(register_info: any, callback: (code: number, msg: string) => void) {
        let account = register_info.account;
        let password = register_info.password;
        let invitecode = register_info.invitecode;
        var sql = `SELECT * FROM qy_account WHERE account = "${account}";`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `注册帐号:SQL错误,请稍候重试!`);
                return;
            }
            if (rows.length > 0) {
                callback(MsgCode.FAILED, `帐号[${account}]已注册,请更换!`);
                return;
            } else {
                sql = `INSERT INTO qy_account(account, password,invite, register_time) VALUES('${account}', '${password}','${invitecode}', NOW() );`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, `注册帐号:插入失败,请稍候重试!`);
                        return;
                    }
                    callback(MsgCode.SUCCESS, `帐号${account}注册成功!`);
                });
            }
        });
    }
    // 修改帐号密码
    static async accountChangePassword(data: any, callback: (code: number, msg: string) => void) {
        let account = data.account;
        let safecode = data.safecode;
        let password = data.password;
        let loginData: any = await SKRedisUtil.getValue(`${account}_login_data`);
        if (loginData) {
            loginData.password = password;
        }
        let sql = `UPDATE qy_account SET password = '${password}' WHERE account = '${account}' and safecode like '_:${safecode}';`;
        DB.query(sql, (error: any) => {
            if (error) {
                callback(MsgCode.FAILED, `修改密码数据库错误,请稍候重试!`);
                return;
            } else {
                callback(MsgCode.SUCCESS, `修改密码成功!`);
            }
        });
    };

    static getFrozenList(callback: (code: number, rows: any) => void) {
        let sql = `SELECT frozen_ip FROM ip_frozen;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, []);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED, []);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    static getFrozenIpRoleid(ip: any, callback: (code: number, rows: any) => void) {
        var sql = `SELECT accountid FROM qy_account WHERE login_ip = '${ip}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, []);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED, []);
                return;
            }
            let accounts = '';
            for (const id of rows) {
                accounts = accounts + id.accountid + ',';
            }
            accounts = accounts.substr(0, accounts.length - 1);
            sql = `SELECT roleid FROM qy_role WHERE accountid IN (${accounts});`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED, []);
                    return;
                }
                if (rows.length == 0) {
                    callback(MsgCode.FAILED, []);
                    return;
                }
                callback(MsgCode.SUCCESS, rows);
            });
        });
    }

    static freezeIP = (accountid: any, callback: any) => {
        var sql = `SELECT login_ip FROM qy_account WHERE accountid = '${accountid}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED);
                return;
            }
            let fip = rows[0].login_ip;
            sql = `SELECT * FROM ip_frozen WHERE frozen_ip = '${fip}';`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED);
                    return;
                }
                if (rows.length > 0) {
                    callback(MsgCode.SUCCESS, 0);
                    return;
                }
                sql = `INSERT INTO ip_frozen(account_id, frozen_ip, frozen_time) VALUES('${accountid}', '${fip}', NOW());`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    callback(MsgCode.SUCCESS, fip);
                });
            });
        });
    }

    static getFrozenMacList = (callback: any) => {
        let sql = `SELECT mac FROM mac_frozen;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, []);
                return;
            }
            if (rows && rows.length == 0) {
                callback(MsgCode.FAILED, []);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    static clearFrozenMacTabel(callback: (code: number, rows: any) => void) {
        let sql = `TRUNCATE mac_frozen;`
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    static getFrozenMacRoleid(mac: string, callback: (code: number, rows: any) => void) {
        var sql = `SELECT accountid FROM qy_account WHERE mac = '${mac}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, []);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED, []);
                return;
            }
            let accounts = '';
            for (const id of rows) {
                accounts = accounts + id.accountid + ',';
            }
            accounts = accounts.substr(0, accounts.length - 1); //.splice(-1);
            sql = `SELECT roleid FROM qy_role WHERE accountid in (${accounts});`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED, []);
                    return;
                }
                if (rows.length == 0) {
                    callback(MsgCode.FAILED, []);
                    return;
                }
                callback(MsgCode.SUCCESS, rows);
            });
        });
    }
    // 封设备
    static freezeMAC = (info: any, callback: (code: number, msg: string, mac: string) => void) => {
        let account_id = info.account_id;
        let gm_role_id = info.gm_role_id;
        let sql = `SELECT mac FROM qy_account WHERE accountid = '${account_id}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `禁设备:帐号[${account_id}]查询SQL错误!`, "");
                return;
            }
            if (rows.length < 1) {
                callback(MsgCode.FAILED, `禁设备:帐号[${account_id}]已被封禁MAC!`, "");
                return;
            }
            let mac = rows[0].mac;
            sql = `SELECT * FROM mac_frozen WHERE mac = '${mac}';`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED, `禁设备:帐号[${account_id}]封禁已存在!`, "");
                    return;
                }
                if (rows.length > 0) {
                    callback(MsgCode.FAILED, `禁设备:帐号[${account_id}]已封禁!`, mac);
                    return;
                }
                sql = `INSERT INTO mac_frozen(account_id,mac,gm_role_id) VALUES('${account_id}','${mac}','${gm_role_id}');`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, `禁设备:帐号[${account_id}]插入:SQL错误!`, mac);
                        return;
                    }
                    callback(MsgCode.SUCCESS, `禁设备:帐号[${account_id}]封禁成功!`, mac);
                });
            });
        });
    }
    // 解封帐号
    static unfreezeMAC = (info: any, callback: (code: number, msg: string, mac: string) => void) => {
        let account_id = info.account_id;
        let sql = `SELECT mac FROM qy_account WHERE accountid = '${account_id}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `帐号${account_id}解封Mac,SQL错误!`, "");
                return;
            }
            if (rows.length < 1) {
                callback(MsgCode.FAILED, `帐号${account_id}已解封!`, "");
                return;
            }
            let mac = rows[0].mac;
            let sql = `DELETE FROM mac_frozen WHERE account_id = '${account_id}';`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED, `帐号${account_id}解禁Mac:SQL错误!`, mac);
                    return;
                }
                callback(MsgCode.SUCCESS, `帐号${account_id}解禁Mac成功!`, mac);
            });
        });
    }

    static getServerListByAccountId(accountid: any, callback: (code: number, rows: any) => void) {
        let sql = `SELECT * FROM qy_role WHERE accountid = ${accountid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }
    // 插入角色
    static insertRole(roleInfo: any, callback: (code: number, roleId: number) => void) {
        let sql = `SELECT * FROM qy_account WHERE accountid = '${roleInfo.accountid}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (rows.length <= 0) {
                callback(MsgCode.FAILED, 0);
                return;
            }
        })
        let roleName = SKDataUtil.checkMYSQL(roleInfo.name);
        sql = `SELECT * FROM qy_role WHERE (accountid = '${roleInfo.accountid}' OR hex(name) = hex('${roleName}')) AND serverid = '${roleInfo.serverid}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, 0);
                return;
            }
            if (rows.length > 0) {
                if (rows[0].name == roleInfo.name) {
                    SKLogger.info(`创建角色:[${roleInfo.accountid}:${roleInfo.name}]已存在`);
                    callback(MsgCode.ROLE_NAME_EXIST, rows[0].roleid);
                    return;
                } else {
                    SKLogger.info(`创建角色:[${roleInfo.accountid}:${rows[0].name}]最多一个角色`);
                    callback(MsgCode.FAILED, rows[0].roleid);
                    return;
                }
            }
            if (rows.length == 0) {
                let titles = `{"onload":false,"titles":[{"type":"0","titleid":"112","value":"","onload":true}]}`;
                sql = `INSERT INTO qy_role(roleid, name, race, sex, level, resid, mapid, x, y, create_time, accountid,serverid,money,taskstate,title,ai_flag) VALUES('${roleInfo.roleId}','${roleInfo.name}', '${roleInfo.race}','${roleInfo.sex}',1,'${roleInfo.resid}',1010,-1,-1, NOW(),'${roleInfo.accountid}','${roleInfo.serverid}',0,'[]','${titles}','${roleInfo.ai_flag}');`;
                DB.query(sql, function (error: any, rows: any) {
                    if (error) {
                        callback(MsgCode.FAILED, 0);
                        return;
                    }
                    if (rows.length < 1) {
                        SKLogger.info(`创建角色:[${roleInfo.accountId}:${roleInfo.name}]不能多于一个!`);
                        callback(MsgCode.FAILED, 0);
                        return;
                    }
                    // 添加签到数据
                    sql = `INSERT INTO dh_day_sign_in(role_id, daySignIn) VALUES('${rows.insertId}', '${roleInfo.daySignIn}');`;
                    DB.query(sql, function (error: any, rows: any) {
                        if (error) {
                            callback(MsgCode.FAILED, 0);
                            return;
                        }
                    });
                    // 添加转盘数据
                    sql = `INSERT INTO dh_dial_role(role_id, dial_num,dial_count,dial_date) VALUES('${rows.insertId}', '${roleInfo.dial_num}', '${roleInfo.dial_count}', '${roleInfo.dial_date}');`;
                    DB.query(sql, function (error: any, rows: any) {
                        if (error) {
                            callback(MsgCode.FAILED, 0);
                            return;
                        }
                    });
                    // 天策符数据
                    sql = `INSERT INTO role_has_ofuda(roleid, ofuda_data) VALUES(${rows.insertId}, '')`
                    DB.query(sql, function (error: any, rows: any) {
                        if (error) {
                            callback(MsgCode.FAILED, 0);
                            return;
                        }
                    });
                    // 点券数据
                    sql = `INSERT INTO qy_currency_role(roleid) VALUES(${rows.insertId})`
                    DB.query(sql, function (error: any, rows: any) {
                        if (error) {
                            callback(MsgCode.FAILED, 0);
                            return;
                        }
                    });
                    callback(MsgCode.SUCCESS, rows.insertId);
                });
            }else {
                callback(MsgCode.FAILED, 0);
                return;
            }
        })
    }
    // 获得坐骑列表
    static getHorseList(roleId: number, callback: (rows: {}) => void) {
        let sql = `SELECT FROM dhxy_horse WHERE roleid=${roleId}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback([]);
                return;
            }
            if (!rows || rows.length < 1) {
                callback([]);
                return;
            }
            let result: any = {};
            for (let item of rows) {
                result[item.mountid] = item;
            }
            callback(result);
        });
    }
    // 改名
    static changeName(info: any, callback: any) {
        let sql = `SELECT * FROM qy_role WHERE hex(name) = hex('${info.name}');`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length > 0) {
                callback(MsgCode.ROLE_NAME_EXIST);
            }
            if (rows.length == 0) {
                sql = `UPDATE qy_role SET name = '${info.name}' WHERE roleid = ${info.roleid};`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    callback(MsgCode.SUCCESS);
                });
            }
        })
    }

    // 宠物改名
    static changePetName(info: any, callback: any) {
        let sql = `UPDATE qy_pet SET name = '${info.name}' WHERE petid = ${info.petId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    // 查询装备ID信息
    static equipKey(callback: any) {
        let sql = `SELECT EquipID FROM qy_equip;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS,rows);
        })
    }
    // 查询角色ID信息
    static roleKey(callback: any) {
        let sql = `SELECT roleid FROM qy_role;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS,rows);
        })
    }

    // 根据装备ID查询装备信息
    static equipInfo(data: any, callback: any) {
        let sql = `SELECT qy_role.name,qy_role.roleid, EquipID, EquipType, BaseAttr, BaseScore, Grade, EIndex, Shuxingxuqiu, Type, GemCnt, LianhuaAttr,qy_equip.name AS EquipName FROM qy_equip LEFT JOIN qy_role ON qy_role.roleid = qy_equip.RoleID WHERE qy_equip.EquipID = '${data.id}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS,rows);
        })
    }

    // 根据宠物ID查询宠物信息
    static petInfo(data: any, callback: any) {
        let sql = `SELECT qy_pet.roleid,qy_role.name,petid,qy_pet.name AS PetName,dataid,qy_pet.relive,qy_pet.level,qy_pet.resid,qy_pet.color,qy_pet.grade,fly,qinmi,shenskill,qy_pet.skill,ppoint,dpoint,rate,hp,mp,atk,spd,wuxing,qy_pet.exp,xexp,xlevel,longgu,qy_pet.control FROM qy_pet LEFT JOIN qy_role ON qy_role.roleid = qy_pet.roleid WHERE qy_pet.petid = ${data.id};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS,rows);
        })
    }

    // 更新最新登录时间
    static updateLastOnlineTime(roleid: any) {
        let sql = `UPDATE qy_role SET lastonline = FROM_UNIXTIME(${Math.ceil(GameUtil.gameTime / 1000)}) WHERE roleid =${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
        })
    }

    // 登录角色
    static loginByRoleid(roleid: any, callback: (code: number, data: any) => void) {
        if (roleid != undefined){
            let sql = `SELECT qy_account.safecode,qy_account.invite,qy_role.* FROM qy_account, qy_role WHERE qy_role.roleid = ${roleid} AND qy_account.accountid = qy_role.accountid;`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    callback(MsgCode.FAILED, null);
                    return;
                }
                if (rows.length > 0) {
                    let data: any = rows[0];
                    if (data != null && data != undefined){
                        if (data.roleid != undefined){
                            sql = `SELECT * FROM qy_equip WHERE RoleID='${data.roleid}' AND state='1';`;
                            sql += `SELECT * FROM dhxy_horse WHERE role_id=${data.roleid};`;
                            sql += `SELECT * FROM dhxy_horse_skill WHERE role_id=${data.roleid};`;
                            sql += `SELECT * FROM qy_pet WHERE roleid = ${roleid} and state = 1 limit ${GameUtil.limitPetNum};`;
                            sql += `SELECT * FROM dh_mail WHERE role_id=${data.roleid} limit ${GameUtil.limitMail};`;
                            sql += `SELECT * FROM dh_day_sign_in WHERE role_id=${data.roleid};`;
                            sql += `SELECT * FROM qy_role WHERE roleid=${data.roleid};`;
                            sql += `SELECT * FROM dh_dial_role WHERE role_id=${data.roleid};`;
                            DB.query(sql, (error: any, rows: any) => {
                                if (error) {
                                    callback(MsgCode.FAILED, null);
                                    return;
                                }
                                data.equipRows = rows[0];
                                data.horseRows = rows[1];
                                data.horseSkillRows = rows[2];
                                data.petRows = rows[3];
                                data.mailRows = rows[4];
                                data.signIn = rows[5];
                                data.role = rows[6];
                                data.dial = rows[7];
                                callback(MsgCode.SUCCESS, data);
                            });
                        }else {
                            callback(MsgCode.FAILED, null);
                        }
                    }else {
                        callback(MsgCode.FAILED, null);
                    }

                } else {
                    callback(MsgCode.FAILED, null);
                }
            });
        }else {
            callback(MsgCode.FAILED, null);
        }

    };

    //获取任务数据
    static getTaskDataByRoleid(roleid: any, callback: any) {
        let sql = `SELECT taskstate FROM qy_role WHERE roleid = ${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length <= 0) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS, rows[0]);
        });
    }

    static getRoleByRoleId(roleid: any, callback: any) {
        let sql = `SELECT * FROM qy_role WHERE roleid = ${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length <= 0) {
                callback(MsgCode.FAILED);
                return;
            }
            let roleinfo = rows[0];
            callback(MsgCode.SUCCESS, roleinfo);
        });
    }
    // 存档
    static savePlayerInfo(roleid: any, roleInfo: any, callback: (code: number, msg: string) => void) {
        let obj: any = {};
        obj.name = roleInfo.name;
        obj.mapid = roleInfo.mapid;
        obj.bangid = roleInfo.bangid;
        obj.x = roleInfo.x;
        obj.y = roleInfo.y;
        obj.addpoint = SKDataUtil.toJson(roleInfo.addpoint, "{}");
        obj.pet = roleInfo.pet;
        obj.bagitem = SKDataUtil.toJson(roleInfo.bagitem, "{}");
        obj.taskstate = SKDataUtil.toJson(roleInfo.taskstate, "{}");
        obj.partnerlist = roleInfo.partnerlist;
        obj.lockeritem = SKDataUtil.toJson(roleInfo.lockeritem, "{}");
        obj.skill = SKDataUtil.toJson(roleInfo.skill, "{}");
        obj.relivelist = SKDataUtil.toJson(roleInfo.relivelist, "[]");
        obj.money = roleInfo.money;
        obj.jade = roleInfo.jade;
        obj.bind_jade = roleInfo.bind_jade;
        obj.bang_score = roleInfo.bang_score;
        obj.shi_score = roleInfo.shi_score;
        obj.di_score = roleInfo.di_score;
        obj.xiu_score = roleInfo.xiu_score;
        obj.guo_score = roleInfo.guo_score;
        obj.exp = roleInfo.exp;
        obj.level = roleInfo.level;
        obj.relive = roleInfo.relive;
        obj.sex = roleInfo.sex;
        obj.resid = roleInfo.resid;
        obj.race = roleInfo.race;
        obj.xiulevel = roleInfo.xiulevel;
        obj.xiupoint = SKDataUtil.toJson(roleInfo.xiupoint, "{}");
        obj.shane = roleInfo.shane;
        obj.state = roleInfo.state;
        obj.level_reward = roleInfo.level_reward;
        obj.rewardrecord = roleInfo.rewardrecord;
        obj.sprewardrecord = roleInfo.sprewardrecord;
        obj.getgift = roleInfo.getgift;
        obj.shuilu = SKDataUtil.toJson(roleInfo.shuilu, "{}");
        obj.arena = SKDataUtil.toJson(roleInfo.arena, "{}");
        obj.color = SKDataUtil.toJson(roleInfo.color, "{}");
        obj.active_scheme_name = roleInfo.active_scheme_name;
        obj.friendlist = SKDataUtil.toJson(roleInfo.friendlist, "{}");
        obj.star = roleInfo.star;
        obj.horse_index = roleInfo.horse_index;
        obj.day_count = SKDataUtil.toJson(roleInfo.day_count, "{}");
        obj.equiplist = null;
        obj.lastonline = `FROM_UNIXTIME(${Math.ceil(GameUtil.gameTime / 1000)})`;
        obj.bag_kind_num = roleInfo.bagKindNum;
        obj.mend_date = roleInfo.mend_date;
        obj.sat_integral = roleInfo.sat_integral;
        obj.offlinetime = roleInfo.offlinetime;
        obj.doublecnt = roleInfo.doublecnt;
        obj.unget_doublecnt = roleInfo.unget_doublecnt;
        obj.zhenfa = roleInfo.zhenfa
        obj.xw = roleInfo.xw
        obj.baby = roleInfo.baby
        obj.star_info = roleInfo.star_info
        obj.tianti_integral = Number(roleInfo.tianti_integral)
        let sql = SKDBUtil.createInsertDuplicatet("qy_role", obj, {
            roleId: roleid,
            accountid: roleInfo.accountid,
            serverid: GameUtil.serverId,
        });
        sql += roleInfo.equipinfo;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "");
        });
    };


    // 存档
    static savePlayerInfoRobot(roleid: any, roleInfo: any, callback: (code: number, msg: string) => void) {
        let obj: any = {};
        obj.name = roleInfo.name;
        obj.mapid = roleInfo.mapid;
        obj.bangid = roleInfo.bangid;
        obj.x = roleInfo.x;
        obj.y = roleInfo.y;
        obj.addpoint = SKDataUtil.toJson(roleInfo.addpoint, "{}");
        obj.pet = roleInfo.pet;
        obj.bagitem = SKDataUtil.toJson(roleInfo.bagitem, "{}");
        obj.taskstate = SKDataUtil.toJson(roleInfo.taskstate, "{}");
        obj.lockeritem = SKDataUtil.toJson(roleInfo.lockeritem, "{}");
        obj.skill = SKDataUtil.toJson(roleInfo.skill, "{}");
        obj.relivelist = SKDataUtil.toJson(roleInfo.relivelist, "[]");
        obj.money = roleInfo.money;
        obj.jade = roleInfo.jade;
        obj.bang_score = roleInfo.bang_score;
        obj.shi_score = roleInfo.shi_score;
        obj.di_score = roleInfo.di_score;
        obj.xiu_score = roleInfo.xiu_score;
        obj.guo_score = roleInfo.guo_score;
        obj.exp = roleInfo.exp;
        obj.level = roleInfo.level;
        obj.relive = roleInfo.relive;
        obj.sex = roleInfo.sex;
        obj.resid = roleInfo.resid;
        obj.race = roleInfo.race;
        obj.xiulevel = roleInfo.xiulevel;
        obj.xiupoint = SKDataUtil.toJson(roleInfo.xiupoint, "{}");
        obj.shane = roleInfo.shane;
        obj.state = roleInfo.state;
        obj.level_reward = roleInfo.level_reward;
        obj.rewardrecord = roleInfo.rewardrecord;
        obj.sprewardrecord = roleInfo.sprewardrecord;
        obj.getgift = roleInfo.getgift;
        obj.shuilu = SKDataUtil.toJson(roleInfo.shuilu, "{}");
        obj.arena = SKDataUtil.toJson(roleInfo.arena, "{}");
        obj.active_scheme_name = roleInfo.active_scheme_name;
        obj.star = roleInfo.star;
        obj.horse_index = roleInfo.horse_index;
        obj.day_count = SKDataUtil.toJson(roleInfo.day_count, "{}");
        obj.equiplist = null;
        obj.lastonline = `FROM_UNIXTIME(${Math.ceil(GameUtil.gameTime / 1000)})`;
        obj.bag_kind_num = roleInfo.bagKindNum;
        obj.mend_date = roleInfo.mend_date;
        obj.sat_integral = roleInfo.sat_integral;
        obj.offlinetime = roleInfo.offlinetime;
        obj.doublecnt = roleInfo.doublecnt;
        obj.unget_doublecnt = roleInfo.unget_doublecnt;
        obj.ai_flag = roleInfo.ai_flag;
        obj.tianti_integral = roleInfo.tianti_integral
        let sql = SKDBUtil.createInsertDuplicatet("qy_role", obj, {
            roleId: roleid,
            accountid: roleInfo.accountid,
            serverid: GameUtil.serverId,
        });
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "");
        });
    };

    static getFriends(roleid: any, callback: (code: number, friendsList: any) => void) { //state=1 已验证的好友  state=0未验证的好友
        var sql = `SELECT * FROM qy_friends WHERE ((roleidA = '${roleid}' OR roleidB = '${roleid}') AND state = 1) OR (roleidB = '${roleid}' AND state = 0);`;
        let friendsList: any = [];
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, friendsList);
                return;
            }
            if (Array.isArray(rows) == false) {
                callback(MsgCode.FAILED, friendsList);
            }
            if (rows.length <= 0) {
                callback(MsgCode.FAILED, friendsList);
            } else {
                for (const info of rows) {
                    if (info.roleidA == roleid) {
                        friendsList.push({
                            friendid: info.id,
                            roleid: info.roleidB,
                            name: info.nameB,
                            resid: info.residB,
                            relive: info.reliveB,
                            level: info.levelB,
                            race: info.raceB,
                            sex: info.sexB,
                            accountid: info.accountidB,
                            state: info.state,
                        });
                    } else if (info.roleidB == roleid) {
                        friendsList.push({
                            friendid: info.id,
                            roleid: info.roleidA,
                            name: info.nameA,
                            resid: info.residA,
                            relive: info.reliveA,
                            level: info.levelA,
                            race: info.raceA,
                            sex: info.sexA,
                            accountid: info.accountidA,
                            state: info.state,
                        });
                    }
                }
                callback(MsgCode.SUCCESS, friendsList);
            }
        });
    }

    static updateFriends(friendid: any, roleid: any, operation: any, callback: any) { //operation 0：删除 1：同意 2：拒绝 3：全部同意 4：全部拒绝
        var sql = `UPDATE qy_friends SET state = '1' WHERE id =${friendid};`;
        if (operation == 0 || operation == 2) {
            sql = `DELETE FROM qy_friends WHERE id =${friendid};`;
        } else if (operation == 3) {
            sql = `UPDATE qy_friends SET state = '1' WHERE roleidB =${roleid};`;
        } else if (operation == 4) {
            sql = `DELETE FROM qy_friends WHERE roleidB = ${roleid} AND state = 0;`;
        }
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, []);
                return;
            }
            DB.getFriends(roleid, callback);
        });
    }

    static searchRoles(info: any, callback: any) {
        let sql = `SELECT serverid, level FROM qy_role WHERE roleid = ${info.roleid}`;
        let playerList: any = [];
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, playerList);
                return;
            }
            if (rows.length <= 0) {
                callback(MsgCode.FAILED, playerList);
            } else {
                let serverid = rows[0].serverid;
                sql = `SELECT * FROM qy_role WHERE serverid = ${serverid} AND roleid != ${info.roleid} AND (name LIKE '%${info.data}%' OR roleid = '${info.data}') AND (SELECT COUNT(1) FROM qy_friends WHERE (qy_friends.roleidA = ${info.roleid} AND qy_friends.roleidB = qy_role.roleid) OR (qy_friends.roleidB = ${info.roleid} AND qy_friends.roleidA = qy_role.roleid)) = 0 ORDER BY RAND() LIMIT 10;`;
                if (info.type == 0) {
                    let maxLevel = rows[0].level + 30;
                    let minLevel = rows[0].level - 30;
                    sql = `SELECT * FROM qy_role WHERE serverid = ${serverid} AND roleid != ${info.roleid} AND level > ${minLevel} AND level < ${maxLevel} AND (SELECT COUNT(1) FROM qy_friends WHERE (qy_friends.roleidA = ${info.roleid} AND qy_friends.roleidB = qy_role.roleid) OR (qy_friends.roleidB = ${info.roleid} AND qy_friends.roleidA = qy_role.roleid)) = 0 ORDER BY RAND() LIMIT 10;`;
                }
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, playerList);
                        return;
                    }

                    if (rows.length <= 0) {
                        callback(MsgCode.FAILED, playerList);
                    } else {
                        for (const info of rows) {
                            playerList.push({
                                roleid: info.roleid,
                                name: info.name,
                                resid: info.resid,
                                level: info.level,
                                relive: info.relive,
                                race: info.race,
                                sex: info.sex,
                            });
                        }
                        callback(MsgCode.SUCCESS, playerList);
                    }
                });
            }
        });
    }

    static addFriends(pinfo: any, callback: any) {
        if (pinfo.roleidA == pinfo.roleidB) {
            callback(MsgCode.FAILED);
            return;
        }
        let sql = `SELECT * FROM qy_friends WHERE (roleidA = '${pinfo.roleidA}' AND roleidB = '${pinfo.roleidB}') OR (roleidA = '${pinfo.roleidB}' AND roleidB = '${pinfo.roleidA}');`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (Array.isArray(rows) == false) {
                callback(MsgCode.FAILED);
            }
            if (rows.length > 0) {
                callback(MsgCode.FAILED);
            } else {
                let roleinfoA: any = {};
                let roleinfoB: any = {};
                DB.getRoleByRoleId(pinfo.roleidA, (ret: any, dbdata: any) => {
                    if (ret == MsgCode.SUCCESS) {
                        roleinfoA = dbdata;
                        DB.getRoleByRoleId(pinfo.roleidB, (ret: any, dbdata: any) => {
                            if (ret == MsgCode.SUCCESS) {
                                roleinfoB = dbdata;
                                let sql = `INSERT INTO qy_friends(roleidA, nameA, residA, reliveA, levelA, raceA, sexA, accountidA, roleidB, nameB, residB, reliveB, levelB, raceB, sexB, accountidB, state, time) VALUES('${roleinfoA.roleid}', '${roleinfoA.name}', '${roleinfoA.resid}', '${roleinfoA.relive}', '${roleinfoA.level}', '${roleinfoA.race}', '${roleinfoA.sex}', '${roleinfoA.accountid}', '${roleinfoB.roleid}', '${roleinfoB.name}', '${roleinfoB.resid}', '${roleinfoB.relive}', '${roleinfoB.level}', '${roleinfoB.race}', '${roleinfoB.sex}', '${roleinfoB.accountid}', 0, NOW());`;
                                DB.query(sql, (error: any, rows: any) => {
                                    if (error) {
                                        callback(MsgCode.FAILED);
                                        return;
                                    }
                                    callback(MsgCode.SUCCESS);
                                });
                            } else {
                                callback(ret);
                            }
                        });
                    } else {
                        callback(ret);
                    }
                });
            }
        });
    }
    // 更新帮派数据
    static updateBang(bangInfo: any, callback: (code: MsgCode) => void) {
        let sql = `UPDATE qy_bang SET rolenum = ${bangInfo.rolenum} WHERE bangid =${bangInfo.bangid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    // 更新帮派数据
    static bangUpdate(bangInfo: any) {
        let sql = `UPDATE qy_bang SET banglevel = ${bangInfo.banglevel}, bangexp = ${bangInfo.bangexp} WHERE bangid =${bangInfo.bangid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static updateBangBidding(bangid: any, bidding: any) {
        let sql = `UPDATE qy_bang SET bidding = ${bidding} WHERE bangid =${bangid};`;
        DB.query(sql, (error: any, rows: any) => { });
    }

    static deleteBang(bangid: any) {
        let sql = `UPDATE qy_bang SET state = 0 WHERE bangid =${bangid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static getBangList(callback: any) {
        let sql = `SELECT * FROM qy_bang WHERE state = 1 and serverid = ${GameUtil.serverId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            // if (rows.length == 0) {//没有帮派信息
            //     callback(MsgCode.FAILED);
            //     return;
            // }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    static getBangRoles(callback: any) {
        let sql = `SELECT qy_role.roleid, qy_role.name, qy_role.resid, qy_role.relive, qy_role.level, qy_role.race, qy_role.sex, qy_role.bangid, qy_bang_member.bang_post, qy_bang_member.join_time, qy_bang_member.week_bang_btl, qy_bang_member.this_bang_btl, qy_bang_member.week_ectype, qy_bang_member.day_task, qy_bang_member.ofuda_level FROM qy_role LEFT JOIN qy_bang_member ON qy_role.roleid = qy_bang_member.roleid WHERE bangid <> 0 AND serverid = ${GameUtil.serverId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            let tlist: any = {};
            for (const info of rows) {
                if (tlist[info.bangid] == null) {
                    tlist[info.bangid] = [];
                }
                tlist[info.bangid].push(info);
            }
            callback(MsgCode.SUCCESS, tlist);
        });
    }

    static selectOfudaLevel(roleid: number, callback: any) {
        let sql = `SELECT ofuda_level FROM qy_bang_member where roleid = ${roleid}`
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
            callback(rows)
        });
    }

    static updateBangMember(member: any,callback: any) {
        let sql = `select * from qy_bang_member where roleid = ${member.roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length > 0) {
                sql = `UPDATE qy_bang_member SET bang_post = '${member.bangpost}',join_time = '${member.jointime}',week_bang_btl = '${member.weekbangbtl}',this_bang_btl = '${member.thisbangbtl}',week_ectype = '${member.weekectype}',day_task = '${member.daytask}' WHERE roleid = '${member.roleid}';`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                });
            } else {
                sql = `INSERT INTO qy_bang_member(roleid,bang_post,join_time,week_bang_btl,this_bang_btl,week_ectype,day_task,ofuda_level)VALUES(${member.roleid},${member.bangpost},NOW(),${member.weekbangbtl},${member.thisbangbtl},${member.weekectype},${member.daytask},${member.ofudalevel});`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    if (rows.length == 0) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                });
            }
        })
    }

    //升级天演策
    static updateBangMemberOfuda(level: number, roleid: any) {
        let sql = `UPDATE qy_bang_member SET ofuda_level = ${level} where roleid = ${roleid}`
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static updateBangPost(memberInfo: any) {
        let sql = `UPDATE qy_bang_member SET bang_post = '${memberInfo.bangpost}' WHERE roleid = '${memberInfo.roleid}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static updatePlayerBangID = function (roleid: any, bangid: any, callback: any) {
        let sql = `UPDATE qy_role SET bangid = ${bangid} WHERE roleid = ${roleid}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
        });
    }

    static createBang(bangInfo: any, callback: any) {
        let sql = `INSERT INTO qy_bang(bangid,name, aim, masterid, mastername, createtime, state, serverid, banglevel, bangexp) 
            VALUES(${bangInfo.bangid},'${bangInfo.name}', '${bangInfo.aim}','${bangInfo.masterid}','${bangInfo.mastername}', NOW(), 1, ${GameUtil.serverId}, '${bangInfo.banglevel}', '${bangInfo.bangexp}');`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS, rows.insertId);
        });
    }

    static updateBangNotice(bangInfo: any, callback: any) {
        let sql = `UPDATE qy_bang SET aim = '${bangInfo.aim}',notice = '${bangInfo.notice}'  WHERE bangid = ${bangInfo.bangid}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static createPet(petInfo: any, callback: any) {
        let sql = `INSERT INTO qy_pet(petid, name, resid, dataid, grade, roleid, rate, hp, mp, atk, spd, wuxing, create_time) VALUES(${petInfo.petid}, '${petInfo.name}', ${petInfo.resid}, ${petInfo.dataid}, ${petInfo.grade}, ${petInfo.ownid}, ${petInfo.rate}, ${petInfo.hp}, ${petInfo.mp}, ${petInfo.atk}, ${petInfo.spd}, '${petInfo.wuxing}', NOW());`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS)
        });
    }
    // 获得召唤兽列表
    static getPetList(roleid: any, callback: (code: number, rows: any[]) => void) {
        let sql = `SELECT * FROM qy_pet WHERE roleid = ${roleid} and state = 1 limit ${GameUtil.limitPetNum}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    // 彻底删除召唤兽
    static removePet(petid: number, roleId: number) {
        let sql = `DELETE FROM qy_pet WHERE petid =${petid} AND roleid=${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }
    // 临时删除召唤兽
    static delPet(petid: number, roleId: number, callback: (code: number) => void) {
        let sql = `UPDATE qy_pet SET state = 0, delete_time = NOW() WHERE petid =${petid} AND roleid=${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }
    // 保存召唤兽列表
    static savePets(petList: Pet[], roleId: number, callback: (code: number, msg: string) => void) {
        if (petList.length < 1) {
            callback(MsgCode.SUCCESS, `存档:召唤兽列表为空无需保存!`);
            return;
        }
        let sql = "";
        for (let pet of petList) {
            sql += SKDBUtil.createUpdate(`qy_pet`, pet.toSaveObj(), ["petid", "roleid"]);
        }
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:召唤兽保存成功!");
        });
    }
    // 保存召唤兽列表1
    static savePetsRedis(petList: Pet[], roleId: number, callback: (code: number, msg: string) => void) {
        if (petList.length < 1) {
            callback(MsgCode.SUCCESS, `存档:召唤兽列表为空无需保存!`);
            return;
        }
        let sql = "";
        for (let pet of petList) {
            sql += SKDBUtil.createUpdate(`qy_pet`, pet, ["petid", "roleid"]);
        }
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:召唤兽保存成功!");
        });
    }

    // 保存角色签到数据
    static saveSignIn(signIn: any, roleId: number, mendDate: any, callback: (code: number, msg: string) => void) {
        let sql = `UPDATE dh_day_sign_in SET daySignIn = '${signIn}', mendDate = '${mendDate}' WHERE role_id = ${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:签到数据保存成功!");
        });
    }

    // 保存角风雨转盘数据
    static saveDial(roleId: number, dial_num: number,dial_count: number,dial_date: any, callback: (code: number, msg: string) => void) {
        let sql = `UPDATE dh_dial_role SET dial_num = '${dial_num}', dial_count = '${dial_count}' , dial_date = '${dial_date}' WHERE role_id = ${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:风雨转盘数据保存成功!");
        });
    }

    // 增加法宝
    static createMagicWeapon(roleid: any, equiparr: any, callback: (code: MsgCode) => void) {
        // 添加法宝数据
        let equipdata = MagicWeaponMgr.shared.getInsertData(equiparr, roleid);
        let sql = `INSERT INTO qy_effective_weapon(${equipdata.fieldstr}) VALUES(${equipdata.valuestr});`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    // 增加装备
    static createEquip(roleid: any, equiparr: any, callback: (code: MsgCode) => void) {
        // 添加装备数据
        let equipdata = EquipMgr.shared.getInsertData(equiparr, roleid);
        let sql = `INSERT INTO qy_equip(${equipdata.fieldstr}) VALUES(${equipdata.valuestr});`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    // 删除装备
    static delEquip(equipid: string, roleId: number, callback: any) {
        let sql = `UPDATE qy_equip SET state = 0, delete_time = NOW() WHERE EquipID ='${equipid}' AND RoleID='${roleId}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    static saveEquipInfo = (equipid: any, roleId: number, savedata: any, callback: any) => {
        let numlist = ['pos', 'Grade', 'Type', 'GemCnt', 'EIndex','BaseScore'];
        let updatestr = '';
        for (const key in savedata) {
            if (numlist.indexOf(key) == -1) {
                updatestr += `${key} = '${savedata[key]}', `
            } else {
                updatestr += `${key} = ${savedata[key]}, `
            }
        }
        updatestr = updatestr.substr(0, updatestr.length - 2);
        let sql = `UPDATE qy_equip SET ${updatestr} WHERE EquipID = '${equipid}' AND RoleID='${roleId}'`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }

    static getPet(roleid: any) {
        let sql = `UPDATE qy_role SET getpet = 1 WHERE roleid =${roleid}`;
        DB.query(sql, (error: any, rows: any) => {
        });
    }

    /*
     * 创建订单
     * @param orderid 订单id
     * @param roleid 角色id
     * @param money 人民币
     * @param jade 仙玉
     * @param count 物品个数
     * @param goodsid 货物id
     * @param activitystates 充值活动的开启状态
     * @param callback 回调
     */
    static createChargeOrder(orderid: any, roleid: any, money: any, jade: any, count: any, goodsid: any, activitystates: any, callback: any) {
        DB.getRoleByRoleId(roleid, (errcode: any, role: any) => {
            if (errcode == MsgCode.SUCCESS) {
                let server_id = role.serverid;
                if (activitystates[server_id] && activitystates[server_id].state == 1) { // 双倍活动
                    jade *= 2;
                }
                let sql = `insert into charge_record (orderid, roleid, money, jade, goodscount, goodsid, create_time, serverid) values ('${orderid}', ${roleid}, ${money}, ${jade}, ${count}, ${goodsid}, NOW(), ${server_id});`;
                DB.query(sql, (error: any, packet: any) => {
                    if (error) {
                        callback(false);
                        return;
                    }
                    callback(true);
                });
            } else
                callback(false);
        });
    };

    /*
     * 是否能完成订单
     * @param orderid 订单号
     */
    static canFinishOrder(sdorderno: string, sdpayno: string, money: string, callback: (code: MsgCode, money: number) => void) {
        let sql = `SELECT * FROM charge_record WHERE orderid='${sdorderno}' AND status=0;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            if (rows.length == 0) {
                SKLogger.warn(`支付:未查询到有效订单[${sdorderno}:${sdpayno}]!`);
                callback(MsgCode.FAILED, null);
            } else {
                let row = rows[0];
                if (SKDataUtil.numberBy(row.money) != SKDataUtil.numberBy(money)) {
                    SKLogger.warn(`支付:订单[${sdorderno}:${sdpayno}]金额不匹配:${row.money}!=${money}!`);
                    callback(MsgCode.FAILED, row);
                    return;
                }
                callback(MsgCode.SUCCESS, row);
            }
        });
    };

    static setOrderFinish(sdorderno: string, sdpayno: string, total_fee: string, callback: (success: boolean) => void) {
        let sql = `UPDATE charge_record SET finish_time = NOW(),realmoney =${total_fee},status=1,sdpayno='${sdpayno}' WHERE orderid = '${sdorderno}';`;
        DB.query(sql, (error: any, packet: any) => {
            if (error) {
                SKLogger.warn(`订单${sdorderno}设置完成状态时失败！`);
                callback(false);
                return;
            }
            if (packet.affectedRows == 0) {
                SKLogger.warn(`订单${sdorderno}设置完成状态时失败！`);
                callback(false);
            } else {
                SKLogger.info(`订单${sdorderno}成功设置完成状态！`);
                callback(true);
            }
        });
    };

    static setNotice(text: any) {
        let sql = `UPDATE qy_info SET comment = '${text}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static setShuilu(sid: any, lid: any) {
        let sql = `UPDATE qy_info SET shuilusid = ${sid}, shuilulid = ${lid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    // 游戏内通知
    static getScrollNotice(serverid: number, limit: number, callback: any) {
        let sql = `SELECT text, type FROM qy_notice WHERE serverid = ${serverid} OR serverid = 0 ORDER BY time DESC LIMIT ${limit};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(false);
                return;
            }
            callback(true, rows);
        });
    };

    static addScrollNotice(serverid: any, type: any, text: any, callback?: (success: boolean) => void) {
        let sql = `insert into qy_notice (text, type, serverid, time) values ('${text}', ${type}, ${serverid}, NOW());`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                if (callback) {
                    callback(false);
                }
                return;
            }
            if (callback) {
                callback(true);
            }
        });
    };
    /*
     * 关系（结拜，夫妻等）
     */

    static createRelation(sqlData: any, callback: any) {
        let sql = `insert into qy_relation (relationId,members, relationType, relationName, createTime,status) values (${sqlData.relationId},'${sqlData.members}', ${sqlData.relationType},'${sqlData.relationName}',  NOW(),${sqlData.status});`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length == 0) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS, rows.insertId);
        });
    };

    static queryAllRelations(callback: any) {
        let sql = `SELECT * FROM qy_relation WHERE status = 0`;
        DB.query(sql, function (error: any, rows: any) {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    static deleteRelationById(sqlData: any, callback: any) {// status 0 正常 -1 已删除
        //var sql = `DELETE FROM qy_relation WHERE relationId =${relationId};`;
        var sql = `select * from qy_relation where relationId = ${sqlData.relationId}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length > 0) {
                sql = `update qy_relation set status = -1,deleteTime = NOW() where relationId = ${sqlData.relationId};`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, []);
                        return;
                    }
                    callback(MsgCode.SUCCESS, []);
                });

            } else {
                sql = `insert into qy_relation (relationId, members, relationType, relationName, createTime,status,deleteTime) values (${sqlData.relationId},'${sqlData.members}', ${sqlData.relationType},'${sqlData.relationName}',  NOW(),${sqlData.status}, NOW());`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    if (rows.length == 0) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    callback(MsgCode.SUCCESS, rows.insertId);
                });
            }
        });
    }

    static updateRelationMembersById(info: any, callback: any) {
        var sql = `select * from qy_relation where relationId = ${info.relationId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length > 0) {
                sql = `UPDATE qy_relation SET members = '${info.members}' WHERE relationId = ${info.relationId};`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    callback(MsgCode.SUCCESS);
                });
            } else {
                sql = `INSERT INTO qy_relation (relationId, members, relationType, relationName, createTime,status) VALUES (${info.relationId},'${info.members}', ${info.relationType},'${info.relationName}',  NOW(),${info.status});`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    if (rows.length == 0) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                    callback(MsgCode.SUCCESS, rows.insertId);
                });
            }
        })
    }

    static getRelationById(id: any, callback: any) {
        let sql = `SELECT * FROM qy_relation WHERE relationId = ${id}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(false);
                return;
            }
            callback(true, rows);
        });
    }

    static getRelationMaxId(callback?: any) {
        let sql = `SELECT max(relationId) AS relationId FROM qy_relation;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                if (callback) {
                    callback(MsgCode.FAILED);
                }
                return;
            }
            if (callback) {
                callback(MsgCode.SUCCESS, rows[0].relationId);
            }
        });
    }

    static getSchemesByRoleId(roleId: any, callback: (code: MsgCode, rows: any) => void) {
        let sql = `SELECT * FROM qy_scheme WHERE roleId = ${roleId}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }
    // 更新套装
    static saveScheme(data: { [key: number]: Scheme }, callback: (code: number, msg: string) => void) {
        let sql: string = "";
        for (let key in data) {
            let item: Scheme = data[key];
            let obj: any = item.toObj();
            if (obj.roleId && obj.schemeId &&obj.schemeName && obj.content && obj.status != undefined){
                sql += `INSERT INTO qy_scheme(roleId,schemeId,schemeName,content,status) VALUES('${obj.roleId}','${obj.schemeId}','${obj.schemeName}','${obj.content}','${obj.status}') ON DUPLICATE KEY UPDATE schemeName='${obj.schemeName}',content='${obj.content}',status='${obj.status}';`
            }

        }

        if (sql.length < 1) {
            callback(MsgCode.SUCCESS, "存档:套装无需存档");
            return;
        }
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:套装全部存档成功!");
        });
    }
    // 更新套装2
    static saveSchemeRedis(data: { [key: number]: Scheme }, callback: (code: number, msg: string) => void) {
        let sql: string = "";
        for (let key in data) {
            let item: Scheme = data[key];
            let obj: any = item;
            sql += `INSERT INTO qy_scheme(roleId,schemeId,schemeName,content,status) VALUES('${obj.roleId}','${obj.schemeId}','${obj.schemeName}','${obj.content}','${obj.status}') ON DUPLICATE KEY UPDATE schemeName='${obj.schemeName}',content='${obj.content}',status='${obj.status}';`
        }
        if (sql.length < 1) {
            callback(MsgCode.SUCCESS, "存档:套装无需存档");
            return;
        }
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                let info = DB.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "存档:套装全部存档成功!");
        });
    }
    // 设置安全码
    static setSafecode(accountid: any, safecode: any, callback: any) {
        let sql = `update qy_account set safecode = '${safecode}' where accountid = ${accountid};`;
        DB.query(sql, (error: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        });
    }
    // 获得角色所在服务器索引
    static serverIdBy(roleId: number, callback: (serverId: number) => void) {
        let sql = `SELECT serverid FROM qy_role WHERE roleid='${roleId}';`;
        DB.query(sql, (error: Error, rows: any) => {
            if (error) {
                callback(-1);
                return;
            }
            if (rows.length < 1) {
                callback(-1);
            }
            let serverId = 1000;
            let temp = rows[0].serverid;
            if (temp) {
                serverId = parseInt(temp);
            }
            callback(serverId);
        });
    }
    // 获得公告
    static getComment(serverId: number, callback: (code: number, data: any) => void) {
        let sql = `SELECT * FROM dhxy_comment WHERE server_id=${serverId}`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            if (rows.length < 1) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows[0]);
        })
    }
    // 设置公告
    static setComment(serverId: number, text: string, callback: (code: number) => void) {
        let data={
            text:text,
        };
        let sql=SKDBUtil.createInsertDuplicatet("dhxy_comment",data,{
            server_id:serverId
        });
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS);
        })
    }
    // 加仙玉
    static addJade(roleId: number, jade: number, callback: Function) {
        let sql = `UPDATE qy_role SET jade=jade+${jade} WHERE roleId=${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
            } else {
                callback(MsgCode.SUCCESS);
            }
        })
    }
    // 加经验
    static addExp(roleId: number, exp: number, callback: (ret: any) => void) {
        let sql = `UPDATE qy_role SET exp=exp+${exp} WHERE roleId=${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
            } else {
                callback(MsgCode.SUCCESS);
            }
        })
    }

    // 获得角色数据
    static roleDataBy(roleId: any, callback: (code: number, data: any) => void) {
        let sql = `SELECT qy_account.safecode,qy_role.* FROM qy_account,qy_role WHERE qy_role.roleid = ${roleId} and qy_account.accountid = qy_role.accountid;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            if (rows.length > 0) {
                let role: any = rows[0];
                role.equipdata = {};
                sql = `SELECT * FROM qy_equip WHERE RoleID = ${role.roleid} AND state != 0;`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, role);
                        return;
                    }
                    for (let info of rows) {
                        role.equipdata[info.EquipID] = info;
                    }
                    callback(MsgCode.SUCCESS, role);
                });
            } else {
                callback(MsgCode.FAILED, null);
            }
        });
    };

    static agentCharge(orderid: any, roleid: any, money: any, jade: any, count: number, goodsid: number, activitystates: any, callback: (code: number, msg: string, serverId: any) => void) {
        DB.getRoleByRoleId(roleid, (code: any, role: any, serverId: any) => {
            if (code == MsgCode.SUCCESS) {
                let server_id = role.serverid;
                if (activitystates[server_id] && activitystates[server_id].state == 1) { // 双倍活动
                    jade *= 2;
                }
                let sql = `INSERT INTO charge_record (orderid,roleid,realmoney,jade,goodscount,goodsid,serverid,create_time,finish_time,status) VALUES ('${orderid}',${roleid}, ${money}, ${jade},${count},${goodsid},${server_id},NOW(),NOW(),1);`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, `代理充值失败,角色索引:${roleid},订单名:${orderid},钱数:${money},仙玉:${jade}`, server_id);
                        return;
                    }
                    callback(MsgCode.SUCCESS, `代理充值成功,角色索引:${roleid},订单名:${orderid},钱数:${money},仙玉:${jade}`, server_id);
                });
            }
        });
    };
    // 加入称谓
    static addTitle(role_id: number, type: number, title_id: number, callback: (code: number, msg: string) => void) {
        let sql = `SELECT title FROM qy_role WHERE roleid='${role_id}'`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `称谓保存失败,角色索引:${role_id},${type},${title_id}`);
                return;
            }
            let temp = rows[0].title;
            let data: any = SKDataUtil.jsonBy(temp);
            if (data) {
                for (let item of data.titles) {
                    if (item.type == type && item.title_id == title_id) {
                        callback(MsgCode.FAILED, `称谓已存在,角色索引:${role_id},${type},${title_id}`);
                        return;
                    }
                }
                let title = { "type": type, "titleid": title_id, "value": "", "onload": false };
                data.titles.push(title);
                let save = SKDataUtil.toJson(data, "{}");
                this.saveTitle(role_id, save, callback);
            }
        });
    }
    // 保存称谓
    static saveTitle(role_id: number, titles: string, callback: (code: number, msg: string) => void) {
        let sql = `UPDATE qy_role SET title = '${titles}' WHERE roleid = ${role_id};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `称谓保存失败,角色索引:${role_id},${titles}`);
                return;
            }
            callback(MsgCode.FAILED, `称谓保存成功,角色索引:${role_id},${titles}`);
        });
    }
    //获得已兑换的列表
    static getExchange(roleId: number, callback: (list: string[]) => void) {
        let sql = `SELECT * FROM qy_exchange WHERE roleid = ${roleId};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback([]);
                return;
            }
            if (!rows || rows.length < 1) {
                callback([]);
                return;
            }
            let result = [];
            for (let item of rows) {
                result.push(item.code);
            }
            callback(result);
        });
    }
    // 保存已兑换
    static saveExchange(roleId: number, code: string, callback: (code: number, msg: string) => void) {
        let sql = `INSERT INTO qy_exchange(roleid,code) VALUES('${roleId}','${code}');`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(1, `玩家${roleId}保存兑换码[${code}]失败:${error}!`);
                return;
            }
            callback(0, `玩家${roleId}保存兑换码[${code}]成功!`);
        });
    }
    // 获得坐骑技能
    static getHorseSkill(roleId: number, callback: (code: number, rows: any) => void) {
        let sql = `SELECT * FROM dhxy_horse_skill WHERE role_id='${roleId}' ORDER BY position;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }
    // 保存坐骑列表
    static saveHorseList(roleId: number, dict: { [key: number]: Horse }, callback: (error: any, rows: any[]) => void) {
        let sql = ``;
        for (let position in dict) {
            let horse = dict[position];
            if (horse) {
                let name = horse.name;
                let level = horse.level;
                let exp = horse.exp;
                sql += `INSERT INTO dhxy_horse(role_id,position,name,level,exp) VALUES('${roleId}','${position}','${name}','${level}','${exp}') ON DUPLICATE KEY UPDATE name='${name}',level='${level}',exp='${exp}';`
            }
        }
        if (sql.length < 1) {
            return;
        }
        DB.query(sql, callback);
    }
    // 保存坐骑技能列表
    static saveHorseSkillList(roleId: number, dict: { [key: number]: SkillBase }, callback: (error: any, rows: any[]) => void) {
        let sql = ``;
        for (let position in dict) {
            let skill = dict[position];
            if (skill) {
                let skillId = skill.skill_id;
                let exp = skill.exp;
                sql += `INSERT INTO dhxy_horse_skill(role_id,position,skill_id,exp) VALUES(${roleId},${position},${skillId},${exp}) ON DUPLICATE KEY UPDATE skill_id=${skillId},exp=${exp};`
            }
        }
        if (sql.length < 1) {
            callback(null, null);
            return;
        }
        DB.query(sql, callback);
    }
    // 读取系统邮件
    static getSystemMail(serverId: number, callback: (error: any, rows: any[]) => void) {
        let sql = `SELECT * FROM dh_system_mail WHERE server_id='${serverId}'`;
        DB.query(sql, callback);
    }
    // 系统邮件存档
    static saveSystemMail(mail: MailData, callback: (code: MsgCode, msg: string) => void) {
        let obj = mail.toSystemMailDB();
        let sql: string = SKDBUtil.createInsertDuplicatet("dh_system_mail", obj, {
            mail_id: mail.mail_id
        });
        DB.query(sql, (error: any, rows: []) => {
            if (error) {
                let info = this.errorInfo(error);
                SKLogger.debug(`系统邮件:[${obj.mail_id}:${obj.title}]存档失败[${info}]`);
                callback(MsgCode.FAILED, info);
                return;
            }
            let info = `系统邮件:[${mail.mail_id}:${mail.title}]存档成功`;
            SKLogger.debug(info);
            callback(MsgCode.SUCCESS, info);
        });
    }
    // 玩家邮件存档
    static saveRoleMail(roleId: number, list: MailData[], callback: (code: MsgCode, msg: string) => void) {
        let sql = "";
        for (let mail of list) {
            let obj = mail.toRoleMailDB();
            obj.role_id = roleId;
            sql += SKDBUtil.createInsertDuplicatet("dh_mail", obj, {
                mail_id: mail.mail_id
            });
        }
        DB.query(sql, (error: any, rows: []) => {
            if (error) {
                let info = this.errorInfo(error);
                callback(MsgCode.FAILED, info);
                return;
            }
            callback(MsgCode.SUCCESS, "");
        });
    }
    // 读机器人数据
    static readRobots(total: number, callback: (rows: any) => void) {
        let sql = `SELECT * FROM qy_role WHERE ai_flag = 1 LIMIT ${total};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
            callback(rows);
        });
    }


    // 检查注册码
    static isCodeEnable(inviteCode: string, callback: (code: number, msg: string) => void) {
        let sql = `SELECT * FROM agency_admin_user WHERE status = 1 and invite ='${inviteCode}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `无效注册码${inviteCode}失败!`);
                return;
            }else {
                if (rows.length == 0){
                    callback(MsgCode.FAILED, `无效注册码${inviteCode}失败!`);
                    return;
                }
                callback(MsgCode.SUCCESS, `注册码${inviteCode}成功`);
            }

        });
    };

    // 多宝阁数据
    static selectShopData(callback: (code: number, data: any) => void) {
        let sql = '';
        let data: any = {};
        sql = `SELECT id, itemid, price, discount FROM prop_fresh;`;
        sql += `SELECT id, itemid, price, discount FROM prop_mall;`;
        sql += `SELECT id, itemid, price, time, discount FROM prop_day_limit;`;
        sql += `SELECT id, itemid, price, time, discount FROM prop_recommend;`;
        sql += `SELECT id, itemid, price, item_kind FROM prop_integral;`;
        sql += `SELECT id, itemid, price, discount  FROM prop_bind_jade;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            data.propFresh = rows[0];
            data.propMall = rows[1];
            data.propDayLimit = rows[2];
            data.propRecommend = rows[3];
            data.propIntegral = rows[4];
            data.propBindJade = rows[5];
            callback(MsgCode.SUCCESS, data);
        });
    };

    // 碎片商城数据
    static selectDebrisData(callback: (code: number, data: any) => void) {
        let sql = `SELECT name, serial, price, num, type FROM prop_debris;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 甄不亏数据
    static selectZbkData(callback: (code: number, data: any) => void) {
        let sql = `SELECT id, itemid, itemname, kind, weight, min_price, max_price, type, min_quantity, max_quantity FROM prop_zhenbukui_shop;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    static selectReport(callback: any){
        let sql = `SELECT sroleid, eresid, eroleid, erolename, iswin, ranking, cdate FROM qy_report`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    // 藏宝图数据
    static selectLotteryData(callback: (code: number, data: any) => void) {
        let sql = `SELECT id, item, name, num, rate FROM prop_lottery;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 山河社稷图图数据
    static selectLotterySuperData(callback: (code: number, data: any) => void) {
        let sql = `SELECT id, item, name, num, rate FROM prop_lottery_super;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 幸运转盘数据
    static selectDialData(callback: (code: number, data: any) => void) {
        let sql = `SELECT item_id, item_name, type, num, flag, rate FROM dh_dial;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 检查兑换码
    static checkCod(code: any, callback: any) {
        let sql = `SELECT code, reward, start, end FROM qy_convert WHERE code = '${code}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            callback(MsgCode.SUCCESS,rows);
        })
    }
    //使用变身卡数据
    static selectUseCard(callback: any){
        let sql = `SELECT roleid, resid, card_id, usetime, endtime, gain, five_phases FROM use_change_card`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    //修改角色特效数据
    static insertSeffect(effectid: any, roleid: any, usestate: any, effecttype: any, callback: any){
        let sql = `select * from role_has_seffect where roleid = ${roleid} and effectid = ${effectid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED);
                return;
            }
            if (rows.length > 0) {
                sql = `UPDATE role_has_seffect SET use_state = ${usestate} WHERE roleid = ${roleid} and effectid = ${effectid} and effecttype = ${effecttype};`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED);
                        return;
                    }
                });
            } else {
                let sql = `INSERT INTO role_has_seffect (roleid, effectid, effecttype, use_state) values(${roleid},${effectid},${effecttype},0)`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        return;
                    }
                });
            }
        })
    }

    //所有玩家的特效
    static selectSeffect(callback: any){
        let sql = `SELECT * FROM role_has_seffect`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    }

    //添加五行数据
    static  insertFivePhasesById(roleid: any){
        let sql = `INSERT INTO qy_five_phases (roleid) values(${roleid})`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    //修改五行数据
    static  updateFivePhasesById(info: any, roleid: any){
        let sql = `UPDATE qy_five_phases SET five_phases_level = ${info.fplevel},jin_level = ${info.jinlevel},jin_exp = ${info.jinexp},mu_level = ${info.mulevel},mu_exp = ${info.muexp},shui_level = ${info.shuilevel},shui_exp = ${info.shuiexp},huo_level = ${info.huolevel},huo_exp = ${info.huoexp},tu_level = ${info.tulevel},tu_exp = ${info.muexp},use_count = ${info.count} WHERE roleid = ${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    //添加支援宠物
    static  insertSupportPet(info: any, callback: any){
        let sql = `INSERT INTO qy_pet_support (roleid,petid,petname,resid,sorder) values(${info.roleid},${info.petid},'${info.petname}',${info.resid},${info.sorder})`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    //添加天策符
    static  insertOfuda(roleid: number, ofudainfo: any){
        let insql = `UPDATE role_has_ofuda SET ofuda_data = '${ofudainfo}'  WHERE roleid = ${roleid};`;
        DB.query(insql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    //删除支援宠物
    static deleteSupportPet(roleid: number, petid: number) {
        let sql = `DELETE FROM qy_pet_support WHERE roleid= ${roleid} AND petid = ${petid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    // 删除支援宠物后修改宠物支援顺序
    static updateSupportPetSorder(info: any, callback: any) {
        let sql = `UPDATE qy_pet_support SET sorder = '${info.sorder}' WHERE roleid = ${info.roleid} and petid = ${info.petid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `修改宠物支援顺序失败${info.petid}:${info.sorder}`);
                return;
            }
        });
    }

    // 修改双倍点数
    static updateDoublePoint(info: any) {
        let sql = `UPDATE qy_role SET doublecnt = '${info.doublecnt}',unget_doublecnt = '${info.unget_doublecnt}' WHERE roleid = ${info.roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    }

    static updateMoney(info: any) {
        let sql = `UPDATE qy_role SET bind_jade = '${info.bind_jade}',bang_score = '${info.bangscore}',shi_score = '${info.shiscore}',di_score = '${info.discore}',xiu_score = '${info.xiuscore}',guo_score = '${info.guoscore}' WHERE roleid = ${info.roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    }


    // 帮战记录
    static insertCutFaction(one: any, one_site: any, two: any, two_site: any) {
        let sql = `insert into cut_faction(side_id, enemy_id, create_time, site) values('${one}',${two},NOW(),'${one_site}');`;
        sql += `insert into cut_faction(side_id, enemy_id, create_time, site) values('${two}','${one}',NOW(),'${two_site}');`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    }

    // 重启服务器读取当前入围帮战资格数据
    static getCutFaction(callback: (code: number, data: any) => void) {
        let sql = `SELECT side_id, enemy_id, site FROM cut_faction where create_time = date_format(NOW(),'%y%m%d');`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 游戏配置
    static selectConfiguration(key: any,callback: any) {
        let sql = `SELECT value_data FROM game_configuration where key_data = '${key}';`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows[0]);
        });
    };

    // 更改游戏配置
    static updateConfiguration(key: any, data: any) {
        let sql = `UPDATE game_configuration SET value_data = '${data}' WHERE key_data = '${key}';`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    };

    // 更改游戏配置
    static updateCurrencyRole(roleid: any, money: any) {
        let sql = `UPDATE qy_currency_role SET money = ${money} WHERE roleid = ${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    };

    // 读取玩家点券数据
    static selectCurrencyRole(callback: any) {
        let sql = `SELECT roleid,money FROM qy_currency_role;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 添加申请提款
    static insertCurrencyWithdraw(data: any, money: any) {
        let sql = `INSERT INTO qy_currency_withdraw (serial,roleid,alipay,name,money, req_time) values(${data.serial},${data.roleid},'${data.alipay}','${data.name}',${data.money},'${data.req_time}')`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
            sql = `update qy_currency_role set money =${money}  where roleid = ${data.roleid};`;
            DB.query(sql, (error: any, rows: any) => {
                if (error) {
                    return;
                }
            });
            return;
        });
    };

    // 查询申请提款
    static selectCurrencyWithdraw(callback: (code: number, data: any) => void) {
        let sql = `SELECT * FROM qy_currency_withdraw;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
            return;
        });
    };

    // 白名单数据
    static selectInterface(callback: (code: number, data: any) => void) {
        let sql = `SELECT map_interface FROM dhxy_whitelist_interface;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    // 结婚数据
    static selectMarry(callback: (code: number, data: any) => void) {
        let sql = `SELECT * FROM qy_marry;`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, null);
                return;
            }
            callback(MsgCode.SUCCESS, rows);
        });
    };

    
    /**天梯数据  写入数据库 */
    static tiantidata(player: any, score: number, baichang: number, shengchang: number, effid: number, callback: (code: number, msg: string) => void) {
        var sql = `SELECT * FROM qy_tianti WHERE roleid = "${player.roleid}";`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                callback(MsgCode.FAILED, `天梯数据:SQL错误,请稍候重试!`);
                return;
            }
            if (rows.length > 0) {
                callback(MsgCode.FAILED, `天梯数据,已经存在，请更新!`);
                sql = `UPDATE qy_tianti SET jifen = ${score} , baichang = ${baichang}, shengchang = ${shengchang}, wingId = ${player.wingId}, effid = ${effid}  WHERE roleid = ${player.roleid};`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, `天梯数据更新失败,请稍候重试!`);
                        return;
                    }
                    callback(MsgCode.SUCCESS, `天梯数据更新成功!`);
                });

                return;
            } else {
                sql = `insert into qy_tianti (roleid, resid, jifen, name, baichang,shengchang,wingId,effid) values (${player.roleid},${player.resid}, ${player.tianti_integral},'${player.name}',${baichang},${shengchang},${player.wingId},${effid});`;
                DB.query(sql, (error: any, rows: any) => {
                    if (error) {
                        callback(MsgCode.FAILED, `天梯数据:插入失败,请稍候重试!`);
                        return;
                    }
                    callback(MsgCode.SUCCESS, `天梯数据成功!`);
                });
            }
        });
    }

    static insertMarry(roleid_a: any, rolename_a: any, roleid_b: any, rolename_b: any) {
        let sql = `insert into qy_marry(roleid_a, rolename_a, roleid_b, rolename_b) values(${roleid_a}, '${rolename_a}', ${roleid_b}, '${rolename_b}');`;
        DB.query(sql, (error: any, rows: any) => {
            return;
        });
    }

    static deleteMarry(roleid: any) {
        let sql = `DELETE FROM qy_marry WHERE roleid_a = ${roleid};`;
        DB.query(sql, (error: any, rows: any) => {
            if (error) {
                return;
            }
        });
    }

    static errorInfo(error: any): string {
        if (error.sqlMessage) {
            return error.sqlMessage;
        }
        if (error.message) {
            return error.message;
        }
        if (error.code) {
            return error.code;
        }
        return "未知";
    }
}