예제 #1
0
 public void Run(CustomerBet customerBet)
 {
     foreach (var bet in customerBet.Bet)
     {
         if (bet.Win >= 1000)
         {
             bet.BigWin = true;
         }
     }
 }
예제 #2
0
 public void Run(CustomerBet customerBet)
 {
     foreach (var bet in customerBet.Bet)
     {
         if (bet.Stake >= 30 * customerBet.AverageBettingStake)
         {
             bet.HighlyUnusual = true;
         }
     }
 }
        public void ShouldThrowIfCustomerBetIsNull()
        {
            // Arrange
            CustomerBet customerBet = null;

            var target = new DefaultTotalWinningsCalculationStrategy();

            // Act & Assert
            Assert.Throws <ArgumentNullException>(() =>
            {
                var totalWinnings = target.CalculateTotalWinnings(customerBet);
            });
        }
예제 #4
0
        public void Run(CustomerBet customerBet)
        {
            //Get Winning Bet and Total Bet for each customer
            var wins      = customerBet.Bet.Count(x => x.Win > 0);
            var totalBets = customerBet.Bet.Count;

            //Prevent div by zero
            if (wins > 0 && totalBets > 0)
            {
                if ((float)((float)wins / (float)totalBets) * 100 >= 60)
                {
                    customerBet.Bet.ToList().ForEach(y => y.WinningAtUnusalRate = true);
                }
            }
        }
예제 #5
0
        /// <summary>
        /// Reads a CSV file and gets a list of customer bets.
        /// </summary>
        /// <param name="filePath">the file path.</param>
        /// <returns>A list of customer bets.</returns>
        public static List <CustomerBet> GetCustomerBets(string filePath)
        {
            var result = new List <CustomerBet>();

            try
            {
                using (var sr = new StreamReader(filePath))
                {
                    // skip the header
                    sr.ReadLine();

                    string currentLine;
                    // currentLine will be null when the StreamReader reaches the end of file
                    while ((currentLine = sr.ReadLine()) != null)
                    {
                        var splittedStrings = currentLine.Split(',');
                        if (splittedStrings.Count() >= 5)
                        {
                            int     customerId, eventCode, participantCode;
                            decimal stake, win;

                            if (int.TryParse(splittedStrings[0], out customerId) && int.TryParse(splittedStrings[1], out eventCode) &&
                                int.TryParse(splittedStrings[2], out participantCode) && decimal.TryParse(splittedStrings[3], out stake) &&
                                decimal.TryParse(splittedStrings[4], out win))
                            {
                                // if conversion is successful then add the current customer bet
                                var currentCustomerBet = new CustomerBet
                                {
                                    CustomerId      = customerId,
                                    EventCode       = eventCode,
                                    ParticipantCode = participantCode,
                                    StakeAmount     = stake,
                                    WinAmount       = win
                                };

                                result.Add(currentCustomerBet);
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                // ignored
            }

            return(result);
        }
        public decimal CalculateTotalWinnings(CustomerBet customerBet)
        {
            if (customerBet == null)
            {
                throw new ArgumentNullException(nameof(customerBet));
            }

            if (customerBet.Bets == null || !customerBet.Bets.Any())
            {
                return(0);
            }

            var results = customerBet.Bets.Select(bet => bet.Won ? bet.ReturnStake : 0);

            return(results.Sum(r => r));
        }
        public void ShouldReturnZeroEarningsIfNoBet()
        {
            // Arrange
            var customerBet = new CustomerBet
            {
                Bets = new List <Bet>()
            };

            var target = new DefaultTotalWinningsCalculationStrategy();

            // Act
            var totalWinnings = target.CalculateTotalWinnings(customerBet);

            // Assert
            Assert.Equal(0, totalWinnings);
        }
예제 #8
0
        public void Init()
        {
            m_CustomerSettledBets   = new List <CustomerBet>();
            m_CustomerUnSettledBets = new List <CustomerBet>();


            Bet b = new Bet {
                CustomerId = 10, Win = 1100, Stake = 10
            };
            CustomerBet c = new CustomerBet();

            c.Bet = new List <Bet>();
            c.Bet.Add(b);

            m_CustomerSettledBets.Add(c);
        }
예제 #9
0
        public void Init()
        {
            m_CustomerSettledBets   = new List <CustomerBet>();
            m_CustomerUnSettledBets = new List <CustomerBet>();


            //Load AllUnique Customers from the bet history
            var customerIDs = m_repository.GetUniqueCustomerID();

            var settledRiskPolicies = new List <IRiskPolicy> {
                new WinningAtUnusalRatePolicy()
            };
            var undsettledRiskPolicies = new List <IRiskPolicy> {
                new BigWinRiskPolicy(), new HighlyUnusalStakePolicy(), new UnusalStakePolicy()
            };

            foreach (var customerID in customerIDs)
            {
                //Add Settled Bet for the given customer
                var settledBet = new CustomerBet();
                settledBet.Bet = new List <Bet>(m_repository.GetSettledBetForCustomer(customerID));
                settledBet.AverageBettingStake = settledBet.Bet.Average(a => a.Stake);
                m_CustomerSettledBets.Add(settledBet);

                //Run Policy on settled Bet
                settledRiskPolicies.ForEach(policy => policy.Run(settledBet));

                //Add Unsettled Bets for the given Customer
                var unSettledBet = new CustomerBet();
                unSettledBet.Bet = new List <Bet>(m_repository.GetUnSettledBetForCustomer(customerID));
                unSettledBet.AverageBettingStake = settledBet.AverageBettingStake;
                m_CustomerUnSettledBets.Add(unSettledBet);

                //Run policy on unsettled Bet
                undsettledRiskPolicies.ForEach(policy => policy.Run(unSettledBet));

                //Mark all these customer as Risky as they have risky history
                unSettledBet.Bet.ForEach(x => x.WinningAtUnusalRate = settledBet.Bet.First().WinningAtUnusalRate);
            }
        }
예제 #10
0
        public static List <CustomerBet> ParseCustomerBetInCsv(string fileName, bool settled = false)
        {
            var customers = new List <CustomerBet>();

            if (!File.Exists(fileName))
            {
                throw new FileNotFoundException("File not found {0}", fileName);
            }

            var content = File.ReadAllLines(fileName);
            var index   = 0;

            foreach (var line in content)
            {
                if (index == 0)
                {
                    index++;
                    continue;
                }

                var data = line.Split(',');

                var customer = new CustomerBet()
                {
                    CustomerId   = Convert.ToInt32(data[0]),
                    Event        = Convert.ToInt32(data[1]),
                    Participant  = Convert.ToInt32(data[2]),
                    Stake        = Convert.ToDouble(data[3]),
                    Win          = Convert.ToDouble(data[4]),
                    IsSettledBet = settled,
                };

                customers.Add(customer);
            }


            return(customers);
        }
예제 #11
0
        public void ThirtyTimesHigherStake()
        {
            var bets = new List <CustomerBet>();

            bets.Add(new CustomerBet()
            {
                CustomerId  = 1,
                Event       = 1,
                Participant = 6,
                Stake       = 20,
                Win         = 200
            });
            bets.Add(new CustomerBet()
            {
                CustomerId  = 1,
                Event       = 1,
                Participant = 6,
                Stake       = 20,
                Win         = 200
            });


            var customerBettingProfile = new CustomersBettingProfile(bets, new List <CustomerBet>());


            var thirtyX = new CustomerBet()
            {
                CustomerId  = 1,
                Event       = 1,
                Participant = 6,
                Stake       = 600,
                Win         = 0
            };

            customerBettingProfile.EvaluateBet(thirtyX);
            Assert.IsTrue(thirtyX.HighlyUnsualBet);
        }
        public void ShouldCalculateTotalWinningsCorrectly()
        {
            // Arrange
            var customerBet = new CustomerBet
            {
                Bets = new List <Bet>
                {
                    new Bet {
                        ReturnStake = 100, Won = false
                    },
                    new Bet {
                        ReturnStake = 300, Won = true
                    },
                    new Bet {
                        ReturnStake = 200, Won = false
                    },
                    new Bet {
                        ReturnStake = 300, Won = true
                    },
                    new Bet {
                        ReturnStake = 400, Won = true
                    },
                    new Bet {
                        ReturnStake = 100, Won = false
                    }
                }
            };

            var target = new DefaultTotalWinningsCalculationStrategy();

            // Act
            var totalWinnings = target.CalculateTotalWinnings(customerBet);

            // Assert
            Assert.Equal(1000, totalWinnings);
        }
        public async Task CalculateCustomerBetsTest()
        {
            // Arrange
            Mock <IEndpointConnector> mockEndpointConnector = new Mock <IEndpointConnector>();

            mockEndpointConnector.Setup(q => q.GetCustomersAsync()).Returns(Task.FromResult(
                                                                                new Customer[]
            {
                new Customer {
                    Id = 1, Name = "Rob"
                },
                new Customer {
                    Id = 2, Name = "Lachlan"
                },
                new Customer {
                    Id = 3, Name = "Mark"
                }
            }));

            mockEndpointConnector.Setup(q => q.GetBetsAsync()).Returns(Task.FromResult(
                                                                           new Bet[]
            {
                new Bet {
                    CustomerId = 1, HorseId = 11, RaceId = 1, Stake = 100
                },
                new Bet {
                    CustomerId = 1, HorseId = 21, RaceId = 2, Stake = 150
                },
                new Bet {
                    CustomerId = 2, HorseId = 21, RaceId = 1, Stake = 100
                },
                new Bet {
                    CustomerId = 2, HorseId = 22, RaceId = 2, Stake = 150
                },
                new Bet {
                    CustomerId = 3, HorseId = 13, RaceId = 1, Stake = 100
                },
            }));

            CustomerBetsService service = new CustomerBetsService(mockEndpointConnector.Object);

            // Act
            CustomerBet[] result = await service.CalculateCustomerBetsAsync();

            // Assert
            Assert.Equal(3, result.Count());

            CustomerBet customerBet1 = result.SingleOrDefault(q => q.Customer.Id == 1);

            Assert.NotNull(customerBet1);
            Assert.Equal(1, customerBet1.Customer.Id);
            Assert.Equal(2, customerBet1.Bets.Count);
            Assert.True(customerBet1.RiskyIndicator);
            Assert.True(customerBet1.Bets.All(q => q.CustomerId == 1));

            CustomerBet customerBet2 = result.SingleOrDefault(q => q.Customer.Id == 2);

            Assert.NotNull(customerBet2);
            Assert.Equal(2, customerBet2.Customer.Id);
            Assert.Equal(2, customerBet2.Bets.Count);
            Assert.True(customerBet2.RiskyIndicator);
            Assert.True(customerBet2.Bets.All(q => q.CustomerId == 2));

            CustomerBet customerBet3 = result.SingleOrDefault(q => q.Customer.Id == 3);

            Assert.NotNull(customerBet3);
            Assert.Equal(3, customerBet3.Customer.Id);
            Assert.Single(customerBet3.Bets);
            Assert.False(customerBet3.RiskyIndicator);
            Assert.True(customerBet3.Bets.All(q => q.CustomerId == 3));
        }
예제 #14
0
        public async Task GetCustomerBetsTest()
        {
            // Arrange
            Mock <ICustomerBetsService> mockCustomerBetsService = new Mock <ICustomerBetsService>();

            CustomerBet[] customerBets = new CustomerBet[]
            {
                new CustomerBet
                {
                    Customer = new Customer
                    {
                        Id   = 1,
                        Name = "Rob"
                    },
                    Bets = new List <Bet>
                    {
                        new Bet {
                            CustomerId = 1, HorseId = 11, RaceId = 1, Stake = 100
                        },
                        new Bet {
                            CustomerId = 1, HorseId = 21, RaceId = 2, Stake = 150
                        },
                        new Bet {
                            CustomerId = 1, HorseId = 32, RaceId = 3, Stake = 200
                        }
                    }
                },
                new CustomerBet
                {
                    Customer = new Customer
                    {
                        Id   = 2,
                        Name = "Lachlan"
                    },
                    Bets = new List <Bet>
                    {
                        new Bet {
                            CustomerId = 2, HorseId = 21, RaceId = 1, Stake = 100
                        },
                        new Bet {
                            CustomerId = 2, HorseId = 22, RaceId = 2, Stake = 150
                        },
                        new Bet {
                            CustomerId = 2, HorseId = 31, RaceId = 3, Stake = 200
                        },
                        new Bet {
                            CustomerId = 2, HorseId = 55, RaceId = 5, Stake = 300
                        }
                    }
                }
            };

            mockCustomerBetsService.Setup(q => q.CalculateCustomerBetsAsync()).Returns(Task.FromResult(customerBets));

            CustomerBetsController controller = new CustomerBetsController(mockCustomerBetsService.Object);

            // Act
            CustomerBet[] result = await controller.Get();

            // Assert
            string expected = JsonConvert.SerializeObject(customerBets);
            string actual   = JsonConvert.SerializeObject(result);

            Assert.Equal(expected, actual);
        }