public static Output Filter(Output output, CmdArguments args)
{
var result = new Output
{
Headers = output.Headers
};
var lines = output.Lines;
if (args.Project != null)
{
lines = lines.Where(l => l.Project == args.Project.Value)
.ToList();
}
if (args.SortByDate)
{
lines = lines.OrderBy(l => l.StartDate)
.ToList();
}
result.Lines = lines;
return(result);
}
static public async Task Do(CmdArguments args)
{
var client = JobClient.CreateFromConnectionString(Settings.Default.ConnectionString);
var method = new CloudToDeviceMethod(args.Names.Single());
method.SetPayloadJson(args.Values.Single());
var startTime = DateTime.UtcNow + TimeSpan.FromSeconds(args.StartOffsetInSeconds);
var jobId = args.JobId;
if (string.IsNullOrEmpty(jobId))
{
jobId = Guid.NewGuid().ToString();
}
JobResponse job = await client.ScheduleDeviceMethodAsync(
jobId,
args.QueryCondition,
method,
startTime,
args.TimeoutInSeconds);
Console.WriteLine($"{job.Type} job {job.JobId} scheduled");
await IoTHubHelper.WaitJob(client, job);
}
static public async Task Do(CmdArguments args)
{
if (args.Ids != null)
{
var client = JobClient.CreateFromConnectionString(Settings.Default.ConnectionString);
foreach (var jobId in args.Ids)
{
var job = await client.GetJobAsync(jobId);
Console.WriteLine(JsonConvert.SerializeObject(job, Formatting.Indented));
Console.WriteLine();
}
}
else
{
var manager = RegistryManager.CreateFromConnectionString(Settings.Default.ConnectionString);
var query = manager.CreateQuery(args.QueryCondition ?? "select * from devices.jobs");
while (query.HasMoreResults)
{
var result = await query.GetNextAsJsonAsync();
foreach (var job in result)
{
Console.WriteLine(job);
Console.WriteLine();
}
}
}
}
static public async Task Do(CmdArguments args)
{
var twin = new Twin();
twin.ETag = "*";
twin.Set(args.KVPairs);
var startTime = DateTime.UtcNow + TimeSpan.FromSeconds(args.StartOffsetInSeconds);
var client = JobClient.CreateFromConnectionString(Settings.Default.ConnectionString);
var jobId = args.JobId;
if (string.IsNullOrEmpty(jobId))
{
jobId = Guid.NewGuid().ToString();
}
JobResponse job = await client.ScheduleTwinUpdateAsync(
jobId,
args.QueryCondition,
twin,
startTime,
args.TimeoutInSeconds);
Console.WriteLine($"{job.Type} job {job.JobId} scheduled");
await IoTHubHelper.WaitJob(client, job);
}
static void Main(string[] args)
{
try
{
var installOffice = new InstallOffice();
installOffice.RunProgram();
var xmlConfiguration = "";
var cmdArgs = CmdArguments.GetArguments();
var xmlArg = cmdArgs.FirstOrDefault(a => a.Name.ToUpper() == "XML");
if (xmlArg != null)
{
xmlConfiguration = xmlArg.Value;
}
Console.WriteLine("Office 365 ProPlus Install Executable Generator");
Console.WriteLine();
if (string.IsNullOrEmpty(xmlConfiguration))
{
Console.Write("Configuration Xml File Path: ");
xmlConfiguration = Console.ReadLine();
Console.WriteLine();
}
if (!File.Exists(xmlConfiguration))
{
throw (new Exception("File Does Not Exist: " + xmlConfiguration));
}
var p = new OfficeInstallMsiGenerator();
p.Generate(new OfficeInstallProperties()
{
OfficeVersion = OfficeVersion.Office2016,
ConfigurationXmlPath = xmlConfiguration,
SourceFilePath = null
});
}
catch (Exception ex)
{
var backColor = Console.BackgroundColor;
var textColor = Console.ForegroundColor;
Console.BackgroundColor = ConsoleColor.Red;
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("ERROR: " + ex.Message);
Console.BackgroundColor = backColor;
Console.ForegroundColor = textColor;
}
finally
{
Console.WriteLine();
Console.WriteLine("Done");
Console.ReadLine();
}
}
public void FilterHandler_Filter_HeadersImmutable()
{
var args = new CmdArguments {
FilePath = @"..\..\..\Files\Data.tsv", SortByDate = true, Project = 2
};
var result = FilterHandler.Filter(output, args);
Assert.AreSame(output.Headers, result.Headers);
}
static public async Task Do(CmdArguments args)
{
var client = RegistryManager.CreateFromConnectionString(Settings.Default.ConnectionString);
foreach (var deviceId in args.Ids)
{
await client.RemoveDeviceAsync(deviceId);
Console.WriteLine($"{deviceId} deleted");
}
}
public void QuotesTest()
{
string strKey = "file";
string strValue = "The file to get";
string[] strQuotes = { string.Format("/{0}", strKey), strValue };
CmdArguments parsedArgs = new CmdArguments(strQuotes);
Assert.AreEqual(strValue, parsedArgs[strKey]);
WriteArgument(strKey, strValue);
}
static public async Task Do(CmdArguments args)
{
var client = JobClient.CreateFromConnectionString(Settings.Default.ConnectionString);
foreach (var jobId in args.Names)
{
var response = await client.CancelJobAsync(jobId);
Console.WriteLine($"Job {jobId} status = {response.Status}");
}
}
public void FilterHandler_Filter_FilterSuccess()
{
var args = new CmdArguments {
FilePath = @"..\..\..\Files\Data.tsv", SortByDate = false, Project = 2
};
var result = FilterHandler.Filter(output, args);
Assert.IsTrue(result.Lines.Count == 1);
Assert.IsTrue(result.Lines.First().Project == 2);
}
public void FilterHandler_Filter_FilterAndSortNoEffect()
{
var args = new CmdArguments {
FilePath = @"..\..\..\Files\Data.tsv", SortByDate = false, Project = null
};
var result = FilterHandler.Filter(output, args);
Assert.IsTrue(result.Lines.Count == output.Lines.Count);
Assert.IsTrue(result.Lines.First().Project == output.Lines.First().Project);
Assert.IsTrue(result.Lines.Last().Project == output.Lines.Last().Project);
}
public static bool onMain(string[] args)
{
CmdArguments arguments = args;
var log = arguments.GetAllArgumentsWithName("logIgnore");
foreach (var logArg in log)
{
try
{
Logger.RemoveFlag((Logger.LogLevel)Enum.Parse(typeof(Logger.LogLevel), logArg.ToUpper()));
}
catch (Exception e)
{
Logger.Error("Could not do {0}, value {1}: ", "logIgnore", logArg, e);
}
}
log = arguments.GetAllArgumentsWithName("log");
foreach (var logArg in log)
{
try
{
Logger.AddFlag((Logger.LogLevel)Enum.Parse(typeof(Logger.LogLevel), logArg.ToUpper()));
}
catch (Exception e)
{
Logger.Error("Could not do {0}, value {1}: ", "log", logArg, e);
}
}
var modDirectory = arguments["modDirectory"];
if (modDirectory != null)
{
Logger.Info("Mod Directory redirected to {0}", modDirectory);
Manager.ModFolderPath = modDirectory;
}
var depDirectory = arguments["depDirectory"];
if (depDirectory != null)
{
Logger.Info("Mod Dependency Directory redirected to {0}", depDirectory);
Manager.DepFolderPath = depDirectory;
}
Logger.Verbose("Initializing Pathfinder");
Pathfinder.Initialize();
var startUpEvent = new Event.StartUpEvent(args);
startUpEvent.CallEvent();
if (startUpEvent.IsCancelled)
{
return(true);
}
return(false);
}
public static CmdArguments Parse(string[] args)
{
var cmdArguments = new CmdArguments();
var properties = typeof(CmdArguments)
.GetProperties(BindingFlags.Instance | BindingFlags.Public);
foreach (var property in properties)
{
var attribute = property.GetCustomAttribute <FlagAttribute>();
var flag = args
.Select((arg, index) => new { arg, index })
.FirstOrDefault(f => f.arg == attribute.Flag);
string value = null;
if (flag == null)
{
if (attribute.IsRequired)
{
throw new Exception($"The flag {attribute.Flag} is required.");
}
continue;
}
if (property.PropertyType == typeof(bool))
{
property.SetValue(cmdArguments, true);
continue;
}
value = args.ElementAtOrDefault(flag.index + 1);
if (value == null)
{
throw new Exception($"No value was provided for the argument flag {attribute.Flag}.");
}
try
{
Convertor.ConvertValue(cmdArguments, property, value);
}
catch
{
throw new Exception($"The value {value} is not valid for flag {attribute.Flag}.");
}
}
return(cmdArguments);
}
static public async Task Do(CmdArguments args)
{
var client = ServiceClient.CreateFromConnectionString(Settings.Default.ConnectionString);
var deviceId = args.Ids.Single();
var method = new CloudToDeviceMethod(args.Names.Single());
method.SetPayloadJson(args.Values.Single());
var result = await client.InvokeDeviceMethodAsync(deviceId, method);
Console.WriteLine($"1 device invoked. Status: {result.Status}, Return: {result.GetPayloadAsJson()}");
}
static public async Task Do(CmdArguments args)
{
var client = ServiceClient.CreateFromConnectionString(Settings.Default.ConnectionString);
var message = new Message(Encoding.UTF8.GetBytes(args.C2DMessage));
foreach (var deviceId in args.Ids)
{
await client.SendAsync(deviceId, message);
Console.WriteLine($"C2D message {args.C2DMessage} sent to device {deviceId}");
}
}
static public async Task Do(CmdArguments args)
{
var client = RegistryManager.CreateFromConnectionString(Settings.Default.ConnectionString);
if (args.Ids != null)
{
await IoTHubHelper.QueryDevicesByIds(client, args.Ids);
}
else
{
await IoTHubHelper.QueryDevicesByCondition(client, args.QueryCondition ?? "select * from devices");
}
}
static public async Task Do(CmdArguments args)
{
var client = RegistryManager.CreateFromConnectionString(Settings.Default.ConnectionString);
var deviceId = args.Ids.Single();
var twin = new Twin(deviceId);
twin.Set(args.KVPairs);
twin = await client.UpdateTwinAsync(deviceId, twin, "*");
IoTHubHelper.OutputDevice(twin);
Console.WriteLine("1 device updated");
}
private void TestArguments(string[] strArgs, bool caseSensitive)
{
CmdArguments parsed = new CmdArguments(strArgs, caseSensitive);
Assert.AreEqual(4, parsed.Count);
Assert.IsFalse(parsed.IsReadOnly);
var parsedKeys = parsed.Keys;
var parsedValues = parsed.Values;
for (int i = 1; i < 5; i++)
{
string key = $"Arg{i}";
Assert.IsTrue(parsed.ContainsKey(key)); // Match case
Assert.AreNotEqual(caseSensitive, parsed.ContainsKey($"arg{i}")); // Different case
string strValue = parsed[key];
string strExpected = (i == 1) ? string.Empty : $"value{i}";
Assert.AreEqual(strExpected, strValue);
Assert.IsTrue(parsedKeys.Contains(caseSensitive ? key : key.ToLower()));
Assert.IsTrue(parsedValues.Contains(strExpected));
string tryGet;
Assert.IsTrue(parsed.TryGetValue(key, out tryGet));
Assert.AreEqual(strExpected, tryGet);
WriteArgument(key, strValue);
}
if (caseSensitive)
{
foreach (KeyValuePair <string, string> pair in parsed)
{
Assert.IsTrue(strArgs.Where(x => x.Contains(pair.Key)).Any());
Assert.IsTrue(strArgs.Where(x => x.Contains(pair.Value)).Any());
}
}
KeyValuePair <string, string>[] copyArray = new KeyValuePair <string, string> [parsed.Count];
parsed.CopyTo(copyArray, 0);
foreach (var copyItem in copyArray)
{
Assert.IsTrue(parsed.Contains(copyItem));
}
parsed.Clear();
Assert.AreEqual(0, parsed.Count);
}
static public async Task Do(CmdArguments args)
{
var client = JobClient.CreateFromConnectionString(Settings.Default.ConnectionString);
var condition = args.QueryCondition == null ? null : JsonConvert.DeserializeObject <QueryJobSummaryCondition>(args.QueryCondition);
var query = client.CreateQuery(condition?.Type, condition?.Status);
while (query.HasMoreResults)
{
var result = await query.GetNextAsJsonAsync();
foreach (var job in result)
{
Console.WriteLine(job);
Console.WriteLine();
}
}
}
public void KomplexCase()
{
var mock = new Mock <IInputManager>();
mock.Setup(foo => foo.GetAllFilenamesWildcard()).Returns(new List <string>()
{
"eins"
});
mock.Setup(foo => foo.GetLinesOfContent("eins")).Returns(TestLines());
CmdArguments cmd = new CmdArguments();
cmd.StartOfLinePattern = @"^in";
cmd.SearchPattern = "zeile";
cmd.ShowPerformance = false;
ParLogLib llib = new ParLogLib(mock.Object, cmd);
// catch standard output
using (StringWriter sw = new StringWriter())
{
Console.SetOut(sw);
llib.Parse();
string expected =
@"in erste zeile
in zweite zeile
multi line 2.5 no key word
in dritte zeile
mehr zu drei
noch mehr zu drei
in vierte zeile
mehr zu zeile 4
in zeile
out zeile
in zeile
out ohne dem wort
in wieder eine zeile
";
Console.SetOut(new StreamWriter(Console.OpenStandardOutput()));
Console.WriteLine(sw.ToString());
Assert.AreEqual(expected, sw.ToString());
}
}
public void AddRemoveTest()
{
// Test an empty command line list - Case Insenstive
CmdArguments parsed = new CmdArguments(new string[0]);
parsed.Add(new KeyValuePair <string, string>("Arg1", "Value1"));
Assert.IsTrue(parsed.ContainsKey("arg1"));
Assert.IsTrue(parsed.Remove("arg1"));
Assert.IsFalse(parsed.ContainsKey("arg1"));
// Test an empty command line list - Case Senstive
parsed = new CmdArguments(new string[0], true);
parsed.Add(new KeyValuePair <string, string>("Arg1", "Value1"));
Assert.IsTrue(parsed.ContainsKey("Arg1"));
Assert.IsFalse(parsed.ContainsKey("arg1"));
Assert.IsFalse(parsed.Remove("arg1"));
Assert.IsTrue(parsed.Remove(new KeyValuePair <string, string>("Arg1", "Value1")));
Assert.IsFalse(parsed.ContainsKey("Arg1"));
}
static public async Task Do(CmdArguments args)
{
var client = RegistryManager.CreateFromConnectionString(Settings.Default.ConnectionString);
foreach (var deviceId in args.Ids)
{
await client.AddDeviceAsync(new Device(deviceId));
Console.WriteLine($"{deviceId} added");
if (args.KVPairs != null)
{
var twin = new Twin();
twin.Set(args.KVPairs);
await client.UpdateTwinAsync(deviceId, twin, "*");
}
}
await IoTHubHelper.QueryDevicesByIds(client, args.Ids);
}
public override int GetHashCode()
{
var hashCode = 304851041;
if (Manufacturer == null)
{
hashCode = hashCode * -1521134295;
}
else
{
hashCode = hashCode * -1521134295 + Manufacturer.GetHashCode();
}
if (CmdArguments == null)
{
hashCode = hashCode * -1521134295;
}
else
{
hashCode = hashCode * -1521134295 + CmdArguments.GetHashCode();
}
return(hashCode * -1521134295 + FileName.GetHashCode());
}
