public override IUnit CreateUnit(IList <string> arguments)
{
var harvesterType = arguments[0];
var harvesterFullName = harvesterType + Suffix;
var harvesterId = arguments[1];
var harvesterOreOutput = double.Parse(arguments[2]);
var harvesterEnergyRequirement = double.Parse(arguments[3]);
Type type = Assembly.GetExecutingAssembly()
.GetTypes()
.FirstOrDefault(t => t.Name
.Equals(harvesterFullName, StringComparison.OrdinalIgnoreCase));
ConstructorInfo ctor = type.GetConstructors().First();
int numberOfArguments = ctor.GetParameters().Length;
object[] givenArgs = new object[] { harvesterId, harvesterOreOutput, harvesterEnergyRequirement };
if (numberOfArguments > 3)
{
var sonicFactor = int.Parse(arguments[4]);
givenArgs = new object[] { harvesterId, harvesterOreOutput, harvesterEnergyRequirement, sonicFactor };
}
try
{
IHarvester getHarvester = (IHarvester)Activator.CreateInstance(type, givenArgs);
return(getHarvester);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
}
public IHarvester GenerateHarvester(IList <string> args)
{
string type = args[0];
var id = int.Parse(args[1]);
var oreOutput = double.Parse(args[2]);
var energyReq = double.Parse(args[3]);
Type harvesterType = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(t => t.Name == type + "Harvester");
if (harvesterType == null)
{
throw new ArgumentException("No Provider Found!");
}
if (!typeof(IHarvester).IsAssignableFrom(harvesterType))
{
throw new ArgumentException("The type is not Assignate to IProvider!");
}
var ctors = harvesterType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
IHarvester harvester = (IHarvester)ctors[0].Invoke(new object[] { id, oreOutput, energyReq });
return(harvester);
}
public override string Execute()
{
StringBuilder result = new StringBuilder();
int id = int.Parse(this.Arguments[0]);
IProvider provider = (IProvider)((ProviderController)this.providerController).Entities.FirstOrDefault(x => x.ID == id);
IHarvester harvester = (IHarvester)((HarvesterController)this.harvesterController).Entities.FirstOrDefault(x => x.ID == id);
if (provider == null && harvester == null)
{
result.AppendLine(string.Format(Constants.InspectNoSuchEntity, id));
}
else if (provider == null)
{
result.AppendLine(harvester.ToString());
}
else if (harvester == null)
{
result.AppendLine(provider.ToString());
}
return(result.ToString().Trim());
}
public string Check(List <string> arguments)
{
StringBuilder sb = new StringBuilder();
string id = arguments[0];
IHarvester harvester = harvesters.FirstOrDefault(h => h.Id == id);
if (harvester != null)
{
sb.AppendLine($"{harvester.GetType().Name.Replace("Harvester", "")} Harvester - {id}")
.AppendLine($"Ore Output: {harvester.OreOutput}")
.AppendLine($"Energy Requirement: {harvester.EnergyRequirement}");
}
IProvider provider = providers.FirstOrDefault(p => p.Id == id);
if (provider != null)
{
sb.AppendLine($"{provider.GetType().Name.Replace("Provider", "")} Provider - {id}")
.AppendLine($"Energy Output: {provider.EnergyOutput}");
}
if (harvester == null && provider == null)
{
sb.AppendLine($"No element found with id - {id}");
}
return(sb.ToString().Trim());
}
public float Harvest(IHarvester harvester)
{
// Make sure nobody else is harvesting this corpse
if (currentHarvester != null && currentHarvester != harvester)
{
return(0f);
}
// Mark this corpse as being harvested
currentHarvester = harvester;
float drained = drainRate * Time.deltaTime;
if (bloodCapacity > drained)
{
bloodCapacity -= drained;
bloodpool.localScale = new Vector3(bloodCapacity / maxBloodCapacity, bloodCapacity / maxBloodCapacity, 1);
}
else
{
drained = bloodCapacity;
bloodCapacity = 0;
}
return(drained);
}
public void SetUp()
{
mocker = new MockRepository();
service = mocker.PartialMock<HarvestService>();
harvestor = mocker.CreateMock<IHarvester>();
scripter = mocker.CreateMock<ISqlScripter>();
}
public string Check(List <string> arguments)
{
string id = arguments[0];
if (providers.ContainsKey(id))
{
IProvider provider = providers[id];
string type = provider.GetType().Name.Replace("Provider", "");
return($"{type} Provider - {id}\r\n" +
$"Energy Output: {provider.EnergyOutput}");
}
else if (harvesters.ContainsKey(id))
{
IHarvester harvester = harvesters[id];
string type = harvester.GetType().Name.Replace("Harvester", "");
return($"{type} Harvester - {id}\r\n" +
$"Ore Output: {harvester.OreOutput}\r\n" +
$"Energy Requirement: {harvester.EnergyRequirement}");
}
else
{
return($"No element found with id - {id}");
}
}
} // HmrcRtiTaxMonthConversion
private VatReturnRawData[] HmrcVatReturnConversion(IHarvester oHarvester)
{
var oVatRecords = new List <VatReturnRawData>();
foreach (KeyValuePair <string, ISeeds> pair in ((Ezbob.HmrcHarvester.Harvester)oHarvester).Hopper.Seeds[DataType.VatReturn])
{
var oData = (VatReturnSeeds)pair.Value;
var oEntry = new VatReturnRawData {
BusinessAddress = oData.BusinessAddress,
BusinessName = oData.BusinessName,
DateDue = oData.DateDue,
DateFrom = oData.DateFrom,
DateTo = oData.DateTo,
Period = oData.Period,
RegistrationNo = oData.RegistrationNo,
};
foreach (KeyValuePair <string, Ezbob.HmrcHarvester.Coin> oBoxData in oData.ReturnDetails)
{
oEntry.Data[oBoxData.Key] = new Ezbob.Backend.Models.Coin {
Amount = oBoxData.Value.Amount,
CurrencyCode = oBoxData.Value.CurrencyCode,
};
} // for each box
oVatRecords.Add(oEntry);
} // for each file
return(oVatRecords.ToArray());
} // HmrcVatReturnConversion
public IHarvester CreateHarvester(List <string> args)
{
string typeString = args[0] + "Harvester";
string id = args[1];
double oreOutput = double.Parse(args[2]);
double energyRequirement = double.Parse(args[3]);
try
{
if (args.Count == 5)
{
int sonicFactor = int.Parse(args[4]);
Type sonicType = Assembly.GetCallingAssembly().GetTypes().Single(t => t.Name == typeString);
IHarvester sonicHarvester = (IHarvester)Activator.CreateInstance(sonicType, new object[] { id, oreOutput, energyRequirement, sonicFactor });
return(sonicHarvester);
}
Type type = Assembly.GetCallingAssembly().GetTypes().Single(t => t.Name == typeString);
IHarvester hammerHarvester = (IHarvester)Activator.CreateInstance(type, new object[] { id, oreOutput, energyRequirement });
return(hammerHarvester);
}
catch (ArgumentException ae)
{
throw new TargetInvocationException(ae.Message, ae);
}
}
public void StopHarvest(IHarvester harvester)
{
if (harvester == currentHarvester)
{
currentHarvester = null;
}
}
public IHarvester GenerateHarvester(IList <string> args)
{
string type = args[0];
int id = int.Parse(args[1]);
double oreOutput = double.Parse(args[2]);
double energyReq = double.Parse(args[3]);
Type harvesterType = Assembly.GetCallingAssembly()
.GetTypes()
.SingleOrDefault(t => t.Name == type + Suffix);
if (harvesterType == null || !typeof(IEntity).IsAssignableFrom(harvesterType))
{
throw new ArgumentException();
}
object[] ctorArgs = new object[]
{
id, oreOutput, energyReq
};
IHarvester harvester = (IHarvester)Activator.CreateInstance(harvesterType, ctorArgs);
return(harvester);
}
public string RegisterHarvester(List <string> arguments)
{
var type = arguments[0];
var id = arguments[1];
var oreOutput = double.Parse(arguments[2]);
var energyRequirement = double.Parse(arguments[3]);
var sonicFactor = 0;
if (arguments.Count == 5)
{
sonicFactor = int.Parse(arguments[4]);
}
try
{
IHarvester harvester = this.harvesterFactory.GenerateHarvester(arguments);
this.harvestersById.Add(id, harvester);
}
catch (ArgumentException e)
{
return(e.Message);
}
return($"Successfully registered {type} Harvester - {id}");
}
/// <summary>
/// Creates a new donut runner
/// </summary>
/// <typeparam name="TDonut">The type of donut to run</typeparam>
/// <typeparam name="TContext">The donut's type of context</typeparam>
/// <typeparam name="TData">The type of data that will be consumed</typeparam>
/// <param name="harvester">The harvester that will read the data</param>
/// <param name="db">Db config</param>
/// <param name="featuresCollection">The targeted features collection that would be outputed to.</param>
/// <returns></returns>
public static IDonutRunner <TDonut, TData> Create <TDonut, TContext, TData>(
IHarvester <IntegratedDocument> harvester,
IDatabaseConfiguration db,
string featuresCollection)
where TDonut : Donutfile <TContext, TData>
where TContext : DonutContext
where TData : class, IIntegratedDocument
{
var builderType = typeof(DonutRunner <, ,>).MakeGenericType(new Type[] { typeof(TDonut), typeof(TContext), typeof(TData) });
//DataIntegration integration, RedisCacher cacher, IServiceProvider serviceProvider
var builderCtor = builderType.GetConstructor(new Type[]
{
typeof(Harvester <TData>),
typeof(IDatabaseConfiguration),
typeof(string)
});
if (builderCtor == null)
{
throw new Exception("DonutBuilder<> has invalid ctor parameters.");
}
var builder = Activator.CreateInstance(builderType, harvester, db, featuresCollection) as IDonutRunner <TDonut, TData>;
return(builder);
}
static void Main(string[] args)
{
Type type = Type.GetType("Harvester.Google.GoogleHarvester");
IHarvester harvester = (IHarvester)Activator.CreateInstance(type);
Console.WriteLine(harvester.Blah);
Console.Read();
}
public string AddHarvester(string id, IHarvester unit)
{
if (!(this.Harvesters.ContainsKey(id)))
{
this.Harvesters.Add(id, unit);
}
return("Successfully registered {0} Harvester - {1}");
}
public IHarvester CreateHarvester(string id, double oreOutput, double energyRequirement)
{
var type = Type.GetType(id);
IHarvester createInstance = (IHarvester)Activator.CreateInstance(type, oreOutput, energyRequirement);
return(createInstance);
}
public string Register(IList <string> args)
{
IHarvester harvester = this.harvesterFactory.GenerateHarvester(args);
this.harvesters.Add(harvester);
return(string.Format(OutputMessages.SuccessfullRegistration,
harvester.GetType().Name));
}
public string Register(IList <string> args)
{
IHarvester harverster = this.factory.GenerateHarvester(args);
this.hervesters.Add(harverster);
return(String.Format(Constants.SuccessfullRegistration,
harverster.GetType().Name));
}
private static async Task RunHarvester(IHarvester harvester)
{
var name = HarvesterNameAttribute.GetName(harvester.GetType());
using (var writer = XmlWriter.Create($"{name}.xml", _xmlWriterSettings))
{
await harvester.Harvest(writer, new DiskArtifactDirectory(name), _httpClient);
}
}
private void OnTriggerEnter2D(Collider2D collision)
{
IHarvester newHarvester = collision.gameObject.GetComponent <IHarvester>();
if (newHarvester != null)
{
newHarvester.AddHarvestTarget(this);
}
}
private void OnTriggerExit2D(Collider2D collision)
{
IHarvester oldHarvester = collision.gameObject.GetComponent <IHarvester>();
if (oldHarvester != null)
{
oldHarvester.RemoveHarvestTarget(this);
}
}
public string Register(IList <string> args)
{
IHarvester harvester = factory.GenerateHarvester(args);
this.harvesters.Add(harvester);
string result = string.Format(Constants.SuccessfullyRegisterdHarvester, harvester.GetType().Name, harvester.ID);
return(result);
}
public string Register(IList <string> arguments)
{
var type = arguments[0];
IHarvester harvester = harvesterFactory.GenerateHarvester(arguments);
this.harvesters.Add(harvester);
return(string.Format(Constants.SuccessfullRegistration,
type + "Harvester"));
}
public IHarvester GenerateHarvester(IList <string> args)
{
string type = args[0];
var id = int.Parse(args[1]);
var oreOutput = double.Parse(args[2]);
var energyReq = double.Parse(args[3]);
Type @class = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(t => t.Name == type + "Harvester");
IHarvester harvester = (IHarvester)Activator.CreateInstance(@class, id, oreOutput, energyReq);
return(harvester);
}
public IHarvester GenerateHarvester(IList <string> args)
{
int id = int.Parse(args[1]);
string type = args[0];
double oreOutput = double.Parse(args[2]);
double energyRequirement = double.Parse(args[3]);
Type clazz = Assembly.GetExecutingAssembly().GetTypes().FirstOrDefault(t => t.Name == type + "Harvester");
var ctors = clazz.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
IHarvester harvester = (IHarvester)ctors[0].Invoke(new object[] { id, oreOutput, energyRequirement });
return(harvester);
}
public IHarvester GenerateHarvester(IList <string> args)
{
string type = args[0];
int id = int.Parse(args[1]);
double oreOutput = double.Parse(args[2]);
double energyRequirement = double.Parse(args[3]);
Assembly assembly = Assembly.GetCallingAssembly();
Type classType = assembly.GetTypes().FirstOrDefault(t => t.Name == type + Suffix);
IHarvester harvester = (IHarvester)Activator.CreateInstance(classType, id, oreOutput, energyRequirement);
return(harvester);
}
public string RegisterHarvester(List <string> arguments)
{
try
{
IHarvester harvester = harvesterFactory.CreateHarvester(arguments);
harvesters.Add(harvester);
}
catch (TargetInvocationException tie)
{
return(string.Format("Harvester is not registered, because of it's {0}", tie.InnerException.Message));
}
return($"Successfully registered {arguments[0]} Harvester - {arguments[1]}");
}
public IHarvester GenerateHarvester(IList <string> args)
{
var typeAsString = args[0];
var id = int.Parse(args[1]);
var oreOutput = double.Parse(args[2]);
var energyReq = double.Parse(args[3]);
var type = Assembly.GetExecutingAssembly()
.GetTypes()
.FirstOrDefault(t => t.Name.Equals(typeAsString + baseClassName));
var constructor = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
IHarvester harvester = (IHarvester)constructor[0].Invoke(new object[] { id, oreOutput, energyReq });
return(harvester);
}
public override string Execute()
{
var id = Arguments[1];
var message = string.Empty;
var harvesterType = Arguments[0];
try
{
IHarvester harvester = (IHarvester)this.Factory.CreateUnit(this.Arguments);
string m = this.Repository.AddHarvester(id, harvester);
message = String.Format(m, harvesterType, harvester.Id);
}
catch (ArgumentException ex)
{
message = ex.Message;
}
return(message);
}
public IHarvester GenerateHarvester(IList <string> args)
{
string type = args[1];
var id = int.Parse(args[2]);
var oreOutput = double.Parse(args[3]);
var energyReq = double.Parse(args[4]);
Type harvesterType = Assembly
.GetExecutingAssembly()
.GetTypes()
.FirstOrDefault(t => t.Name == type + "Harvester");
ConstructorInfo[] ctors = harvesterType.GetConstructors(BindingFlags.Public | BindingFlags.Instance);
IHarvester harvester = (IHarvester)ctors[0].Invoke(new object[] { id, oreOutput, energyReq });
return(harvester);
}
public Engine(IKeeper keeper, IHarvester harvester, ASafeLog log)
{
Log = log.Safe();
Now = DateTime.UtcNow;
Keeper = keeper;
Harvester = harvester;
if (Keeper == null)
{
throw new NoConnectionEngineAlert(Log);
}
if (Harvester == null)
{
throw new NoHarvesterEngineAlert(Log);
}
} // constructor
