示例#1
0
    public override OpRes makeQuery(object param, GMUser user, QueryCondition queryCond)
    {
        ParamQuery p = (ParamQuery)param;

        if (string.IsNullOrEmpty(p.m_time))
        {
            return(OpRes.op_res_time_format_error);
        }

        DateTime mint = DateTime.Now, maxt = DateTime.Now;
        bool     res = Tool.splitTimeStr(p.m_time, ref mint, ref maxt);

        if (!res)
        {
            return(OpRes.op_res_time_format_error);
        }

        if (queryCond.isExport())
        {
            queryCond.addCond("time", p.m_time);
        }
        else
        {
            IMongoQuery imq1 = Query.LT("genTime", BsonValue.Create(maxt));
            IMongoQuery imq2 = Query.GTE("genTime", BsonValue.Create(mint));
            queryCond.addImq(Query.And(imq1, imq2));

            IMongoQuery imq3 = Query.GT("rechargeCount", 0);
            queryCond.addImq(imq3);
        }
        return(OpRes.opres_success);
    }
    public override OpRes makeQuery(object param, GMUser user, QueryCondition imq)
    {
        ParamScoreOpRecord p = (ParamScoreOpRecord)param;

        string cond = "";
        OpRes  res  = getQueryCond(p, user, ref cond, imq);

        if (res == OpRes.opres_success)
        {
            imq.addCond("cond", cond);
            if (imq.isExport())
            {
                imq.addCond("moneyBase", DefCC.MONEY_BASE);
            }
        }

        return(res);
    }
示例#3
0
    public override OpRes makeQuery(object param, GMUser user, QueryCondition queryCond)
    {
        ParamIncomeExpenses p = (ParamIncomeExpenses)param;

        if (string.IsNullOrEmpty(p.m_time))
        {
            return(OpRes.op_res_time_format_error);
        }

        DateTime mint = DateTime.Now, maxt = DateTime.Now;
        bool     res = Tool.splitTimeStr(p.m_time, ref mint, ref maxt);

        if (!res)
        {
            return(OpRes.op_res_time_format_error);
        }

        if (queryCond.isExport())
        {
            queryCond.addCond("time", p.m_time);
        }
        else
        {
            IMongoQuery imq1 = Query.LT("genTime", BsonValue.Create(maxt));
            IMongoQuery imq2 = Query.GTE("genTime", BsonValue.Create(mint));
            queryCond.addImq(Query.And(imq1, imq2));

            if (p.m_playerGainDb == 1)
            {
                queryCond.addImq(Query.EQ("isDropDb", true));
            }
            else if (p.m_playerGainDb == 2)
            {
                queryCond.addImq(Query.EQ("isDropDb", false));
            }
        }
        return(OpRes.opres_success);
    }
    public override OpRes makeQuery(object param, GMUser user, QueryCondition queryCond)
    {
        ParamQueryRecharge p = (ParamQueryRecharge)param;

        int          condCount = 0;
        PlatformInfo pinfo     = null;

        if (!string.IsNullOrEmpty(p.m_param))
        {
            switch (p.m_way)
            {
            case QueryWay.by_way0:     //  通过玩家id查询
            {
                int val = -1;
                if (!int.TryParse(p.m_param, out val))
                {
                    return(OpRes.op_res_param_not_valid);
                }
                Dictionary <string, object> ret = QueryBase.getPlayerProperty(val, user, s_field);
                if (ret == null)
                {
                    return(OpRes.op_res_not_found_data);
                }
                if (!ret.ContainsKey("platform"))
                {
                    return(OpRes.op_res_failed);
                }

                // 取玩家ID所在平台
                string platName = Convert.ToString(ret["platform"]);
                queryCond.addQueryCond("PlayerId", val);

                pinfo = ResMgr.getInstance().getPlatformInfoByName(platName);

                // 获取服务器ID

                /*DbServerInfo dbInfo = ResMgr.getInstance().getDbInfo(user.m_dbIP);
                 * if (dbInfo != null)
                 * {
                 *  queryCond.addQueryCond("ServerId", dbInfo.m_serverId);
                 * }*/
            }
            break;

            case QueryWay.by_way1:     //  通过账号查询
            {
                Dictionary <string, object> ret = QueryBase.getPlayerPropertyByAcc(p.m_param, user, s_field);
                if (ret == null)
                {
                    return(OpRes.op_res_not_found_data);
                }
                if (!ret.ContainsKey("platform"))
                {
                    return(OpRes.op_res_failed);
                }

                // 取玩家账号所在平台,然后从相应的平台去查
                string platName = Convert.ToString(ret["platform"]);
                queryCond.addQueryCond("Account", p.m_param);

                pinfo = ResMgr.getInstance().getPlatformInfoByName(platName);

                // 获取服务器ID

                /* DbServerInfo dbInfo = ResMgr.getInstance().getDbInfo(user.m_dbIP);
                 * if (dbInfo != null)
                 * {
                 *   queryCond.addQueryCond("ServerId", dbInfo.m_serverId);
                 * }*/
            }
            break;

            case QueryWay.by_way2:     //  通过订单号查询
            {
                pinfo = ResMgr.getInstance().getPlatformInfo(p.m_platIndex);
                queryCond.addQueryCond("OrderID", p.m_param);
            }
            break;

            default:
            {
                return(OpRes.op_res_failed);
            }
            }
            condCount++;
        }
        else
        {
            pinfo = ResMgr.getInstance().getPlatformInfo(p.m_platIndex);

            // 获取服务器ID

            /*DbServerInfo dbInfo = ResMgr.getInstance().getDbInfo(user.m_dbIP);
             * if (dbInfo != null)
             * {
             *  queryCond.addQueryCond("ServerId", dbInfo.m_serverId);
             * }*/
        }

        if (pinfo == null)
        {
            return(OpRes.op_res_need_sel_platform);
        }

        if (!m_items.ContainsKey(pinfo.m_engName))
        {
            return(OpRes.op_res_not_found_data);
        }

        m_rbase = m_items[pinfo.m_engName];

        m_platInfo.m_tableName = pinfo.m_tableName;
        m_platInfo.m_platName  = pinfo.m_engName;

        if (queryCond.isExport())
        {
            queryCond.addCond("table", m_platInfo.m_tableName);
            queryCond.addCond("plat", m_platInfo.m_platName);
        }

        if (p.m_time != "")
        {
            DateTime mint = DateTime.Now, maxt = DateTime.Now;
            bool     res = Tool.splitTimeStr(p.m_time, ref mint, ref maxt);
            if (!res)
            {
                return(OpRes.op_res_time_format_error);
            }

            condCount++;
            if (queryCond.isExport())
            {
                queryCond.addCond("time", p.m_time);
            }
            else
            {
                IMongoQuery imq1 = Query.LT("PayTime", BsonValue.Create(maxt));
                IMongoQuery imq2 = Query.GTE("PayTime", BsonValue.Create(mint));
                queryCond.addImq(Query.And(imq1, imq2));
            }
        }

        if (p.m_result > 0)
        {
            queryCond.addQueryCond("Process", p.m_result == 1 ? true : false);
        }
        if (!string.IsNullOrEmpty(p.m_range))
        {
            if (!Tool.isTwoNumValid(p.m_range))
            {
                return(OpRes.op_res_param_not_valid);
            }

            if (queryCond.isExport())
            {
                queryCond.addCond("range", p.m_range);
            }
            else
            {
                List <int> range = new List <int>();
                Tool.parseNumList(p.m_range, range);
                IMongoQuery timq1  = Query.LTE("RMB", BsonValue.Create(range[1]));
                IMongoQuery timq2  = Query.GTE("RMB", BsonValue.Create(range[0]));
                IMongoQuery tmpImq = Query.And(timq1, timq2);
                queryCond.addImq(tmpImq);
            }
        }

        if (condCount == 0)
        {
            return(OpRes.op_res_need_at_least_one_cond);
        }

        return(OpRes.opres_success);
    }
    // 构造查询条件
    OpRes getQueryCond(ParamScoreOpRecord p, GMUser user, ref string condStr, QueryCondition queryCond)
    {
        DateTime mint = DateTime.Now, maxt = mint;
        bool     useTime = false;

        if (!string.IsNullOrEmpty(p.m_time))
        {
            useTime = Tool.splitTimeStr(p.m_time, ref mint, ref maxt);
            if (!useTime)
            {
                return(OpRes.op_res_time_format_error);
            }
        }

        QueryCondGenerator gen = new QueryCondGenerator();

        gen.addCondition(string.Format(" opSrcCreateCode like '{0}%' ", ItemHelp.getCreateCodeSpecial(user)));

        if (!string.IsNullOrEmpty(p.m_opAcc))
        {
            gen.addCondition(string.Format("opSrc='{0}'", p.m_opAcc));

            if (queryCond.isExport())
            {
                queryCond.addCond("opSrc", p.m_opAcc);
            }
        }
        if (!string.IsNullOrEmpty(p.m_dstAcc))
        {
            gen.addCondition(string.Format("opDst='{0}'", p.m_dstAcc));

            if (queryCond.isExport())
            {
                queryCond.addCond("opDst", p.m_dstAcc);
            }
        }
        if (useTime)
        {
            gen.addCondition(string.Format(" opTime>='{0}' and opTime<'{1}' ", mint.ToString(ConstDef.DATE_TIME24),
                                           maxt.ToString(ConstDef.DATE_TIME24)));

            if (queryCond.isExport())
            {
                queryCond.addCond("time", p.m_time);
            }
        }

        if (p.m_orderState > -1)
        {
            gen.addCondition(string.Format("opResult={0}", p.m_orderState));

            if (queryCond.isExport())
            {
                queryCond.addCond("opResult", p.m_orderState);
            }
        }

        gen.addCondition(string.Format(" {0}.opSrc={1}.acc", TableName.GM_SCORE, TableName.GM_ACCOUNT));
        condStr = gen.and();

        return(OpRes.opres_success);
    }