Пример #1
0
        /// <summary>
        /// 插入记录
        /// </summary>
        /// <param name="inviteCode">邀请码</param>
        /// <param name="accoundId">被邀请人id</param>
        /// /// <param name="type">1:fiiipay 2:fiiipos</param>
        public void InsertRecord(InviteRecordIM im)
        {
            //判断是fiiipos还是fiiipay

            //1 插入数据 invite profit两个表 邀请双方都支持插入数据 钱包 流水进行更新
            // 判断当前邀请人数到达五十 进行推送。。。。。。。。。。。。

            //2 插入数据 invite
            if (!(im.Type == (int)SystemPlatform.FiiiPay || im.Type == (int)SystemPlatform.FiiiPOS))
            {
                throw new ArgumentException("只支持fiiipay和fiiipos邀请");
            }
            var userAccountDAC    = new UserAccountDAC();
            var account           = userAccountDAC.GetByInvitationCode(im.InvitationCode);
            var settingCollection = new MasterSettingDAC().SelectByGroup("InviteReward");
            var cryptoCurrencty   = new CryptocurrencyDAC().GetByCode("FIII");
            var cryptoId          = cryptoCurrencty.Id;

            if (im.Type == (int)SystemPlatform.FiiiPay)
            {
                var iDAC        = new InviteRecordDAC();
                var pfDAC       = new ProfitDetailDAC();
                var uwComponent = new UserWalletComponent();

                var uwDAC  = new UserWalletDAC();
                var uwsDAC = new UserWalletStatementDAC();
                var utDAC  = new UserTransactionDAC();

                var inviteMoney  = decimal.Parse(settingCollection.Where(item => item.Name == "Invite_Reward_Amount").Select(item => item.Value).FirstOrDefault());
                var rewardMoney  = decimal.Parse(settingCollection.Where(item => item.Name == "Over_People_Count_Reward_Amount").Select(item => item.Value).FirstOrDefault());
                var maxCount     = decimal.Parse(settingCollection.Where(item => item.Name == "Max_Reward_Amount").Select(item => item.Value).FirstOrDefault());
                var orderNo1     = CreateOrderno();
                var orderNo2     = CreateOrderno();
                var inviteWallet = uwComponent.GetUserWallet(account.Id, cryptoId);
                if (inviteWallet == null)
                {
                    inviteWallet = uwComponent.GenerateWallet(account.Id, cryptoId);
                }

                var beInvitedWallet = uwComponent.GetUserWallet(im.BeInvitedAccountId, cryptoId);
                if (beInvitedWallet == null)
                {
                    beInvitedWallet = uwComponent.GenerateWallet(im.BeInvitedAccountId, cryptoId);
                }

                int     inviteId;
                long    profitId1    = 0; //邀请人奖励ID
                long    profitId2    = 0; //被邀请人奖励ID
                long    exProfitId1  = 0; //邀请人额外奖励ID
                decimal totalReward  = pfDAC.GetTotalReward(account);
                int     invitedCount = pfDAC.GetInvitedCount(account);

                using (var scope = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required, new TimeSpan(0, 0, 1, 30)))
                {
                    //插入数据到inviterecord表中
                    inviteId = iDAC.Insert(new InviteRecord()
                    {
                        Type = (InviteType)im.Type, AccountId = im.BeInvitedAccountId, Timestamp = DateTime.UtcNow, InviterCode = im.InvitationCode, InviterAccountId = account.Id
                    });

                    if (totalReward < maxCount)
                    {
                        profitId1 = pfDAC.Insert(new ProfitDetail()
                        {
                            InvitationId = inviteId,
                            CryptoAmount = inviteMoney,
                            AccountId    = account.Id,
                            Status       = InviteStatusType.IssuedFrozen,
                            Type         = ProfitType.InvitePiiiPay,
                            OrderNo      = orderNo1,
                            Timestamp    = DateTime.UtcNow,
                            CryptoId     = cryptoId
                        });

                        utDAC.Insert(new UserTransaction
                        {
                            Id         = Guid.NewGuid(),
                            AccountId  = account.Id,
                            CryptoId   = cryptoCurrencty.Id,
                            CryptoCode = cryptoCurrencty.Code,
                            Type       = UserTransactionType.Profit,
                            DetailId   = profitId1.ToString(),
                            Status     = (byte)InviteStatusType.IssuedFrozen,
                            Timestamp  = DateTime.UtcNow,
                            Amount     = inviteMoney,
                            OrderNo    = orderNo1
                        });

                        uwDAC.IncreaseFrozen(inviteWallet.Id, inviteMoney);

                        uwsDAC.Insert(new UserWalletStatement
                        {
                            WalletId      = inviteWallet.Id,
                            Action        = UserWalletStatementAction.Invite,
                            Amount        = 0,
                            Balance       = inviteWallet.Balance,
                            FrozenAmount  = inviteMoney,
                            FrozenBalance = inviteWallet.FrozenBalance + inviteMoney,
                            Timestamp     = DateTime.UtcNow
                        });

                        // 每当满50人时则可以奖励 采用了插入操作 所以只要满足为49个就可以了
                        if ((invitedCount + 1) % 50 == 0)
                        {
                            var pd50 = new ProfitDetail()
                            {
                                InvitationId = inviteId,
                                CryptoAmount = rewardMoney,
                                AccountId    = account.Id,
                                Status       = InviteStatusType.IssuedFrozen,
                                Type         = ProfitType.Reward,
                                OrderNo      = CreateOrderno(),
                                Timestamp    = DateTime.UtcNow,
                                CryptoId     = cryptoId
                            };
                            exProfitId1 = pfDAC.Insert(pd50);

                            utDAC.Insert(new UserTransaction
                            {
                                Id         = Guid.NewGuid(),
                                AccountId  = account.Id,
                                CryptoId   = cryptoCurrencty.Id,
                                CryptoCode = cryptoCurrencty.Code,
                                Type       = UserTransactionType.Profit,
                                DetailId   = exProfitId1.ToString(),
                                Status     = (byte)InviteStatusType.IssuedFrozen,
                                Timestamp  = DateTime.UtcNow,
                                Amount     = rewardMoney,
                                OrderNo    = pd50.OrderNo
                            });

                            uwDAC.IncreaseFrozen(inviteWallet.Id, rewardMoney);

                            uwsDAC.Insert(new UserWalletStatement
                            {
                                WalletId      = inviteWallet.Id,
                                Action        = UserWalletStatementAction.Invite,
                                Amount        = 0,
                                Balance       = inviteWallet.Balance,
                                FrozenAmount  = rewardMoney,
                                FrozenBalance = inviteWallet.FrozenBalance + inviteMoney + rewardMoney,
                                Timestamp     = DateTime.UtcNow
                            });
                        }
                        profitId2 = pfDAC.Insert(new ProfitDetail()
                        {
                            InvitationId = inviteId,
                            CryptoAmount = inviteMoney,
                            AccountId    = im.BeInvitedAccountId,
                            Type         = ProfitType.BeInvited,
                            Status       = InviteStatusType.IssuedActive,
                            OrderNo      = orderNo2,
                            Timestamp    = DateTime.UtcNow,
                            CryptoId     = cryptoId
                        });
                        utDAC.Insert(new UserTransaction
                        {
                            Id         = Guid.NewGuid(),
                            AccountId  = im.BeInvitedAccountId,
                            CryptoId   = cryptoCurrencty.Id,
                            CryptoCode = cryptoCurrencty.Code,
                            Type       = UserTransactionType.Profit,
                            DetailId   = profitId2.ToString(),
                            Status     = (byte)InviteStatusType.IssuedActive,
                            Timestamp  = DateTime.UtcNow,
                            Amount     = inviteMoney,
                            OrderNo    = orderNo2
                        });
                        uwDAC.Increase(beInvitedWallet.Id, inviteMoney);
                        uwsDAC.Insert(new UserWalletStatement
                        {
                            WalletId      = beInvitedWallet.Id,
                            Action        = UserWalletStatementAction.BeInvite,
                            Amount        = inviteMoney,
                            Balance       = beInvitedWallet.Balance + inviteMoney,
                            FrozenAmount  = 0,
                            FrozenBalance = beInvitedWallet.FrozenBalance,
                            Timestamp     = DateTime.UtcNow
                        });
                    }
                    scope.Complete();
                }

                if (!(im.Type == (int)SystemPlatform.FiiiPay || im.Type == (int)SystemPlatform.FiiiPOS))
                {
                    throw new ArgumentException("只支持fiiipay和fiiipos邀请");
                }

                if (im.Type == (int)SystemPlatform.FiiiPay)
                {
                    UserMSMQ.PubUserInviteSuccessed(profitId2, 0);
                }
                //else if (im.Type == SystemPlatform.FiiiPOS)
                //    MerchantMSMQ.PubUserInviteSuccessed(profitId2, 0);
            }
            //else
            //{
            //    var iDAC = new InviteRecordDAC();
            //    iDAC.Insert(new InviteRecord() { Type = im.Type, AccountId = im.BeInvitedAccountId, Timestamp = DateTime.UtcNow, InviterCode = im.InvitationCode, InviterAccountId = account.Id });
            //}
        }
Пример #2
0
        public async Task <bool> FiiipayMerchantCreateAsync(UserAccount account, FiiiPayMerchantInfoCreateIM model)
        {
            var uaDAC = new UserAccountDAC();

            if (account.L1VerifyStatus != VerifyStatus.Certified)
            {
                throw new CommonException(ReasonCode.NOT_VERIFY_LV1, Resources.EMNeedLV1Verfied);
            }

            var  inviteAccount    = uaDAC.GetByInvitationCode(model.InviteCode);
            bool needInviteRecord = true;

            if (!string.IsNullOrEmpty(model.InviteCode))
            {
                if (inviteAccount == null)
                {
                    throw new CommonException(ReasonCode.INVITORCODE_NOT_EXISTS, MessageResources.InvalidInvitation);
                }
                if (inviteAccount.InvitationCode == account.InvitationCode)
                {
                    throw new CommonException(ReasonCode.INVALID_INVITECODE, MessageResources.InviteCodeCanotInputSelf);
                }

                var existInviteRecord = await new InviteRecordDAC().GetDetailByAccountIdAsync(account.Id, InviteType.FiiipayMerchant);
                if (existInviteRecord != null)
                {
                    needInviteRecord = false;
                }
            }
            else
            {
                needInviteRecord = false;
            }


            var merchantCountry = new CountryDAC().GetById(model.CountryId);

            if (merchantCountry == null)
            {
                throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
            }
            if (!merchantCountry.IsSupportStore)
            {
                throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
            }

            Regions stateRegion;
            Regions cityRegion;

            if (model.StateId.HasValue)
            {
                stateRegion = await new RegionDAC().GetByIdAsync(model.StateId.Value);
                if (stateRegion == null)
                {
                    throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
                }
                if (stateRegion.CountryId != model.CountryId)
                {
                    throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
                }

                if (model.CityId.HasValue)
                {
                    cityRegion = await new RegionDAC().GetByIdAsync(model.CityId.Value);
                    if (cityRegion == null)
                    {
                        throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
                    }
                    if (cityRegion.CountryId != model.CountryId || cityRegion.ParentId != stateRegion.Id)
                    {
                        throw new CommonException(ReasonCode.RECORD_NOT_EXIST, MessageResources.InvalidParameters);
                    }
                }
            }

            #region entities
            Guid     merchantInfoId = Guid.NewGuid();
            DateTime dtNow          = DateTime.UtcNow;

            MerchantInformation merchantInfo = new MerchantInformation
            {
                Id                = merchantInfoId,
                CreateTime        = dtNow,
                FromType          = InputFromType.UserInput,
                MerchantName      = model.MerchantName,
                WeekTxt           = model.WeekTxt,
                Tags              = model.TagList == null ? "" : string.Join(",", model.TagList),
                Introduce         = model.Introduce,
                CountryId         = merchantCountry.Id,
                StateId           = model.StateId,
                CityId            = model.CityId,
                PhoneCode         = account.PhoneCode,
                Address           = model.Address,
                Lng               = model.Lng,
                Lat               = model.Lat,
                Status            = Status.Stop,
                VerifyStatus      = VerifyStatus.UnderApproval,
                MerchantAccountId = account.Id,
                Phone             = model.Phone,
                IsPublic          = Status.Stop,
                FileId            = model.StorefrontImg[0],
                ThumbnailId       = model.StorefrontImg[1],
                AccountType       = AccountType.User,
                Markup            = 0,
                FeeRate           = 0,
                IsAllowExpense    = false,
                Week              = Week.Monday,
                ApplicantName     = model.ApplicantName,
                UseFiiiDeduct     = model.UseFiiiDeduction
            };
            InviteRecord inviteRecord = new InviteRecord
            {
                AccountId        = account.Id,
                InviterCode      = model.InviteCode,
                Type             = InviteType.FiiipayMerchant,
                InviterAccountId = inviteAccount?.Id ?? Guid.Empty,
                Timestamp        = dtNow
            };
            FiiipayMerchantVerifyRecord record = new FiiipayMerchantVerifyRecord
            {
                CreateTime           = dtNow,
                MerchantInfoId       = merchantInfoId,
                BusinessLicenseImage = model.BusinessLicenseImage,
                LicenseNo            = model.LicenseNo,
                VerifyStatus         = VerifyStatus.UnderApproval
            };

            List <MerchantCategory> categorys = model.MerchantCategorys.Select(t => new MerchantCategory
            {
                MerchantInformationId = merchantInfoId,
                Category = t
            }).ToList();

            List <MerchantOwnersFigure> figuresList = new List <MerchantOwnersFigure>();
            if (model.FigureImgList != null)
            {
                for (int i = 0; i < model.FigureImgList.Length; i++)
                {
                    figuresList.Add(new MerchantOwnersFigure
                    {
                        MerchantInformationId = merchantInfoId,
                        FileId      = model.FigureImgList[i][0],
                        Sort        = i,
                        ThumbnailId = model.FigureImgList[i][1]
                    });
                }
            }

            var coinList = await new CryptocurrencyDAC().GetAllAsync();

            List <MerchantSupportCrypto> supportCryptoList = model.SupportCoins.Select(t =>
            {
                var c = coinList.Find(m => m.Id == t);
                if (c != null)
                {
                    return(new MerchantSupportCrypto
                    {
                        MerchantInfoId = merchantInfoId,
                        CryptoId = t,
                        CryptoCode = c.Code
                    });
                }

                return(null);
            }).Where(x => x != null).ToList();

            #endregion

            var mInfoDAC          = new MerchantInformationDAC();
            var fmVerfiyRecordDAC = new FiiipayMerchantVerifyRecordDAC();
            var mCategoryDAC      = new MerchantCategoryDAC();
            var mFigureDAC        = new MerchantOwnersFigureDAC();
            var mSupportCryptoDAC = new MerchantSupportCryptoDAC();
            var inviteDAC         = new InviteRecordDAC();

            using (var scope = new TransactionScope(TransactionScopeOption.Required, new TimeSpan(0, 0, 1, 30)))
            {
                mInfoDAC.Insert(merchantInfo);
                fmVerfiyRecordDAC.Insert(record);
                if (needInviteRecord)
                {
                    inviteDAC.Insert(inviteRecord);
                }

                if (categorys != null && categorys.Count > 0)
                {
                    foreach (var item in categorys)
                    {
                        mCategoryDAC.Insert(item);
                    }
                }
                if (figuresList != null && figuresList.Count > 0)
                {
                    foreach (var item in figuresList)
                    {
                        mFigureDAC.Insert(item);
                    }
                }
                if (supportCryptoList != null && supportCryptoList.Count > 0)
                {
                    foreach (var item in supportCryptoList)
                    {
                        mSupportCryptoDAC.Insert(item);
                    }
                }

                scope.Complete();
            }

            return(true);
        }