private static UserData ToUser(Dictionary <string, object> userD)
{
var user = new UserData();
try
{
if (userD.ContainsKey("Fingerprint"))
{
user.Fingerprint = userD["Fingerprint"] as string;
}
if (userD.ContainsKey("UserName"))
{
user.UserName = userD["UserName"] as string;
}
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Unable to parse user data part.", exception);
var data = Issue.Register(exp);
throw exp.AddData("IssueInstanceTicket", data.IssueInstanceTicket).AddData("IssueTypeTicket", data.IssueTypeTicket);
}
return(user);
}
public static Tharga.Quilt4Net.DataTransfer.Session ToSession(Dictionary <string, object> sessionD)
{
var session = new Tharga.Quilt4Net.DataTransfer.Session();
try
{
if (sessionD.ContainsKey("SessionGuid"))
{
Guid sessionGuid;
if (Guid.TryParse(sessionD["SessionGuid"] as string, out sessionGuid))
{
session.SessionGuid = sessionGuid;
}
}
if (sessionD.ContainsKey("ClientStartTime"))
{
DateTime clientStartTime;
if (DateTime.TryParse(sessionD["ClientStartTime"] as string, out clientStartTime))
{
session.ClientStartTime = clientStartTime;
}
}
if (sessionD.ContainsKey("ClientToken"))
{
session.ClientToken = sessionD["ClientToken"] as string;
if (sessionD.ContainsKey("Environment"))
{
session.Environment = sessionD["Environment"] as string;
}
}
if (sessionD.ContainsKey("Application"))
{
var applicationD = sessionD["Application"] as dynamic;
session.Application = ToApplication(applicationD);
}
if (sessionD.ContainsKey("Machine"))
{
var machineD = sessionD["Machine"] as dynamic;
session.Machine = ToMachine(machineD);
}
if (sessionD.ContainsKey("User"))
{
var userD = sessionD["User"] as dynamic;
session.User = ToUser(userD);
}
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Unable to parse session data part.", exception);
var data = Issue.Register(exp);
throw exp.AddData("IssueInstanceTicket", data.IssueInstanceTicket).AddData("IssueTypeTicket", data.IssueTypeTicket);
}
return(session);
}
/// <summary>
/// Guards against an invalid operation. The operation is invalid if the condition evaluates to <c>True</c> . Will
/// throw an <see cref="InvalidOperationException">InvalidOperationException</see> .
/// </summary>
/// <param name="operationInvalid">A boolean condition, which if <c>true</c> , indicates if the operation is invalid.</param>
/// <param name="exceptionMessage">
/// (Optional) Custom error message. A specific error message that can be used to describe
/// the exception in more detail than the default message.
/// </param>
/// <param name="additionalData">(Optional) Additional information to add to the Data property of the thrown exception.</param>
/// <exception cref="InvalidOperationException">Will be thrown when <c>operationInvalid</c> is evaluates to <c>true</c> .</exception>
/// <example>
/// <code>
/// public void Start()
/// {
/// GuardAgainst.OperationBeingInvalid(_started), nameof(myArgument));
///
/// // Remaining code omitted.
/// }
/// </code>
/// </example>
public static void OperationBeingInvalid(bool operationInvalid,
string exceptionMessage = null,
IDictionary <object, object> additionalData = default)
{
if (!operationInvalid)
{
return;
}
var ex = new InvalidOperationException(exceptionMessage.ToNullIfWhitespace());
ex.AddData(additionalData);
throw ex;
}
private static ApplicationData ToApplication(Dictionary <string, object> applicationD)
{
var application = new ApplicationData();
try
{
if (applicationD.ContainsKey("Fingerprint"))
{
application.Fingerprint = applicationD["Fingerprint"] as string;
}
if (applicationD.ContainsKey("Name"))
{
application.Name = applicationD["Name"] as string;
}
if (applicationD.ContainsKey("SupportToolkitNameVersion"))
{
application.SupportToolkitNameVersion = applicationD["SupportToolkitNameVersion"] as string;
}
if (applicationD.ContainsKey("Version"))
{
application.Version = applicationD["Version"] as string;
}
if (applicationD.ContainsKey("BuildTime"))
{
DateTime buildTime;
if (DateTime.TryParse(applicationD["BuildTime"] as string, out buildTime))
{
application.BuildTime = buildTime;
}
}
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Unable to parse application data part.", exception);
var data = Issue.Register(exp);
throw exp.AddData("IssueInstanceTicket", data.IssueInstanceTicket).AddData("IssueTypeTicket", data.IssueTypeTicket);
}
return(application);
}
private static MachineData ToMachine(Dictionary <string, object> machineD)
{
var machine = new MachineData();
try
{
machine.Fingerprint = machineD["Fingerprint"] as string;
machine.Name = machineD["Name"] as string;
if (machineD.ContainsKey("Data"))
{
machine.Data = ToDictionary(machineD["Data"]);
}
else
{
machine.Data = new Dictionary <string, string>();
}
if (!machine.Data.ContainsKey("OsName") && machineD.ContainsKey("OsName"))
{
var osName = machineD["OsName"] as string;
if (!string.IsNullOrEmpty(osName))
{
machine.Data.Add("OsName", osName);
}
}
}
catch (Exception exception)
{
var exp = new InvalidOperationException("Unable to parse machine data part.", exception);
var data = Issue.Register(exp);
throw exp.AddData("IssueInstanceTicket", data.IssueInstanceTicket).AddData("IssueTypeTicket", data.IssueTypeTicket);
}
return(machine);
}