Пример #1
0
        public void Cancel([FromBody] InsuranceAction action)
        {
            ModelState.Validate();

            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }
            if (action.InsuranceId <= 0)
            {
                throw new ArgumentException();
            }

            if (action.ActionDate.Date != DateTime.Today)
            {
                throw new PawnshopApplicationException("Данное действие отмене не подлежит.");
            }

            var insurance = _insuranceRepository.Get(action.InsuranceId);

            using (var transaction = _actionRepository.BeginTransaction())
            {
                switch (action.ActionType)
                {
                case InsuranceActionType.Sign:
                    if (insurance.Status != InsuranceStatus.Signed)
                    {
                        throw new InvalidOperationException();
                    }
                    insurance.Status = InsuranceStatus.Draft;
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                _orderRepository.Delete(action.OrderId);
                _eventLog.Log(EventCode.CashOrderDeleted, EventStatus.Success, EntityType.CashOrder, action.OrderId, null, null);
                _insuranceRepository.Update(insurance);
                _actionRepository.Delete(action.Id);

                transaction.Commit();
            }
        }
Пример #2
0
        private void CreateOrder(Insurance insurance, InsuranceAction action, OrderType orderType, int debitAccountId, int creditAccountId)
        {
            string code;

            switch (orderType)
            {
            case OrderType.CashIn:
                code = _branchContext.Configuration.CashOrderSettings.CashInNumberCode;
                break;

            case OrderType.CashOut:
                code = _branchContext.Configuration.CashOrderSettings.CashOutNumberCode;
                break;

            default:
                throw new ArgumentOutOfRangeException(nameof(orderType), orderType, null);
            }

            var order = new CashOrder
            {
                OrderType       = orderType,
                ClientId        = insurance.Contract.ClientId,
                DebitAccountId  = debitAccountId,
                CreditAccountId = creditAccountId,
                OrderCost       = insurance.InsuranceCost,
                OrderDate       = action.ActionDate,
                Reason          = GetReason(action.ActionType),
                RegDate         = DateTime.Now,
                OwnerId         = _branchContext.Branch.Id,
                BranchId        = _branchContext.Branch.Id,
                AuthorId        = _sessionContext.UserId,
                OrderNumber     = _cashCounterRepository.Next(orderType, action.ActionDate.Year, _branchContext.Branch.Id, code)
            };

            if (order.DebitAccountId == 0 || order.CreditAccountId == 0)
            {
                throw new PawnshopApplicationException("Настройте счета дебет и кредит для страхового договора");
            }

            _orderRepository.Insert(order);
            _eventLog.Log(EventCode.CashOrderSaved, EventStatus.Success, EntityType.CashOrder, order.Id, null, null);

            action.OrderId = order.Id;
        }
Пример #3
0
        public InsuranceAction Sign([FromBody] InsuranceAction action)
        {
            if (action == null)
            {
                throw new ArgumentNullException(nameof(action));
            }
            if (action.InsuranceId <= 0)
            {
                throw new ArgumentException();
            }

            var insurance = _insuranceRepository.Get(action.InsuranceId);

            if (insurance.Status != InsuranceStatus.Draft)
            {
                throw new InvalidOperationException();
            }

            using (var transaction = _actionRepository.BeginTransaction())
            {
                action.ActionType = InsuranceActionType.Sign;
                action.ActionDate = DateTime.Now;
                action.AuthorId   = _sessionContext.UserId;

                var debitAccountId  = _branchContext.Configuration?.CashOrderSettings?.InsuranceSettings?.SignSettings?.DebitId ?? 0;
                var creditAccountId = _branchContext.Configuration?.CashOrderSettings?.InsuranceSettings?.SignSettings?.CreditId ?? 0;
                CreateOrder(insurance, action, OrderType.CashOut, debitAccountId, creditAccountId);

                ModelState.Clear();
                TryValidateModel(action);
                ModelState.Validate();

                insurance.Status = InsuranceStatus.Signed;
                _insuranceRepository.Update(insurance);
                _actionRepository.Insert(action);

                transaction.Commit();
            }

            return(action);
        }
Пример #4
0
        public void Start()
        {
            _player.Hand = new Hand();
            _player.Hand.AddCard(_deck.GetNextCard());
            _player.Hand.AddCard(_deck.GetNextCard());

            _dealer.Hand = new Hand();
            _dealer.Hand.AddCard(_deck.GetNextCard());

            OnRoundStart(new OnRoundStartArgs()
            {
                Player = _player,
                Dealer = _dealer
            });

            if (_player.HasBlackjack)
            {
                if (_dealer.Hand.Value < 10)
                {
                    OnRoundHandResult(new OnRoundHandResultArgs()
                    {
                        Hand   = _player.Hand,
                        Player = _player,
                        Result = HandResult.BlackJack
                    });
                }
            }

            if (_dealer.Hand.Value == 11)
            {
                InsuranceAction insuranceAction = OnRoundInsurance(new OnRoundInsuranceArgs()
                {
                    Player = _player
                });

                if (insuranceAction == InsuranceAction.Yes)
                {
                    OnRoundIfInsurance(new OnRoundIfInsuranceArgs()
                    {
                        Player = _player
                    });

                    //Call DealersHoleCardReveal method...
                    DealerHoleCardReveal();

                    if (_dealer.HasBlackjack)
                    {
                        OnRoundHandResult(new OnRoundHandResultArgs()
                        {
                            Hand   = _player.Hand,
                            Player = _player,
                            Result = HandResult.InsuranceBlackJack
                        });
                    }
                    else
                    {
                        OnRoundHandResult(new OnRoundHandResultArgs()
                        {
                            Hand   = _player.Hand,
                            Player = _player,
                            Result = HandResult.Lose
                        });
                    }
                    return;
                }
            }

            List <Card> cards = _player.Hand.GetCards();

            if (cards[0].Face == cards[1].Face)
            {
                SplitAction splitAction = OnRoundSplit(new OnRoundSplitArgs()
                {
                    Player = _player
                });

                if (splitAction == SplitAction.Yes)
                {
                    OnRoundIfSplit(new OnRoundIfSplitArgs()
                    {
                        Player = _player
                    });

                    _player.SplitHand = _player.Hand.Split();

                    _player.Hand.AddCard(_deck.GetNextCard());
                    OnRoundDeal(new OnRoundDealArgs()
                    {
                        Player = _player,
                        Hand   = _player.Hand
                    });

                    _player.SplitHand.AddCard(_deck.GetNextCard());
                    OnRoundDeal(new OnRoundDealArgs()
                    {
                        Player = _player,
                        Hand   = _player.SplitHand
                    });
                }
            }

            if (_player.IsSplit)
            {
                bool        isFirstHandAce = cards[0].Face == Face.Ace;
                List <Card> splitHandCards = _player.SplitHand.GetCards();
                bool        isSplitHandAce = splitHandCards[0].Face == Face.Ace;

                if (!isFirstHandAce || !isSplitHandAce)
                {
                    ResolvePlayerHand(_player.Hand);
                    ResolvePlayerHand(_player.SplitHand);
                }
            }

            else
            {
                ResolvePlayerHand(_player.Hand);
            }

            if (_player.Hand.IsBust)
            {
                OnRoundBust(new OnRoundBustArgs()
                {
                    Player   = _player,
                    BustHand = _player.Hand
                });
                return;
            }

            if (_player.IsSplit && _player.SplitHand.IsBust)
            {
                OnRoundBust(new OnRoundBustArgs()
                {
                    Player   = _player,
                    BustHand = _player.SplitHand
                });
                return;
            }

            //Copy this holeCardReveal into a method

            DealerHoleCardReveal();

            /*Card holeCard = _deck.GetNextCard();
             * _dealer.Hand.AddCard(holeCard);
             * OnRoundHoleCardReveal(new OnRoundHoleCardRevealArgs()
             * {
             *  Dealer = _dealer,
             *  HoleCard = holeCard
             * });
             */

            if (_dealer.HasBlackjack)
            {
                if (_player.HasBlackjack)
                {
                    OnRoundHandResult(new OnRoundHandResultArgs()
                    {
                        Hand   = _player.Hand,
                        Player = _player,
                        Result = HandResult.Tie
                    });
                }
            }
            else
            {
                while (_dealer.Hand.Value < 17 && _dealer.Hand.Value < _player.Hand.Value)
                {
                    _dealer.Hand.AddCard(_deck.GetNextCard());
                    OnRoundDeal(new OnRoundDealArgs()
                    {
                        Dealer = _dealer,
                        Hand   = _dealer.Hand
                    });
                }

                if (!_dealer.Hand.IsBust)
                {
                    OnRoundStay(new OnRoundStayArgs()
                    {
                        Dealer = _dealer,
                        Hand   = _dealer.Hand
                    });
                }
                else
                {
                    OnRoundBust(new OnRoundBustArgs()
                    {
                        Dealer   = _dealer,
                        BustHand = _dealer.Hand,
                    });
                }
            }

            ResolveRoundResult(_player.Hand);

            if (_player.IsSplit)
            {
                ResolveRoundResult(_player.SplitHand);
            }
        }