public BuildingUpgradeHandlerResponse CalculateBuildQueue(BuildingUpgradeHandlerRequest request)
{
throw new NotImplementedException();
}
private void CalculateBuildQueue(HandlerEntities.City mappedCity, City city)
{
var calcRequest = new BuildingUpgradeHandlerRequest
{
City = mappedCity,
CalculateBuidingUpgradeStatistics = true,
ReturnInventory = true,
ReturnFaciltiyAssignment = false
};
var calculateResults = _buildingUpgradeHandler.CalculateBuildQueue(calcRequest);
city.RequiredProducts = calculateResults.RequiredProductQueue.Select(Mapper.Map<Product>).ToArray();
city.RequiredProductsInCityStorage =
calculateResults.RequiredProductsInCityStorageQueue.Select(Mapper.Map<Product>).ToArray();
city.TotalProducts = calculateResults.TotalProductQueue.Select(Mapper.Map<Product>).ToArray();
city.AvailableStorage = calculateResults.AvailableStorage.Select(Mapper.Map<Product>).ToArray();
}
public City Get(SupplyChainRequest request)
{
var logStart = LogHelper.StartLog("Begin Supply Chain Get", Logger);
//Get the current city from the database.
var currentCity = ConvertRequestToHandlerCity(request);
var prodTypes = _dbContext.ProductTypes
.AsQueryable()
.Include(x=>x.RequiredProducts)
.Include(y=>y.ManufacturerType.ProductTypes)
.ToArray();
var calcRequest = new BuildingUpgradeHandlerRequest
{
ReturnInventory = true,
ReturnFaciltiyAssignment = request.ReturnFacilityAssignment,
City = Mapper.Map<Handler.Entities.City>(currentCity),
ProductTypes = prodTypes
};
var strgResults = CalculateNewCityStorageAmounts(request, calcRequest, prodTypes);
var ret = _buldingUpgradeHandler.CalculateBuildQueue(calcRequest);
var city = new City
{
CurrentCityStorage = Mapper.Map<CityStorage>(strgResults.CityStorage),
RequiredProducts = ret.RequiredProductQueue.Select(Mapper.Map<Product>).ToArray(),
RequiredProductsInCityStorage = ret.RequiredProductsInCityStorageQueue.Select(Mapper.Map<Product>).ToArray(),
TotalProducts = ret.TotalProductQueue.Select(Mapper.Map<Product>).ToArray(),
AvailableStorage = ret.AvailableStorage.Select(Mapper.Map<Product>).ToArray(),
BuildingUpgrades = ret.OrderedUpgrades.Select(Mapper.Map<BuildingUpgrade>).ToArray().OrderBy(x=>x.Name).ToArray()
};
UpdateBuildingUpgradeUiInfo(prodTypes, city);
return LogHelper.EndLog(logStart, city);
}
private CalculateStorageResponse CalculateNewCityStorageAmounts(SupplyChainRequest request, BuildingUpgradeHandlerRequest calcRequest, ProductType[] productTypes)
{
var strgResults = new CalculateStorageResponse
{
CityStorage = calcRequest.City.CurrentCityStorage
};
//If we have products queued for production then calculate the new city storage.
if (request.RequiredProductUpdates == null) return strgResults;
var calculateStorageRequest = new CalculateStorageRequest
{
ProductTypes = productTypes,
NewProductQuantities = request.RequiredProductUpdates.Select(Mapper.Map<Handler.Entities.Product>).ToArray(),
CityStorage = calcRequest.City.CurrentCityStorage
};
return _cityStorageCalculator.CalculateNewStorageAmounts(calculateStorageRequest);
}
public BuildingUpgradeHandlerResponse CalculateBuildQueue(BuildingUpgradeHandlerRequest request)
{
//Early out if we don't have required data.
if (request == null || request.City == null)
return new BuildingUpgradeHandlerResponse
{
RequiredProductQueue = new Product[]{},
CityStorage = request != null && request.City != null ? request.City.CurrentCityStorage : new CityStorage(),
PendingInventory = new Product[0],
TotalProductQueue = new Product[0],
RequiredProductsInCityStorageQueue = new Product[0],
OrderedUpgrades = new BuildingUpgrade[0],
AvailableStorage = new Product[0]
};
_productTypes = GetProductTypes(request).Select(Mapper.Map<ProductType>).ToArray();
request.City.CurrentCityStorage.CurrentInventory = PopulateRequiredProducts(_productTypes, request.City.CurrentCityStorage.CurrentInventory);
var handlerResponse = new BuildingUpgradeHandlerResponse
{
CityStorage = request.City.CurrentCityStorage,
//Get property upgrade orders in the order requested (currently only sorted by shortest to longest duration)
// should be able to sort by priority etc...
OrderedUpgrades = ReorderUpgradesByDuration(request)
};
//Get the list of inventory items from the orders including prerequisites to be queued.
if (request.ReturnInventory)
{
var buildingUpgradeProductConsolidatorResponse = _buildingUpgradeProductConsolidator.GetConsolidatedProductQueue(new BuildingUpgradeProductConsoldatorRequest
{
BuildingUpgrades = handlerResponse.OrderedUpgrades,
CityStorage = handlerResponse.CityStorage,
ProductTypes = _productTypes
});
handlerResponse.RequiredProductQueue = PopulateRequiredProducts(_productTypes, buildingUpgradeProductConsolidatorResponse.ConsolidatedRequiredProductQueue.ToArray());
handlerResponse.TotalProductQueue = PopulateRequiredProducts(_productTypes, buildingUpgradeProductConsolidatorResponse.ConsolidatedTotalProductQueue.ToArray());
handlerResponse.AvailableStorage = PopulateRequiredProducts(_productTypes, buildingUpgradeProductConsolidatorResponse.AvailableStorage.ToArray());
handlerResponse.RequiredProductsInCityStorageQueue = PopulateRequiredProducts(_productTypes, buildingUpgradeProductConsolidatorResponse.ConsolidatedRequiredProductsInStorage.ToArray());
}
else
{
handlerResponse.RequiredProductQueue = new Product[0];
handlerResponse.TotalProductQueue = new Product[0];
handlerResponse.AvailableStorage = new Product[0];
handlerResponse.RequiredProductsInCityStorageQueue = new Product[0];
}
if (request.CalculateBuidingUpgradeStatistics)
{
var statisticsRequest = new BuildingUpgradeStatisticsCalculatorRequest();
_buildingUpgradeStatisticsCalculator.CalculateStatistics(statisticsRequest);
}
//now create manufacturing order to be placed.
// NOTE only creates one order where it maxes out supply chain limits.
// List<LegacyProduct> pendingInventory;
// var manufactingOrder = CreateManufacturingOrder(request, orderedInventoryQueue, out pendingInventory);
return handlerResponse;
}
/// <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;
}
private Domain.ProductType[] GetProductTypes(BuildingUpgradeHandlerRequest request)
{
if (request.ProductTypes != null)
return request.ProductTypes;
return _propertyUpgradeUoW.ProductTypeRepository.Context.ProductTypes.AsQueryable()
.Include(x => x.RequiredProducts).ToArray();
}