public IProcessingData ProcessGarbage(IWaste garbage)
{
var spending = (garbage.Weight * garbage.VolumePerKg) * 0.65;
var energyCost = (garbage.Weight * garbage.VolumePerKg) * 0.13;
return(new ProcessingData(0 - energyCost, 0 - spending));
}
public override IProcessingData ProcessGarbage(IWaste garbage)
{
var energyBalance = (garbage.VolumePerKg * garbage.Weight) * 0.8;
var capitalBalance = 0;
return(new ProcessingData(energyBalance, capitalBalance));
}
protected override double GetCapitalBalance(IWaste garbage)
{
double capitalEarned = 400 * garbage.Weight;
double capitalUsed = 0;
return(capitalEarned - capitalUsed);
}
protected override double GetCapitalBalance(IWaste garbage)
{
double capitalEarned = 0;
double capitalUsed = garbage.GetTotalVolume() * 0.65;
return(capitalEarned - capitalUsed);
}
public void AddWasteToBin(IWasteBin wasteBin, IWaste waste)
{
wasteBin.ListBox.Items.Add(waste.Name + " (" + waste.Volume + ")");
wasteBin.FullVolume += waste.Volume;
wasteBin.ProgressBar.Value += waste.Volume;
wasteBin.OccupancyRate = ((wasteBin.FullVolume * 100) / wasteBin.Capacity);
}
protected override double CalculateEnergyBalance(IWaste garbage)
{
double energyProduced = 0;
double energyUsed = 0.5 * garbage.CalcVolume();
return(energyProduced - energyUsed);
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requirmentsAreSet == true)
{
bool requirmentsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requirmentsAreSatisfied = this.capitalBalance >= minimumCapitalBalance &&
this.energyBalance >= this.minimumEnergyBalance;
}
if (requirmentsAreSatisfied == false)
{
return("Processing Denied!");
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
return($"{(someWaste.Weight):f2} kg of {someWaste.Name} successfully processed!");
}
protected override double CalculateCapitalBalance(IWaste garbage)
{
var capitalEarned = 0;
var capitalUsed = 0.65 * garbage.CalculateWasteTotalVolume();
return(capitalEarned - capitalUsed);
}
public IWaste InstantiateWaste(string[] parameters)
{
var type = parameters[3];
var typeName = type + "Garbage";
var garbageType = Assembly.GetExecutingAssembly().DefinedTypes.FirstOrDefault(t => t.Name == typeName);
if (garbageType == null)
{
throw new ArgumentException("Unsuported garbage type was passed!");
}
ConstructorInfo garbageConstructor = garbageType.GetConstructors()[0];
ParameterInfo[] constructorParams = garbageConstructor.GetParameters();
object[] convertedParameters = new object[constructorParams.Length];
for (int i = 0; i < convertedParameters.Length; i++)
{
Type paramType = constructorParams[i].ParameterType;
if (typeof(IConvertible).IsAssignableFrom(paramType))
{
convertedParameters[i] = Convert.ChangeType(parameters[i], paramType);
}
}
IWaste waste = (IWaste)Activator.CreateInstance(garbageType, convertedParameters);
return(waste);
}
protected override double CalculateEnergyBalance(IWaste garbage)
{
var energyProduced = 0;
var energyUsed = 0.13 * garbage.CalculateWasteTotalVolume();
return(energyProduced - energyUsed);
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requarementsAreSet)
{
bool requarementsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requarementsAreSatisfied = this.capitalBalance >= this.minCapitalBalance &&
this.energyBalance >= this.minEnergyBalance;
}
if (!requarementsAreSatisfied)
{
return(ProcessingDeniedMessage);
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
string formattedMessage = string.Format(ProcessGarbageMessageToFormat, someWaste.Weight.ToString(FloatingPointNumberFormat), someWaste.Name);
return(formattedMessage);
// return $"{someWaste.Weight} kg of {someWaste.Name} successfully processed!";
}
public IProcessingData ProcessGarbage(IWaste garbage)
{
var energyBalance = ((garbage.Weight * garbage.VolumePerKg) / 2) * -1;
var capitalBalance = 400 * garbage.Weight;
return(new ProcessingData(energyBalance, capitalBalance));
}
public IProcessingData ProcessWaste(IWaste garbage)
{
Type type = garbage.GetType(); //take garbage type.
//Take attribute (if there is one) for current strategy.
DisposableAttribute disposalAttribute = (DisposableAttribute)type.GetCustomAttributes(typeof(DisposableAttribute), true).FirstOrDefault();
if (disposalAttribute == null) //If there isn't throw exeption
{
throw new ArgumentException(
"The passed in garbage does not implement a supported Disposable Strategy Attribute.");
}
Type typeOfAttribute = disposalAttribute.GetType(); //take from disposableAttribute his type.
if (!this.StrategyHolder.GetDisposalStrategies.ContainsKey(typeOfAttribute)) //Check if in strategies have key with this current starategy. If there isn't key I make key to have this key in future.
{
Type typeOfCorespondingStrategy = disposalAttribute.CorespondingStrategyType; //Take type of current strategy to be used.
IGarbageDisposalStrategy activatedStrategy = (IGarbageDisposalStrategy)Activator.CreateInstance(typeOfCorespondingStrategy); //Make instance for current strategy.
this.StrategyHolder.AddStrategy(typeOfAttribute, activatedStrategy); // Add key to dict with strategies.
}
IGarbageDisposalStrategy currentStrategy = this.StrategyHolder.GetDisposalStrategies[typeOfAttribute]; //Take maked strategy.
return(currentStrategy.ProcessGarbage(garbage));
}
protected override double CalculateCapitalBalance(IWaste garbage)
{
var capitalEarned = 0;
var capitalUsed = 0;
return(capitalEarned - capitalUsed);
}
public override IProcessingData ProcessGarbage(IWaste garbage)
{
var energyBalance = -((garbage.Weight * garbage.VolumePerKg) * 0.13);
var capitalBalance = -((garbage.Weight * garbage.VolumePerKg) * 0.65);
return(new ProcessingData(energyBalance, capitalBalance));
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
// Bonus task: Check current Management Min Requirements
if (this.hasRequierementsSet)
{
bool meetsRequirements = true;
if (this.garbageTypeRequirement == type)
{
meetsRequirements = this.energyBalance >= this.minEnergyBalanceRequirement &&
this.capitalBalance >= this.minCapitalBalanceRequirement;
}
if (!meetsRequirements)
{
return(ProcessingDeniedMessage);
}
}
IWaste waste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(waste);
this.capitalBalance += processedData.CapitalBalance;
this.energyBalance += processedData.EnergyBalance;
//return $"{waste.Weight:f2} kg of {waste.Name} successfully processed!";
var formattedMessage = string.Format(
ProcessedGarbageMessageToFormat,
waste.Weight.ToString(FloatingPointNumberFormat),
waste.Name);
return(formattedMessage);
}
protected override double CalculateCapitalbalance(IWaste garbage)
{
double capitalEarned = 0;
double capitalUsed = garbage.CalculateWasteTotalVolume() * 0.65;
return(capitalEarned - capitalUsed);
}
protected override double CalculateEnergybalance(IWaste garbage)
{
double energyProduced = 0;
double energyUsed = garbage.CalculateWasteTotalVolume() * 0.13;
return(energyProduced - energyUsed);
}
public IProcessingData ProcessWaste(IWaste garbage)
{
Type type = garbage.GetType();
DisposableAttribute disposalAttribute = (DisposableAttribute)type
.GetCustomAttributes(typeof(DisposableAttribute), true).FirstOrDefault();
if (disposalAttribute == null)
{
throw new ArgumentException(
"The passed in garbage does not implement a supported Disposable Strategy Attribute.");
}
Type typeOfAttribute = disposalAttribute.GetType();
if (!this.StrategyHolder.GetDisposalStrategies.ContainsKey(typeOfAttribute))
{
Type typeOfCorrespondingStrategy = disposalAttribute.CorrespondingStrategyType;
IGarbageDisposalStrategy activatedDisposalStrategy =
(IGarbageDisposalStrategy)Activator.CreateInstance(typeOfCorrespondingStrategy);
this.StrategyHolder.AddStrategy(typeOfAttribute, activatedDisposalStrategy);
}
IGarbageDisposalStrategy currentStrategy = this.StrategyHolder.GetDisposalStrategies[typeOfAttribute];
return(currentStrategy.ProcessGarbage(garbage));
}
public IProcessingData ProcessGarbage(IWaste garbage)
{
var usedEnergy = (garbage.Weight * garbage.VolumePerKg) / 2;
var income = garbage.Weight * 400;
return(new ProcessingData(0 - usedEnergy, income));
}
protected override double CalculateEnergyBalance(IWaste waste)
{
double energyProduced = 0;
double energyUsed = waste.CalculateWasteTotalVolume() * 0.5;
return(energyProduced - energyUsed);
}
protected override double CalculateCapitalBalance(IWaste waste)
{
double capitalEarned = waste.Weight * 400;
double capitalUsed = 0;
return(capitalEarned - capitalUsed);
}
public override IProcessingData ProcessGarbage(IWaste garbage)
{
double energyBalance = -garbage.TotalGarbageVolume * EnergyUsedFactor / 100;
double capitalBalance = -CapitalUsiedFactor * garbage.TotalGarbageVolume / 100;
return(new ProcessingData(energyBalance, capitalBalance));
}
public IProcessingData ProcessGarbage(IWaste garbage)
{
double energyBalance = this.CalculateEnergyBalance(garbage);
double capitalBalance = this.CalculateCapitalBalance(garbage);
return(new ProcessingData(energyBalance, capitalBalance));
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
//Add checks for ChangedMenagementRequirement
if (requirenmentsAreSet)
{
bool requirementsAreSatisfied = true;
if (this.typeOfGarbage == type)
{
requirementsAreSatisfied = this.capitalBalance >= minimumCapitalBalance && this.energyBalance >= minimumEnergyBalance;
}
if (!requirementsAreSatisfied)
{
return(ProcessingDeniedMessage);
}
}
IWaste someWaste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processedData = this.garbageProcessor.ProcessWaste(someWaste);
capitalBalance += processedData.CapitalBalance;
energyBalance += processedData.EnergyBalance;
string formatedMessage = string.Format(ProcessGarbageMessageToFormat, someWaste.Weight.ToString(FloatingPointNumberFormat), someWaste.Name);
return(formatedMessage);
}
public override IProcessingData ProcessGarbage(IWaste garbage)
{
double capitalBalance = 0;
double energyBalance = (garbage.TotalGarbageVolume * EnergyProdusedFactor / 100) - (garbage.TotalGarbageVolume * EnergyUsedFactor / 100);
return(new ProcessingData(energyBalance, capitalBalance));
}
protected override double GetEnergyBalance(IWaste garbage)
{
double energyProduced = 0;
double energyUsed = garbage.GetTotalVolume() * 0.13;
return(energyProduced - energyUsed);
}
public string ProcessGarbage(string name, double weight, double volumePerKg, string type)
{
if (this.requirementsAreSet)
{
bool requirementsAreSatisfied = true;
if (this.requiredGarbageType == type)
{
requirementsAreSatisfied = this.capitalBalance >= this.minCapitalBalance && this.energyBalance >= this.minEnergyBalance;
}
if (!requirementsAreSatisfied)
{
return($"Processing Denied!");
}
}
IWaste waste = this.wasteFactory.Create(name, weight, volumePerKg, type);
IProcessingData processingData = this.garbageProcessor.ProcessWaste(waste);
this.capitalBalance += processingData.CapitalBalance;
this.energyBalance += processingData.EnergyBalance;
return($"{waste.Weight:F2} kg of {waste.Name} successfully processed!");
}
protected override double CalculateCapitalBalance(IWaste garbage)
{
double capitalEarned = garbage.Weight * 400;
//double capitalused = 0;
return(capitalEarned);
}
public override IProcessingData ProcessGarbage(IWaste garbage)
{
var energy = garbage.VolumePerKg * garbage.Weight * (EnergyProducedMultiplier - EnergyUsedMultiplier);
var processingData = ProcessingDataFactory.CreateProcessingData(energy, 0);
return(processingData);
}
public IProcessingData ProcessWaste(IWaste garbage)
{
var type = garbage.GetType();
var disposalAttribute = type.GetCustomAttributes(true).FirstOrDefault() as DisposableAttribute;
IGarbageDisposalStrategy currentStrategy;
if (disposalAttribute == null ||
!this.StrategyHolder.GetDisposalStrategies.TryGetValue(disposalAttribute.GetType(), out currentStrategy))
{
throw new ArgumentException(
"The passed in garbage does not implement a supported Disposable Strategy Attribute.");
}
return currentStrategy.ProcessGarbage(garbage);
}
public IProcessingData ProcessGarbage(IWaste garbage)
{
var totalGarbageVolume = garbage.Weight * garbage.VolumePerKg;
var energyProduced = totalGarbageVolume;
var energyUsed = totalGarbageVolume * 0.2;
var energyBalance = energyProduced - energyUsed;
var capitalBalance = 0;
var processingData = new ProcessingData(energyBalance, capitalBalance);
return processingData;
}
