示例#1
0
        /// <summary>
        /// 用户是否能参与活动,true:能参与,反之不能
        /// </summary>
        public bool IsUserJoinPrizeActivity(string userId, string schemeId)
        {
            if (string.IsNullOrEmpty(userId))
            {
                return(false);
            }
            //特殊用户
            var specialList = ConfigurationManager.AppSettings["SpecialUser"].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);

            if (specialList.Contains(userId))
            {
                return(true);
            }

            var sportsManager = new Sports_Manager();
            var order         = sportsManager.QuerySports_Order_Complate(schemeId);

            if (order == null)
            {
                return(false);
            }
            var together = sportsManager.QuerySports_Together(order.SchemeId);

            if (together == null)
            {
                return(false);
            }
            if (together.SystemGuarantees > 0)
            {
                return(false);
            }
            var agentList = ConfigurationManager.AppSettings["JoinActivityAgent"].Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries);

            if (agentList.Contains(userId))
            {
                return(false);
            }
            var manager = new UserBalanceManager();
            var user    = manager.GetUserRegister(userId);

            if (user == null)
            {
                return(false);
            }
            if (user.IsAgent == true)
            {
                return(false);
            }
            if (string.IsNullOrEmpty(user.AgentId))
            {
                return(true);
            }
            return(!agentList.Contains(user.AgentId));
        }
示例#2
0
        /// <summary>
        /// 派奖后计算宝单分享相关
        /// </summary>
        public void OrderPrize_AfterTranCommit(string userId, string schemeId, string gameCode, string gameType, string issuseNumber, decimal orderMoney, bool isBonus, decimal preTaxBonusMoney, decimal afterTaxBonusMoney, bool isVirtualOrder, DateTime prizeTime)
        {
            if (string.IsNullOrEmpty(userId) || string.IsNullOrEmpty(schemeId))
            {
                return;
            }
            var orderManager  = new Sports_Manager();
            var bdfxManager   = new BDFXManager();
            var orderComplate = orderManager.QuerySports_Order_Complate(schemeId);

            if (orderComplate == null)
            {
                return;
            }
            if (orderComplate.SchemeType == (int)SchemeType.SingleTreasure)//宝单
            {
                var bdfxEntity = bdfxManager.QueryTotalSingleTreasureBySchemeId(schemeId);
                if (bdfxEntity != null)
                {
                    bdfxEntity.CurrBonusMoney = afterTaxBonusMoney;
                    bdfxEntity.IsBonus        = true;
                    bdfxEntity.IsComplate     = true;
                    if (bdfxEntity.CurrentBetMoney > 0)
                    {
                        var currProfitRate = Math.Truncate(((afterTaxBonusMoney - bdfxEntity.CurrentBetMoney) / bdfxEntity.CurrentBetMoney) * 100) / 100;
                        bdfxEntity.CurrProfitRate = currProfitRate;
                    }
                    else
                    {
                        bdfxEntity.CurrProfitRate = 0;
                    }
                    bdfxManager.UpdateTotalSingleTreasure(bdfxEntity);
                }
            }
            else if (orderComplate.SchemeType == (int)SchemeType.SingleCopy && afterTaxBonusMoney > 0)//抄单
            {
                var manager = new Sports_Manager();
                var order   = manager.QuerySports_Order_Complate(schemeId);
                if (order == null)
                {
                    throw new LogicException(string.Format("自动派钱,没有找到订单{0}", schemeId));
                }
                var bdfxRecorSingleEntity = bdfxManager.QueryBDFXRecordSingleCopyBySchemeId(schemeId);
                if (bdfxRecorSingleEntity != null)
                {
                    var BDFXEntity = bdfxManager.QueryTotalSingleTreasureBySchemeId(bdfxRecorSingleEntity.BDXFSchemeId);
                    if (BDFXEntity != null)
                    {
                        BDFXEntity.TotalBonusMoney += afterTaxBonusMoney;
                        if (BDFXEntity.TotalBuyMoney > 0 && BDFXEntity.TotalBonusMoney != 0)
                        {
                            var profiteRate = (BDFXEntity.TotalBonusMoney - BDFXEntity.TotalBuyMoney) / BDFXEntity.TotalBuyMoney;
                            BDFXEntity.ProfitRate = Math.Truncate(profiteRate * 100) / 100M;
                        }
                        else
                        {
                            BDFXEntity.ProfitRate = 0;
                        }
                        //var commissionMoney = afterTaxBonusMoney * BDFXEntity.Commission / 100;
                        //BDFXEntity.TotalCommissionMoney += commissionMoney;
                        var commissionMoney = (order.AfterTaxBonusMoney - order.TotalMoney) * BDFXEntity.Commission / 100M;
                        commissionMoney = Math.Truncate(commissionMoney * 100) / 100M;
                        if (commissionMoney > 0)
                        {
                            BDFXEntity.TotalCommissionMoney += commissionMoney;
                        }
                        else
                        {
                            BDFXEntity.TotalCommissionMoney = 0;
                        }
                        bdfxManager.UpdateTotalSingleTreasure(BDFXEntity);
                    }
                }
            }
        }
示例#3
0
        public void OrderPrize_AfterTranCommit(string userId, string schemeId, string gameCode, string gameType, string issuseNumber, decimal orderMoney, bool isBonus, decimal preTaxBonusMoney, decimal afterTaxBonusMoney, bool isVirtualOrder, DateTime prizeTime)
        {
            using (var biz = new GameBiz.Business.GameBizBusinessManagement())
            {
                biz.BeginTran();

                var sportsManager = new Sports_Manager();
                var order         = sportsManager.QuerySports_Order_Complate(schemeId);
                if (order == null)
                {
                    throw new LogicException(string.Format("自动分红,没有找到订单{0}", schemeId));
                }
                //if (order.IsPayRebate)
                //    throw new LogicException(string.Format("订单{0}已分红", schemeId));
                var bonusAwardsMoney = 0M;
                if (order.AddMoneyDescription.Contains("10"))
                {
                    bonusAwardsMoney = order.AddMoney;
                }
                var bonusMoney = (order.TotalMoney - order.RedBagMoney - order.AfterTaxBonusMoney + bonusAwardsMoney);
                if (order.TicketStatus == TicketStatus.Ticketed && !order.IsVirtualOrder)
                {
                    var msg = string.Empty;
                    //合买判断
                    if (order.SchemeType == SchemeType.TogetherBetting)
                    {
                        var main = sportsManager.QuerySports_Together(schemeId);
                        if (main == null)
                        {
                            msg = string.Format("找不到合买订单:{0}", schemeId);
                        }
                        var sysJoinEntity = sportsManager.QuerySports_TogetherJoin(schemeId, TogetherJoinType.SystemGuarantees);
                        if (sysJoinEntity != null && sysJoinEntity.RealBuyCount > 0)
                        {
                            msg = "网站参与保底,不分红";
                        }

                        if (main.SoldCount + main.Guarantees < main.TotalCount)
                        {
                            throw new Exception("订单未满员,不执行分红");
                        }
                    }

                    if (string.IsNullOrEmpty(msg))
                    {
                        var userManager    = new UserBalanceManager();
                        var ocAgentManager = new OCAgentManager();
                        var orderGameType  = string.Empty;
                        if (new string[] { "CTZQ", "BJDC", "JCZQ", "JCLQ" }.Contains(order.GameCode))
                        {
                            orderGameType = order.GameType;
                        }

                        PayOrderBonus(userManager, ocAgentManager, order.SchemeId, order.SchemeType, order.UserId, order.GameCode, orderGameType, order.UserId, bonusMoney, 0);
                    }
                }

                order.IsPayRebate = true;
                sportsManager.UpdateSports_Order_Complate(order);

                biz.CommitTran();
            }
        }
        public void OrderPrize_AfterTranCommit(string userId, string schemeId, string gameCode, string gameType, string issuseNumber, decimal orderMoney, bool isBonus, decimal preTaxBonusMoney, decimal afterTaxBonusMoney, bool isVirtualOrder, DateTime prizeTime)
        {
            //if (isVirtualOrder) return;
            //if (!isBonus) return;
            //if (afterTaxBonusMoney <= 0) return;
            //if (afterTaxBonusMoney >= 10000M) return;

            //开启事务
            using (var biz = new GameBizBusinessManagement())
            {
                biz.BeginTran();

                var manager = new Sports_Manager();
                var order   = manager.QuerySports_Order_Complate(schemeId);
                if (order == null)
                {
                    throw new LogicException(string.Format("自动派钱,没有找到订单{0}", schemeId));
                }
                if (order.IsPrizeMoney)
                {
                    throw new LogicException(string.Format("订单{0}已派奖", schemeId));
                }

                order.IsPrizeMoney = true;
                manager.UpdateSports_Order_Complate(order);

                if (!order.IsVirtualOrder)
                {
                    if (order.SchemeType == SchemeType.GeneralBetting || order.SchemeType == SchemeType.ChaseBetting || order.SchemeType == SchemeType.SingleCopy)
                    {
                        #region 普通、追号、抄单
                        if (order.AfterTaxBonusMoney > 0)
                        {
                            if (order.SchemeType == SchemeType.SingleCopy)//抄单订单,派奖时需减去奖金提成的金额
                            {
                                var bdfxManager           = new BDFXManager();
                                var bdfxRecorSingleEntity = bdfxManager.QueryBDFXRecordSingleCopyBySchemeId(schemeId);
                                var realBonusMoney        = order.AfterTaxBonusMoney;
                                var commissionMoney       = 0M;
                                if (bdfxRecorSingleEntity != null)
                                {
                                    var BDFXEntity = bdfxManager.QueryTotalSingleTreasureBySchemeId(bdfxRecorSingleEntity.BDXFSchemeId);
                                    if (BDFXEntity != null)
                                    {
                                        //计算提成金额
                                        if ((order.AfterTaxBonusMoney - order.TotalMoney) > 0)
                                        {
                                            commissionMoney = (order.AfterTaxBonusMoney - order.TotalMoney) * BDFXEntity.Commission / 100M;
                                            commissionMoney = Math.Truncate(commissionMoney * 100) / 100M;
                                            realBonusMoney  = order.AfterTaxBonusMoney - commissionMoney;
                                            //返提成
                                            if (commissionMoney > 0)
                                            {
                                                BusinessHelper.Payin_To_Balance(AccountType.Bonus, BusinessHelper.FundCategory_BDFXCommissionMoney, BDFXEntity.UserId, schemeId, commissionMoney,
                                                                                string.Format("抄单订单{0}中奖{1:N2}元,提成{2:N0}%,获得奖金盈利提成金额{3:N2}元.", schemeId, order.AfterTaxBonusMoney, BDFXEntity.Commission, commissionMoney));
                                            }
                                        }
                                    }
                                }
                                //返奖金
                                BusinessHelper.Payin_To_Balance(AccountType.Bonus, BusinessHelper.FundCategory_Bonus, order.UserId, schemeId, realBonusMoney,
                                                                string.Format("抄单订单{0}中奖{1:N2}元,扣除奖金盈利提成金额{2:N2}元,实得奖金{3:N2}元.", schemeId, order.AfterTaxBonusMoney, commissionMoney, realBonusMoney));
                            }
                            else
                            {
                                BusinessHelper.Payin_To_Balance(AccountType.Bonus, BusinessHelper.FundCategory_Bonus, order.UserId, schemeId, order.AfterTaxBonusMoney,
                                                                string.Format("中奖奖金{0:N2}元.", order.AfterTaxBonusMoney));
                            }
                        }

                        if (order.AddMoney > 0)
                        {
                            BusinessHelper.Payin_To_Balance(order.AddMoneyDescription == "10" ? AccountType.Bonus : AccountType.RedBag, BusinessHelper.FundCategory_Bonus, order.UserId, schemeId, order.AddMoney,
                                                            string.Format("订单{0}活动赠送{1:N2}元.", schemeId, order.AddMoney));
                        }
                        #endregion
                    }
                    if (order.SchemeType == SchemeType.TogetherBetting)
                    {
                        #region 合买
                        var main = manager.QuerySports_Together(schemeId);
                        if (order.AfterTaxBonusMoney > 0)
                        {
                            //提成
                            var deductMoney = 0M;
                            if (order.AfterTaxBonusMoney > main.TotalMoney)
                            {
                                deductMoney = (order.AfterTaxBonusMoney - main.TotalMoney) * main.BonusDeduct / 100;
                            }
                            //提成金额,只能给合买发起者
                            if (deductMoney > 0M)
                            {
                                BusinessHelper.Payin_To_Balance(AccountType.Bonus, BusinessHelper.FundCategory_Deduct, order.UserId, schemeId, deductMoney,
                                                                string.Format("订单{0}, 合买奖金盈利提成金额{1:N2}元。", schemeId, deductMoney));
                            }

                            //中奖金额,分发到所有参与合买的用户的奖金账户
                            var bonusMoney  = order.AfterTaxBonusMoney - deductMoney;
                            var singleMoney = bonusMoney / main.TotalCount;
                            foreach (var join in manager.QuerySports_TogetherSucessJoin(schemeId))
                            {
                                //if (join.JoinType == TogetherJoinType.SystemGuarantees) continue;//20151015屏蔽原代码,如果合买有系统保底,依然将奖金返还到系统保底账上
                                //发参与奖金
                                if (join.RealBuyCount <= 0)
                                {
                                    continue;
                                }
                                var joinMoney = join.RealBuyCount * singleMoney;
                                //派钱
                                if (joinMoney > 0M)
                                {
                                    BusinessHelper.Payin_To_Balance(AccountType.Bonus, BusinessHelper.FundCategory_Bonus, join.JoinUserId, schemeId, joinMoney,
                                                                    string.Format("中奖分成,奖金¥{0:N2}元。", joinMoney));
                                }
                            }
                        }
                        if (order.AddMoney > 0M)
                        {
                            //加奖金额分配给发起者
                            if (order.DistributionWay == AddMoneyDistributionWay.CreaterOnly)
                            {
                                //加奖
                                if (order.AddMoney > 0)
                                {
                                    BusinessHelper.Payin_To_Balance(order.AddMoneyDescription == "10" ? AccountType.Bonus : AccountType.RedBag, BusinessHelper.FundCategory_Activity, order.UserId, schemeId, order.AddMoney,
                                                                    string.Format("订单{0}活动赠送{1:N2}元。", schemeId, order.AddMoney), RedBagCategory.Activity);
                                }
                            }
                            //处理加奖
                            if (order.DistributionWay == AddMoneyDistributionWay.Average)
                            {
                                var addMonesinglePrice = order.AddMoney / main.TotalCount;
                                foreach (var join in manager.QuerySports_TogetherSucessJoin(schemeId))
                                {
                                    if (join.JoinType == TogetherJoinType.SystemGuarantees)
                                    {
                                        continue;
                                    }

                                    if (join.RealBuyCount <= 0)
                                    {
                                        continue;
                                    }
                                    //发参与奖金
                                    var joinMoney = join.RealBuyCount * addMonesinglePrice;
                                    //派钱
                                    if (joinMoney > 0M)
                                    {
                                        BusinessHelper.Payin_To_Balance(order.AddMoneyDescription == "10" ? AccountType.Bonus : AccountType.RedBag, BusinessHelper.FundCategory_Activity, join.JoinUserId, schemeId, joinMoney,
                                                                        string.Format("订单{0}活动赠送{1:N2}元。", schemeId, joinMoney), RedBagCategory.Activity);
                                    }
                                }
                            }
                            //加奖金额分配给发起者
                            if (order.DistributionWay == AddMoneyDistributionWay.JoinerOnly)
                            {
                                //订单发起者没有加奖
                                var joinList           = manager.QuerySports_TogetherSucessJoin(schemeId);
                                var createrList        = joinList.Where(p => p.JoinUserId == order.UserId).ToList();
                                var createJoinCount    = createrList.Count == 0 ? 0 : createrList.Sum(p => p.RealBuyCount);
                                var addMonesinglePrice = order.AddMoney / (main.TotalCount - createJoinCount);
                                foreach (var join in joinList)
                                {
                                    if (join.JoinType == TogetherJoinType.SystemGuarantees)
                                    {
                                        continue;
                                    }
                                    if (join.JoinUserId == order.UserId)
                                    {
                                        continue;
                                    }

                                    if (join.RealBuyCount <= 0)
                                    {
                                        continue;
                                    }
                                    //发参与奖金
                                    var joinMoney = join.RealBuyCount * addMonesinglePrice;
                                    //派钱
                                    if (joinMoney > 0M)
                                    {
                                        BusinessHelper.Payin_To_Balance(order.AddMoneyDescription == "10" ? AccountType.Bonus : AccountType.RedBag, BusinessHelper.FundCategory_Activity, join.JoinUserId, schemeId, joinMoney,
                                                                        string.Format("订单{0}活动赠送{1:N2}元。", schemeId, joinMoney), RedBagCategory.Activity);
                                    }
                                }
                            }
                        }
                        #endregion
                    }

                    //添加最新中奖记录表
                    if (afterTaxBonusMoney >= 2000M)
                    {
                        var userInfo = new UserBalanceManager().GetUserRegister(order.UserId);
                        if (userInfo != null)
                        {
                            new External.Domain.Managers.SiteMessage.SiteActivityManager().AddLotteryNewBonus(new External.Domain.Entities.SiteMessage.LotteryNewBonus
                            {
                                AfterTaxBonusMoney       = order.AfterTaxBonusMoney,
                                Amount                   = order.Amount,
                                CreateTime               = order.ComplateDateTime,
                                GameCode                 = order.GameCode,
                                GameType                 = order.GameType,
                                IssuseNumber             = order.IssuseNumber,
                                PlayType                 = order.PlayType,
                                PreTaxBonusMoney         = order.PreTaxBonusMoney,
                                SchemeId                 = order.SchemeId,
                                TotalMoney               = order.TotalMoney,
                                UserDisplayName          = userInfo.DisplayName,
                                HideUserDisplayNameCount = userInfo.HideDisplayNameCount
                            });
                        }
                    }
                }

                biz.CommitTran();
            }

            //刷新用户在Redis中的余额
            if (afterTaxBonusMoney > 0M)
            {
                BusinessHelper.RefreshRedisUserBalance(userId);
            }
        }