public async Task Process(BatchConfig batch, BatchOption option)
{
foreach (var command in batch.Commands)
{
if (command is TargetCommand targetCommand)
{
if (option == BatchOption.ApplyCurrentState)
{
await ITargetProcessor.ApplyCurrentStateAsync(targetCommand);
}
else if (option == BatchOption.ResetState)
{
await ITargetProcessor.ResetState(targetCommand);
}
else
{
await ITargetProcessor.Process(targetCommand);
}
}
else if (command is OkCommand)
{
await IOkProcessor.Process(command as OkCommand);
}
}
}
public async Task <ulong> CreateOrUpdateBatchOption(BatchOption option)
{
using (var db = await DbConnectionFactory.OpenAsync())
{
return(await db.CreateOrUpdateBatchOption(option));
}
}
public static int RunBatch(BatchOption option)
{
Process(option);
Console.WriteLine("\n\nComplete...");
return(0);
}
public async Task It_Should_Delete_Batch_Option()
{
// Arrange
batchRepository.DoesBatchExist(Arg.Any <string>())
.Returns(true);
var existingBatchOption = new BatchOption
{
Id = 123
};
batchRepository.GetBatchOption(Arg.Any <string>(), Arg.Any <string>())
.Returns(existingBatchOption);
batchRepository.DeleteBatchOption(Arg.Any <ulong>()).Returns(true);
var request = new DeleteBatchOptionRequest();
// Act
var response = await Sut.Delete(request);
// Assert
response.Should().NotBeNull();
await batchRepository.Received().DeleteBatchOption(Arg.Is <ulong>(a =>
a == existingBatchOption.Id));
}
public async Task It_Should_Update_BatchOption()
{
// Arrange
batchRepository.DoesBatchExist(Arg.Any <string>())
.Returns(true);
var batchOption = new BatchOption
{
Id = 123
};
batchRepository.GetBatchOption(Arg.Any <string>(), Arg.Any <string>())
.Returns(batchOption);
var request = TestData.ServiceModels.UpdateBatchOptions.Debug;
request.BatchId = TestBatchId;
// Act
var response = await Sut.Put(request);
// Assert
response.Should().NotBeNull();
await batchRepository.Received().CreateOrUpdateBatchOption(Arg.Is <BatchOption>(a =>
a.Id == 123 &&
a.BatchId == TestBatchId &&
a.Description == request.Description));
}
private static async Task ProcessBatchAsync(BatchConfig batch, BatchOption option)
{
var batchProcessor = Container.Shared.Get <IBatchProcessor>();
Console.WriteLine($"Processing [{batch.Name}]");
Console.WriteLine("");
await batchProcessor.Process(batch, option);
}
private void ShowGameObjectHeadInfo(GameObj select_obj)
{
GUILayout.BeginVertical("Box");
GUILayout.BeginHorizontal();
bool bActive = select_obj.m_bActive;
select_obj.m_bActive = GUILayout.Toggle(select_obj.m_bActive, select_obj.m_szName);
#region SetGameObjectActive
if (bActive != select_obj.m_bActive)
{
string szObj = IObject.Serializer <GameObj>(select_obj);
Cmd cmd = new Cmd(szObj.Length);
cmd.WriteNetCmd(NetCmd.C2S_CmdSetObjActive);
cmd.WriteString(szObj);
net_client.SendCmd(cmd);
}
#endregion
bool bStatic = select_obj.m_bStatic;
select_obj.m_bStatic = GUILayout.Toggle(select_obj.m_bStatic, "Static");
#region SetGameObjectStatic
if (bStatic != select_obj.m_bStatic)
{
BatchOption eBatchOption = DisplayeBatchOptionDialog("Static flags");
if (eBatchOption != BatchOption.eCancle)
{
string szObj = IObject.Serializer <GameObj>(select_obj);
Cmd cmd = new Cmd(szObj.Length);
cmd.WriteNetCmd(NetCmd.C2S_CmdSetObjStatic);
cmd.WriteString(szObj);
cmd.WriteInt32((int)eBatchOption);
net_client.SendCmd(cmd);
}
else
{
select_obj.m_bStatic = !select_obj.m_bStatic;
}
}
#endregion
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
string szTag = select_obj.m_szTag;
GUILayout.Label("Tag");
select_obj.m_szTag = EditorGUILayout.TagField(select_obj.m_szTag);
#region SetGameObjectTag
if (!szTag.Equals(select_obj.m_szTag))
{
BatchOption eBatchOption = DisplayeBatchOptionDialog("Tag");
if (eBatchOption != BatchOption.eCancle)
{
string szObj = IObject.Serializer <GameObj>(select_obj);
Cmd cmd = new Cmd(szObj.Length);
cmd.WriteNetCmd(NetCmd.C2S_CmdSetObjTag);
cmd.WriteString(szObj);
cmd.WriteInt32((int)eBatchOption);
net_client.SendCmd(cmd);
}
else
{
select_obj.m_szTag = szTag;
}
}
#endregion
int nLayer = select_obj.m_nLayer;
GUILayout.Label("Layer");
select_obj.m_nLayer = EditorGUILayout.LayerField(select_obj.m_nLayer);
#region SetGameObjectLayer
if (!nLayer.Equals(select_obj.m_nLayer))
{
BatchOption eBatchOption = DisplayeBatchOptionDialog("Layer");
if (eBatchOption != BatchOption.eCancle)
{
string szObj = IObject.Serializer <GameObj>(select_obj);
Cmd cmd = new Cmd(szObj.Length);
cmd.WriteNetCmd(NetCmd.C2S_CmdSetObjLayer);
cmd.WriteString(szObj);
cmd.WriteInt32((int)eBatchOption);
net_client.SendCmd(cmd);
}
else
{
select_obj.m_nLayer = nLayer;
}
}
#endregion
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
static void Process(BatchOption option)
{
var ft = new FileTool();
var now = DateTime.Now;
var folder = option.Directory;
var dataFile = "_data.csv";
var dataFileGA = "_dataGA.csv";
var files = Directory.GetFiles(folder, "*.txt");
var fileCount = files.Count();
var finders = option.Finder.ToArray();
var heuristics = option.Heuristic.ToArray();
var Mutation = option.Mutate.ToArray();
var Crossover = option.Crossover.ToArray();
var Fitness = option.Fitness.ToArray();
var Selection = option.Selection.Cast <SelectionEnum>().ToArray();
var newdatafile = !File.Exists(dataFile);
var newdatafileGA = !File.Exists(dataFileGA);
StreamWriter csvFile;
StreamWriter csvGAFile;
if (newdatafile)
{
csvFile = File.CreateText(dataFile);
}
else
{
csvFile = File.AppendText(dataFile);
}
if (newdatafileGA)
{
csvGAFile = File.CreateText(dataFileGA);
}
else
{
csvGAFile = File.AppendText(dataFileGA);
}
//csvFile = new StreamWriter(File.Open(dataFile, FileMode.OpenOrCreate), Encoding.UTF8, 4096, false);
//csvGAFile = new StreamWriter(File.Open(dataFileGA, FileMode.OpenOrCreate), Encoding.UTF8, 4096, false);
if (newdatafile)
{
csvFile.Write(new TextWrapper().GetHeader());
}
if (newdatafileGA)
{
csvGAFile.Write(new TextGAWrapper().GetHeader());
}
for (int i = 0; i < fileCount; i++)
{
var map = FileTool.ReadMapFromFile(files[i]);
foreach (var _finder in finders)
{
foreach (var _h in heuristics)
{
var h = new HeuristicFactory().GetImplementation(_h);
var finder = new FinderFactory().GetImplementation(_finder);
if (finder is IGeneticAlgorithm)
{
for (int cross = 0; cross < Crossover.Count(); cross++)
{
for (int mut = 0; mut < Mutation.Count(); mut++)
{
for (int fit = 0; fit < Fitness.Count(); fit++)
{
for (int sel = 0; sel < Selection.Count(); sel++)
{
for (int j = 0; j < option.GaTimes; j++)
{
GC.Collect();
GC.WaitForPendingFinalizers();
var GAFinder = (IGeneticAlgorithm) new FinderFactory().GetImplementation(_finder);
GAFinder.Crossover = new CrossoverFactory().GetImplementation(Crossover[cross]);
GAFinder.Mutate = new MutateFactory().GetImplementation(Mutation[mut]);
GAFinder.Fitness = new FitnessFactory().GetImplementation(Fitness[fit]);
GAFinder.Selection = new SelectionFactory().GetImplementation(Selection[sel]);
var helper = $"\n n:{j},cx:{GAFinder.Crossover.GetType().Name},m:{GAFinder.Mutate.GetType().Name},f:{GAFinder.Fitness.GetType().Name},s:{GAFinder.Selection.GetType().Name}";
var csv = new TextWrapper();
csv = RunStep(csv, i, fileCount, map, h, GAFinder, option.Directory, Path.GetFileName(files[i]), helper);
csvFile.Write(csv.ToString());
var csvGA = new TextGAWrapper
{
Alg = csv.Alg,
MapNumber = csv.MapNumber,
Heuristic = csv.Heuristic,
MapTypeGenerate = csv.MapTypeGenerate,
MapDiagonal = csv.MapDiagonal,
MapSize = csv.MapSize,
Solution = csv.Solution,
Time = csv.Time,
MaxNodes = csv.MaxNodes,
PathLength = csv.PathLength,
Crossover = GAFinder.Crossover.GetType().Name,
Mutation = GAFinder.Mutate.GetType().Name,
Fitness = GAFinder.Fitness.GetType().Name,
Selection = GAFinder.Selection.GetType().Name,
Generations = GAFinder.Generations.ToString(),
};
csvGAFile.Write(csvGA.ToString());
}
}
}
}
}
}
else
{
var csv = new TextWrapper();
csv = RunStep(csv, i, fileCount, map, h, finder, option.Directory, Path.GetFileName(files[i]));
csvFile.Write(csv.ToString());
}
csvFile.Flush();
csvGAFile.Flush();
}
}
}
DrawTextProgressBar(fileCount, fileCount);
csvFile.Dispose();
csvGAFile.Dispose();
}
internal static async Task <ulong> CreateOrUpdateBatchOption(this IDbConnection db, BatchOption option)
{
await db.SaveAsync(option, true);
return(option.Id);
}
public ActionResult BatchForm(VTBatchModel model, string buttontype)
{
if (ModelState.IsValid)
{
// Determine Which ID to use depending on the settings.
string EmployeeID = "";
if (VT.Properties.Settings.Default.UsingBinaryBadgeID)
{
try
{
EmployeeID = helper.VTIDtoEMPID(model.EmployeeID);
}
catch
{
model.DisplayMessage = "Please Scan your VT ID";
return(View(model));
}
}
else
{
EmployeeID = model.EmployeeID;
}
if (buttontype == "Go")
{
// Add the choices in the select down
model.ListBatchFields = logic.getBatchInfo(model.SerialNumber);
// There was an error
if (model.ListBatchFields[0].return_num != "0")
{
model.DisplayMessage = model.ListBatchFields[0].error_message;
return(View(model));
}
for (int i = 0; i < model.ListBatchFields.Count; i++)
{
BatchOption option = new BatchOption();
option.Text = model.ListBatchFields[i].Label;
option.Value = model.ListBatchFields[i].Token;
model.Options.Add(option);
}
if (model.BatchAmount != 0)
{
model.ListFields = logic.getFormInfo(model.SerialNumber, model.EmployeeID, model.SelectedItem); // It is only going to fill the first element
// There was an error
if (model.ListFields[0].return_num != "0")
{
model.DisplayMessage = model.ListFields[0].error_message;
return(View(model));
}
// Add the first serial number scanned to the batch list
model.SerialNumbers.Add(model.SerialNumber);
for (int i = 0; i < model.BatchAmount - 1; i++)
{
model.SerialNumbers.Add("");
}
model.GoBatch = true;
}
model.Go = true;
}
else if (buttontype == "Submit")
{
string[] check;
List <String> submit_list = new List <String>();
// Fills in the hidden values.
for (int i = 0; i < model.ListFields.Count; i++)
{
if (model.ListFields[i].isHidden)
{
if (model.ListFields[i].Token == "SNT" || model.ListFields[i].Token == "SNC")
{
string serial_numbers = model.SerialNumber;
// Add all of the remaining serial numbers
for (int j = 0; j < model.SerialNumbers.Count; j++)
{
serial_numbers += "," + model.SerialNumbers[j];
}
// Remove the extra comma at the end
model.ListFields[i].Value = serial_numbers;
}
else if (model.ListFields[i].Token == "USR")
{
model.ListFields[i].Value = EmployeeID;
}
else if (model.ListFields[i].Token == "TMS")
{
model.ListFields[i].Value = "0";
}
}
if (model.ListFields[i].DataType == "DATA-PIN")
{
model.ListFields[i].Value = model.PIN;
}
submit_list.Add(model.ListFields[i].Token + model.ListFields[i].Value);
}
check = logic.helperSubmit(submit_list, 4, model.SelectedItem);
string error_number = check[0];
string error_message = check[1];
if (error_number == "0")
{
ModelState.Clear();
VTBatchModel clear_model = new VTBatchModel(); // Creates an empty model
clear_model.Success = true;
clear_model.DisplayMessage = "Submitted\n";
for (int i = 0; i < model.SerialNumbers.Count; i++)
{
clear_model.DisplayMessage += model.SerialNumbers[i] + ",";
}
clear_model.DisplayMessage += "\n" + DateTime.Now;
clear_model.DisplaySerialError = error_message;
return(View(clear_model));
}
else
{
model.DisplayMessage = helper.checkErrors(error_number, error_message); // Sets the display message to the error.
}
}
}
return(View(model));
}
