public void Scenario1()
 {
     var uow = new Mock<IPropertyUpgradeUoW>();
     var calculator = new BuildingUpgradeDurationCalculator(uow.Object);
     var request = new BuildingUpgradeDurationCalculatorRequest
     {
         BuildingUpgrade = new BuildingUpgrade
         {
             Products = new List<Product>
             {
                 new Product
                 {
                     ProductTypeId = 4,
                     Quantity = 1
                 }
             }
         },
         CityStorage = CityStorage(),
         ProductTypes = ProductTypes()
     };
     var ret = calculator.CalculateUpgradeTime(request);
     Assert.IsNotNull(ret);
     request.BuildingUpgrade.TotalUpgradeTime.ShouldEqual(10);
     request.BuildingUpgrade.RemainingUpgradeTime.ShouldEqual(10);
     request.BuildingUpgrade.Products.First().TotalDuration.ShouldEqual(10);
     request.BuildingUpgrade.Products.First().RemainingDuration.ShouldEqual(10);
 }
        public BuildingUpgradeDurationCalculatorResponse CalculateUpgradeTimes(
            BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
        {
            //            if (InValidBuildingUpgrades(upgradeDurationCalculatorRequest))
            //                return new BuildingUpgradeDurationCalculatorResponse();

            InitializeProductTypes(upgradeDurationCalculatorRequest);

            //first calculate the total times. This also adds child required products
            var totalUpgradeTime = GetTotalUpgradeTime(upgradeDurationCalculatorRequest);
            //now calculate the remaining time based on city storage. This will update the already added child required products
            var remainingUpgradeTime = GetRemainingUpgradeTime(upgradeDurationCalculatorRequest);

            //update the building upgrade totals
            upgradeDurationCalculatorRequest.BuildingUpgrade.TotalUpgradeTime = totalUpgradeTime;
            upgradeDurationCalculatorRequest.BuildingUpgrade.RemainingUpgradeTime = remainingUpgradeTime;

            return new BuildingUpgradeDurationCalculatorResponse
            {
                TotalUpgradeTime = totalUpgradeTime,
                RemainingUpgradeTime = remainingUpgradeTime
            };
            //                propUpgrade.TotalUpgradeTime = propUpgradeDurationCalcResponse.TotalUpgradeTime;
            //                propUpgrade.RemainingUpgradeTime = propUpgradeDurationCalcResponse.RemainingUpgradeTime;
            //                propUpgrade.ProductsInStorage = GetProductsAlreadyInStorage(propUpgrade, request.City.CurrentCityStorage.CurrentInventory);
        }
 public BuildingUpgradeDurationCalculatorResponse CalculateUpgradeTime(
     BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
 {
     return new BuildingUpgradeDurationCalculatorResponse
     {
         TotalUpgradeTime = 50
     };
 }
        public BuildingUpgradeDurationCalculatorResponse CalculateRemainingTime(
            BuildingUpgradeDurationCalculatorRequest durationRequest)
        {
            if (InValidBuildingUpgrades(durationRequest))
                return new BuildingUpgradeDurationCalculatorResponse();
            InitializeProductTypes(durationRequest);

            CalculateUpgradeTime(durationRequest);
            var remainingUpgradeTime = GetRemainingUpgradeTime(durationRequest);

            return new BuildingUpgradeDurationCalculatorResponse
            {
                RemainingUpgradeTime = remainingUpgradeTime
            };
        }
        public BuildingUpgradeDurationCalculatorResponse CalculateUpgradeTime(BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
        {
            if (InValidBuildingUpgrades(upgradeDurationCalculatorRequest))
                return new BuildingUpgradeDurationCalculatorResponse();

            InitializeProductTypes(upgradeDurationCalculatorRequest);

            //first calculate the total times. This also adds child required products
            var totalUpgradeTime = GetTotalUpgradeTime(upgradeDurationCalculatorRequest);
            //now calculate the remaining time based on city storage. This will update the already added child required products
            var remainingUpgradeTime = GetRemainingUpgradeTime(upgradeDurationCalculatorRequest);

            //update the building upgrade totals
            upgradeDurationCalculatorRequest.BuildingUpgrade.TotalUpgradeTime = totalUpgradeTime;
            upgradeDurationCalculatorRequest.BuildingUpgrade.RemainingUpgradeTime = remainingUpgradeTime;

            return new BuildingUpgradeDurationCalculatorResponse
            {
                TotalUpgradeTime = totalUpgradeTime,
                RemainingUpgradeTime = remainingUpgradeTime
            };
        }
        public BuildingUpgradeStatisticsCalculatorResponse CalculateStatistics(
            BuildingUpgradeStatisticsCalculatorRequest statisticsRequest)
        {
            if (statisticsRequest.BuildingUpgrades == null)
                return new BuildingUpgradeStatisticsCalculatorResponse();
            foreach (var upgrade in statisticsRequest.BuildingUpgrades)
            {
                var durationRequest = new BuildingUpgradeDurationCalculatorRequest
                {
                    BuildingUpgrade = upgrade,
                    ProductTypes = statisticsRequest.ProductTypes,
                    CityStorage = statisticsRequest.CityStorage.Clone(),
                    DecrementPassedStorage = true
                };
                upgrade.RemainingUpgradeTime = _buildingUpgradeCalculator.CalculateRemainingTime(durationRequest).RemainingUpgradeTime;
            }
            //need to go through each building upgrade and
            //  calculate time left.
            //  update product list with quantity left after storage

            return new BuildingUpgradeStatisticsCalculatorResponse();
        }
 private void InitializeProductTypes(BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
 {
     if (upgradeDurationCalculatorRequest.ProductTypes == null)
         upgradeDurationCalculatorRequest.ProductTypes =
             _propertyUpgradeUoW.ProductTypeRepository.Get().Select(Mapper.Map<ProductType>).ToArray();
     _productTypes = upgradeDurationCalculatorRequest.ProductTypes;
 }
 /// <summary>
 /// - Calculates the total upgrade time for the building upgrade and 
 /// - Adds the required sub products to the required products and updates their product total times 
 /// </summary>
 /// <param name="upgradeDurationCalculatorRequest"></param>
 /// <returns></returns>
 private int GetTotalUpgradeTime(BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
 {
     var retTime = 0;
     var addedTypes = new List<int>();
     foreach (var item in upgradeDurationCalculatorRequest.BuildingUpgrade.Products)
     {
         var productTotalDuration = CalculateInventoryItemDuration(item, addedTypes, true, null);
         item.TotalDuration = productTotalDuration;
         retTime += productTotalDuration;
     }
     return retTime;
 }
 private int GetRemainingUpgradeTime(BuildingUpgradeDurationCalculatorRequest durationRequest)
 {
     ICollection<int> typesAlreadyAdded = new List<int>();
     var sum = 0;
     foreach (var item in durationRequest.BuildingUpgrade.Products)
     {
         //if decrement passed storage is true then we want to modify the passed city storage quantities rather than
         //  cloning it.
         var cityStorage = durationRequest.DecrementPassedStorage ? durationRequest.CityStorage : durationRequest.CityStorage.Clone();
         var productRemainingDuration = CalculateInventoryItemDuration(item, typesAlreadyAdded, true, cityStorage);
         item.RemainingDuration = productRemainingDuration;
         sum += productRemainingDuration;
     }
     return sum;
 }
 private static bool InValidBuildingUpgrades(BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
 {
     return upgradeDurationCalculatorRequest == null ||
            upgradeDurationCalculatorRequest.BuildingUpgrade == null ||
            upgradeDurationCalculatorRequest.BuildingUpgrade.Products == null;
 }
 public void Scenario5()
 {
     var uow = new Mock<IPropertyUpgradeUoW>();
     var calculator = new BuildingUpgradeDurationCalculator(uow.Object);
     var cityStorage = CityStorage();
     var prod = cityStorage.CurrentInventory.First(x => x.ProductTypeId == 4);
     prod.Quantity = 1;
     var request = new BuildingUpgradeDurationCalculatorRequest
     {
         BuildingUpgrade = new BuildingUpgrade
         {
             Products = new List<Product>
             {
                 new Product
                 {
                     ProductTypeId = 3,
                     Quantity = 1
                 }
             }
         },
         CityStorage = cityStorage,
         ProductTypes = ProductTypes()
     };
     var ret = calculator.CalculateUpgradeTime(request);
     Assert.IsNotNull(ret);
     ret.TotalUpgradeTime.ShouldEqual(20);
     ret.RemainingUpgradeTime.ShouldEqual(10);
 }
        public void Scenario3()
        {
            var uow = new Mock<IPropertyUpgradeUoW>();
            var calculator = new BuildingUpgradeDurationCalculator(uow.Object);
            var request = new BuildingUpgradeDurationCalculatorRequest
            {
                BuildingUpgrade = new BuildingUpgrade
                {
                    Products = new List<Product>
                    {
                        new Product
                        {
                            ProductTypeId = 2,
                            Quantity = 1
                        }
                    }
                },
                CityStorage = CityStorage(),
                ProductTypes = ProductTypes()
            };
            var ret = calculator.CalculateUpgradeTime(request);
            Assert.IsNotNull(ret);
            ret.TotalUpgradeTime.ShouldEqual(50);
            ret.RemainingUpgradeTime.ShouldEqual(50);

            request.BuildingUpgrade.Products.First().TotalDuration.ShouldEqual(50);
            request.BuildingUpgrade.Products.First().RemainingDuration.ShouldEqual(50);

            request.BuildingUpgrade.Products.First().RequiredProducts.FirstOrDefault().ShouldNotBeNull();
            request.BuildingUpgrade.Products.First().RequiredProducts.Count().ShouldEqual(2);
            request.BuildingUpgrade.Products.First().RequiredProducts.ToArray()[0].TotalDuration.ShouldEqual(20);
            request.BuildingUpgrade.Products.First().RequiredProducts.ToArray()[0].RemainingDuration.ShouldEqual(20);

            request.BuildingUpgrade.Products.First().RequiredProducts.ToArray()[1].TotalDuration.ShouldEqual(20);
            request.BuildingUpgrade.Products.First().RequiredProducts.ToArray()[1].RemainingDuration.ShouldEqual(20);
        }
 public BuildingUpgradeDurationCalculatorResponse CalculateUpgradeTimes(
     BuildingUpgradeDurationCalculatorRequest upgradeDurationCalculatorRequest)
 {
     throw new System.NotImplementedException();
 }
 public BuildingUpgradeDurationCalculatorResponse CalculateRemainingTime(
     BuildingUpgradeDurationCalculatorRequest durationRequest)
 {
     throw new System.NotImplementedException();
 }
Esempio n. 15
0
        /// <summary>
        /// Get Upgrade Orders ordered by the order that takes the least time to process.
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        private BuildingUpgrade[] ReorderUpgradesByDuration(BuildingUpgradeHandlerRequest request)
        {
            var requestPropUpgrades = request.City.BuildingUpgrades;
            //                            var upgradeDurationCalculatorRequest = new BuildingUpgradeDurationCalculatorRequest
            //                            {
            //                                BuildingUpgrades = requestPropUpgrades,
            //                                ProductTypes = _productTypes,
            //                                CityStorage = request.City.CurrentCityStorage
            //                            };
            //            var propUpgradeDurationCalcResponse = _buildingUpgradeDurationCalculator.CalculateUpgradeTimes(upgradeDurationCalculatorRequest);
            foreach (var propUpgrade in requestPropUpgrades)
            {
                var upgradeDurationCalculatorRequest = new BuildingUpgradeDurationCalculatorRequest
                {
                    BuildingUpgrade = propUpgrade,
                    ProductTypes = _productTypes,
                    CityStorage = request.City.CurrentCityStorage
                };
                var propUpgradeDurationCalcResponse = _buildingUpgradeDurationCalculator.CalculateUpgradeTime(upgradeDurationCalculatorRequest);
                propUpgrade.TotalUpgradeTime = propUpgradeDurationCalcResponse.TotalUpgradeTime;
                propUpgrade.RemainingUpgradeTime = propUpgradeDurationCalcResponse.RemainingUpgradeTime;
                propUpgrade.ProductsInStorage = GetProductsAlreadyInStorage(propUpgrade, request.City.CurrentCityStorage.CurrentInventory);
            }

            var orderedPropUpgrades = requestPropUpgrades.OrderBy(x => x.TotalUpgradeTime).ToArray();
            return orderedPropUpgrades;
        }