public Tuple <int[], GetLotteryInfoResq> GetLottery(GetLotteryInfoReq para)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();
            int todayCount = activityInfoProcessing.GetTodayLotteryCount(para);

            if (todayCount == 0)
            {
                int rondom = LotteryProbability.GetRondom();
                activityInfoProcessing.InserLotteryInfo(para, rondom);
                return(new Tuple <int[], GetLotteryInfoResq>(new int[] { rondom, rondom, rondom }, GetLotteryInfo(para)));
            }
            else if (todayCount == 1)
            {
                int index0 = LotteryProbability.GetRondom();
                int index1 = LotteryProbability.GetRondom();
                int index2 = LotteryProbability.GetRondom();

                if (index0 == index1 && index1 == index2)
                {
                    activityInfoProcessing.InserLotteryInfo(para, index0);
                }
                else
                {
                    activityInfoProcessing.InserLotteryInfo(para, -1);
                }

                return(new Tuple <int[], GetLotteryInfoResq>(new int[] { index0, index1, index2 }, GetLotteryInfo(para)));
            }
            else  //两次机会都用完了
            {
                return(new Tuple <int[], GetLotteryInfoResq>(new int[] { }, null));
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="para"></param>
        /// <returns></returns>
        public bool GetBox(GetLotteryInfoReq para)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();
            int  count  = activityInfoProcessing.GetUserLotteryTypeCount(para);
            bool result = false;

            switch (para.BoxIndex)
            {
            case 0:
                result = (count >= 1);
                break;

            case 1:
                result = (count >= 3);
                break;

            case 2:
                result = (count >= 5);
                break;

            case 3:
                result = (count == 6);
                break;
            }

            if (result)
            {
                activityInfoProcessing.InserUserBox(para);
            }

            return(result);
        }
        public bool InserUserBox(GetLotteryInfoReq para)
        {
            UserBoxInfo userBoxInfo = new UserBoxInfo();

            userBoxInfo.F_BoxIndex   = para.BoxIndex;
            userBoxInfo.F_CreateTime = DateTime.Now;
            userBoxInfo.F_UId        = para.Uid;
            _dbContext.UserBoxInfo.Add(userBoxInfo);
            return(_dbContext.SaveChanges() > 0);
        }
        public Tuple <bool, int> InserLotteryInfo(GetLotteryInfoReq para, int lotteryIndex)
        {
            UserLotteryInfoModel userLotteryInfoModel = new UserLotteryInfoModel();
            DateTime             dt = DateTime.Now;

            userLotteryInfoModel.F_UId          = para.Uid;
            userLotteryInfoModel.F_CreateTime   = dt;
            userLotteryInfoModel.F_CreateUId    = string.IsNullOrWhiteSpace(para.HelperUid) ? para.Uid : para.HelperUid;
            userLotteryInfoModel.F_CreateDate   = dt.ToString("yyyy-MM-dd");
            userLotteryInfoModel.F_LotteryIndex = lotteryIndex;
            _dbContext.UserLotteryInfo.Add(userLotteryInfoModel);
            bool result = _dbContext.SaveChanges() > 0;

            return(new Tuple <bool, int>(result, lotteryIndex));
        }
        public ResultBase GetLottery([FromBody] GetLotteryInfoReq req)
        {
            if (string.IsNullOrEmpty(req.Uid))
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_NotFound_Para,
                });
            }

            ActivityInfoService activityInfoService = new ActivityInfoService();
            Tuple <int[], GetLotteryInfoResq> resq  = null;

            try
            {
                resq = activityInfoService.GetLottery(req);
            }
            catch (Exception ex)
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ServerError,
                    Message = ex.Message + ex.StackTrace
                });
            }

            if (resq != null && resq.Item1.Count() > 0)
            {
                resq.Item2.lotteryIndex = resq.Item1;
                return(new ResultBase
                {
                    IsSuccess = true,
                    Code = CodeConstant.Success,
                    Data = resq.Item2
                });
            }
            else
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_TodayCountIsOver
                });
            }
        }
        public ResultBase HelpGetLottery([FromBody] GetLotteryInfoReq req)
        {
            if (string.IsNullOrWhiteSpace(req.Uid) || string.IsNullOrWhiteSpace(req.HelperUid))
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_NotFound_Para
                });
            }

            ActivityInfoService activityInfoService      = new ActivityInfoService();
            Tuple <bool, int[], GetLotteryInfoResq> resq = new Tuple <bool, int[], GetLotteryInfoResq>(false, new int[] { -1 }, null);

            try
            {
                resq = activityInfoService.HelpGetLottery(req);
            }
            catch (Exception ex)
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ServerError,
                    Message = ex.Message + ex.StackTrace
                });
            }

            if (resq.Item1)
            {
                resq.Item3.lotteryIndex = resq.Item2;
                return(new ResultBase
                {
                    IsSuccess = true,
                    Code = CodeConstant.Success,
                    Data = resq.Item3
                });
            }
            else
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_TodayCountIsOver
                });
            }
        }
        public ResultBase GetLotteryInfo([FromBody] GetLotteryInfoReq req)
        {
            if (string.IsNullOrEmpty(req.Uid))
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_NotFound_Para,
                });
            }

            ActivityInfoService activityInfoService = new ActivityInfoService();
            GetLotteryInfoResq  resq = new GetLotteryInfoResq();

            try
            {
                resq = activityInfoService.GetLotteryInfo(req);
            }
            catch (Exception ex)
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ServerError,
                    Message = ex.Message + ex.StackTrace
                });
            }

            if (resq != null)
            {
                return(new ResultBase
                {
                    IsSuccess = true,
                    Code = CodeConstant.Success,
                    Data = resq
                });
            }
            else
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.DataNull
                });
            }
        }
        public ResultBase OpenBox([FromBody] GetLotteryInfoReq req)
        {
            if (string.IsNullOrWhiteSpace(req.Uid))
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_NotFound_Para
                });
            }

            ActivityInfoService activityInfoService = new ActivityInfoService();
            bool resq = false;

            try
            {
                resq = activityInfoService.GetBox(req);
            }
            catch (Exception ex)
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ServerError,
                    Message = ex.Message + ex.StackTrace
                });
            }

            if (resq)
            {
                return(new ResultBase
                {
                    IsSuccess = true,
                    Code = CodeConstant.Success,
                });
            }
            else
            {
                return(new ResultBase
                {
                    IsSuccess = false,
                    Code = CodeConstant.ClientError_CountIsNotEnough
                });
            }
        }
        public Tuple <bool, int[], GetLotteryInfoResq> HelpGetLottery(GetLotteryInfoReq req)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();

            if (activityInfoProcessing.GetHelperCount(req) >= 1)
            {
                return(new Tuple <bool, int[], GetLotteryInfoResq>(false, new int[] { -1 }, null));
            }

            if (!activityInfoProcessing.ExistUId(req.HelperUid))
            {
                activityInfoProcessing.InsertUserInfo(req.HelperUid, req.HelperHeadUrl, req.HelperNickName);
            }

            int rondom = GetRondomLottery();

            activityInfoProcessing.InserLotteryInfo(req, rondom);
            return(new Tuple <bool, int[], GetLotteryInfoResq>(true, new int[] { rondom }, GetLotteryInfo(req)));
        }
        public GetLotteryInfoResq GetLotteryInfo(GetLotteryInfoReq para)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();

            if (!activityInfoProcessing.ExistUId(para.Uid))
            {
                activityInfoProcessing.InsertUserInfo(para.Uid, para.HeadUrl, para.NickName);
            }

            GetLotteryInfoResq getLotteryInfoResq = new GetLotteryInfoResq();

            getLotteryInfoResq.AvailableCount = 2 - activityInfoProcessing.GetTodayLotteryCount(para);
            getLotteryInfoResq.userInfo       = activityInfoProcessing.GetUserInfoModel(para);
            getLotteryInfoResq.userBoxIndex   = activityInfoProcessing.GetUserBoxInfos(para).Select(m => m.F_BoxIndex).ToArray();

            List <UserLotteryCount> userLotteryDetails = activityInfoProcessing.GetUserLotteryCount(para);
            List <UserLotteryHelp>  userLotteryHelps   = activityInfoProcessing.GetUserLotteryHelp(para);

            List <UserLotteryDetail> details = new List <UserLotteryDetail>();

            foreach (UserLotteryCount item in userLotteryDetails)
            {
                var userHelp = userLotteryHelps.Where(m => m.F_LotteryIndex == item.F_LotteryIndex).OrderByDescending(m => m.F_CreateTime).FirstOrDefault();
                if (userHelp != null)
                {
                    UserLotteryDetail detail = new UserLotteryDetail();
                    detail.F_LotteryCount   = item.F_IndexCount;
                    detail.F_LotteryIndex   = item.F_LotteryIndex;
                    detail.F_UId            = item.F_UId;
                    detail.F_CreateUId      = userHelp.F_CreateUId;
                    detail.F_CreateNickName = userHelp.F_CreateNickName;
                    detail.F_CreateHeadUrl  = userHelp.F_CreateHeadUrl;
                    details.Add(detail);
                }
            }
            getLotteryInfoResq.userLottery = details;
            return(getLotteryInfoResq);
        }
        public int GetTodayCount(GetLotteryInfoReq req)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();

            return(activityInfoProcessing.GetTodayLotteryCount(req));
        }
        /// <summary>
        /// 今天帮助点亮者点亮次数
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public int GetHelperCount(GetLotteryInfoReq reqModel)
        {
            int results = _dbContext.UserLotteryInfo.Count(m => m.F_UId == reqModel.Uid && m.F_CreateUId == reqModel.HelperUid);

            return(results);
        }
        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <param name="para"></param>
        /// <returns></returns>
        public UserInfoModel GetUserInfo(GetLotteryInfoReq para)
        {
            ActivityInfoProcessing activityInfoProcessing = new ActivityInfoProcessing();

            return(activityInfoProcessing.GetUserInfoModel(para));
        }
        /// <summary>
        /// 获取用户今天已经抽奖次数
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public int GetTodayLotteryCount(GetLotteryInfoReq reqModel)
        {
            int lotteryCount = _dbContext.UserLotteryInfo.Count(m => m.F_CreateDate == DateTime.Now.ToString("yyyy-MM-dd") && m.F_UId == reqModel.Uid && m.F_CreateUId == reqModel.Uid);

            return(lotteryCount);
        }
        /// <summary>
        /// 用户最后一次助力者
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public List <UserLotteryHelp> GetUserLotteryHelp(GetLotteryInfoReq reqModel)
        {
            List <UserLotteryHelp> results = _dbContext.UserLotteryHelp.FromSql("SELECT x.F_Id,  x.F_CreateTime, x.F_UId,x.F_LotteryIndex,x.F_CreateUId,y.F_HeadUrl as F_CreateHeadUrl,y.F_NickName as  F_CreateNickName from T_UserLotteryInfo AS x LEFT JOIN t_userinfo AS y on x.F_CreateUId = y.F_UId where x.F_LotteryIndex!=-1 AND x.F_UId = @uid ", new MySqlParameter("uid", reqModel.Uid)).ToList();

            return(results);
        }
        /// <summary>
        /// 获取用户信息
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public UserInfoModel GetUserInfoModel(GetLotteryInfoReq reqModel)
        {
            UserInfoModel userInfo = _dbContext.Set <UserInfoModel>().Where(m => m.F_UId == reqModel.Uid).FirstOrDefault();

            return(userInfo);
        }
        /// <summary>
        /// 用户已经中了多少个奖项
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public int GetUserLotteryTypeCount(GetLotteryInfoReq reqModel)
        {
            int results = _dbContext.UserLotteryCount.FromSql("select count(*) as F_IndexCount,F_UId,F_LotteryIndex from T_UserLotteryInfo where F_LotteryIndex!=-1 AND F_UId=@uid GROUP BY F_UId,F_LotteryIndex", new MySqlParameter("uid", reqModel.Uid)).Count();

            return(results);
        }
        /// <summary>
        /// 获取用户已领取的宝箱
        /// </summary>
        /// <param name="reqModel"></param>
        /// <returns></returns>
        public List <UserBoxInfo> GetUserBoxInfos(GetLotteryInfoReq reqModel)
        {
            List <UserBoxInfo> userBoxInfos = _dbContext.UserBoxInfo.Where(m => m.F_UId == reqModel.Uid).ToList();

            return(userBoxInfos);
        }