private void btnLoadTrack_Click(object sender, RoutedEventArgs e)
{
if (!map.IsMapLoaded)
{
MessageBox.Show(this, "You must load a map before loading a track");
}
else
{
var datum = Datum.GetInstance("European 1950");
var utmZone = "31T";
var dlg = new OpenFileDialog();
dlg.Filter = "Track Files (*.igc, *.trk)|*.igc;*.trk|All Files (*.*)|*.*";
dlg.InitialDirectory = Environment.CurrentDirectory;
//dlg.RestoreDirectory = true;
if (dlg.ShowDialog(this) == true)
{
var logFile = LoggerFile.Load(dlg.FileName, DateTime.Now - DateTime.UtcNow);
var trackLog = logFile.GetTrackLog();
var track = new Point[trackLog.Length];
for (var i = 0; i < trackLog.Length; i++)
{
var p = trackLog[i];
var tmpPoint = p.Coordinates.ToUtm(datum, utmZone);
track[i] = new Point(tmpPoint.Easting, tmpPoint.Northing);
}
map.AddOverlay(new TrackOverlay(track, 2));
}
}
}
/// <summary>
/// Creates the logger for the application.
/// </summary>
private void InitializeLogger()
{
var loggers = new List <LoggerBase>();
// we want to show logger exception after all loggers have been initialized, so "remember" these
var loggersFailed = new Dictionary <string, Exception>();
// create loggers based on configuration
foreach (Configurations.Logger configLogger in Configurations.LoggerSection.GetLoggers())
{
if (string.IsNullOrEmpty(configLogger.Provider))
{
_logger.Log(_loggerTag, LoggerPriorities.Error, "Ignoring Logger without provider.");
continue;
}
LoggerBase logger = null;
// try to greate loggers based on provider name
try
{
switch (configLogger.Provider.ToLower())
{
case "console":
logger = new LoggerConsole(configLogger);
break;
case "file":
logger = new LoggerFile(configLogger);
break;
case "eventlog":
logger = new LoggerEventLog(configLogger);
break;
}
}
catch (Exception ex)
{
loggersFailed.Add(configLogger.Provider, ex);
}
if (logger == null)
{
_logger.Log(_loggerTag, LoggerPriorities.Error, "Unknown logger {0}", configLogger.Provider);
continue;
}
loggers.Add(logger);
}
_logger = new LoggerMultiple(loggers);
foreach (var logger in loggersFailed)
{
_logger.Log(_loggerTag, LoggerPriorities.Error, "Could not create logger {0}. Error: {1}", logger.Key, logger.Value);
}
}
public List <AXPoint> GetTrack(LoggerFile trackLog)
{
var track = new List <AXPoint>();
foreach (var p in trackLog.GetTrackLog())
{
track.Add(FromGeoToAXPoint(p, trackLog.IsAltitudeBarometric));
}
return(track);
}
public void WriteLogs_WithNullPathAndSomeLog_ShouldThrownLoggerFileException()
{
// Arrange
LoggerFile fileLogger = (LoggerFile)LoggerFactory.InitializeFactory().CreateLogger(LoggerTypes.File);
// Act
fileLogger.WriteLogs(null, "Content Log");
// Assert
// Expected LoggerFileException
}
public void ReadLogs_WithNullPath_ShouldThrownLoggerFileException()
{
// Arrange
LoggerFile fileLogger = (LoggerFile)LoggerFactory.InitializeFactory().CreateLogger(LoggerTypes.File);
// Act
fileLogger.ReadLogs(null);
// Assert
// Expected LoggerFileException
}
public static void Destroy()
{
string time = DateTime.Now.ToString("h:mm:ss tt");
try
{
LoggerFile.Close();
Console.WriteLine($"{time} : Closed Logging.");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
private static FlushLogArgs CreateFlushArgsForListener(Logger defaultLogger, ILogListener listener, FlushLogArgs defaultArgs, string defaultArgsJson, List <LoggerFile> defaultFiles)
{
FlushLogArgs args = JsonConvert.DeserializeObject <FlushLogArgs>(defaultArgsJson);
string inputStream = null;
if (!string.IsNullOrEmpty(defaultArgs.WebProperties.Request.Properties.InputStream))
{
if (KissLogConfiguration.Options.ApplyShouldLogRequestInputStream(defaultLogger, listener, defaultArgs))
{
inputStream = defaultArgs.WebProperties.Request.Properties.InputStream;
}
}
args.WebProperties.Request.Properties.Headers = defaultArgs.WebProperties.Request.Properties.Headers.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestHeader(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.Cookies = defaultArgs.WebProperties.Request.Properties.Cookies.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestCookie(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.QueryString = defaultArgs.WebProperties.Request.Properties.QueryString.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestQueryString(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.FormData = defaultArgs.WebProperties.Request.Properties.FormData.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestFormData(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.ServerVariables = defaultArgs.WebProperties.Request.Properties.ServerVariables.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestServerVariable(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.Claims = defaultArgs.WebProperties.Request.Properties.Claims.Where(p => KissLogConfiguration.Options.ApplyShouldLogRequestClaim(listener, defaultArgs, p.Key)).ToList();
args.WebProperties.Request.Properties.InputStream = inputStream;
args.WebProperties.Response.Properties.Headers = defaultArgs.WebProperties.Response.Properties.Headers.Where(p => KissLogConfiguration.Options.ApplyShouldLogResponseHeader(listener, defaultArgs, p.Key)).ToList();
List <LogMessagesGroup> messages = new List <LogMessagesGroup>();
foreach (var group in args.MessagesGroups)
{
messages.Add(new LogMessagesGroup
{
CategoryName = group.CategoryName,
Messages = group.Messages.Where(p => listener.Parser.ShouldLog(p, listener)).ToList()
});
}
args.MessagesGroups = messages;
List <LoggerFile> files = defaultFiles.ToList();
LoggerFile responseFile = GetResponseFile(files);
if (responseFile != null && !InternalHelpers.ShouldLogResponseBody(defaultLogger, listener, defaultArgs))
{
files.Remove(responseFile);
}
args.Files = files;
return(args);
}
static void Main(string[] args)
{
var logger = GetLogger();
using (var strategy = new LoggerFile("loggerFile.txt", false))
{
logger.ChangeStrategy(strategy);
logger.Info("Logger was started");
var addressBook = new AddressBook.AddressBook();
addressBook.UserAdded += HandleBookChanged;
addressBook.UserRemoved += HandleBookChanged;
TestAddressBook(addressBook);
logger.Info("Logger finish work");
}
}
public static void Writer(string LogMessage)
{
string time = DateTime.Now.ToString("h:mm:ss tt");
string currentdate = DateTime.Now.ToString("yyMMdd");
if (currentdate != Logger.Date)
{
Logger.Destroy();
Logger.Initiate();
}
try
{
LoggerFile.WriteLine($"{time} : {LogMessage}");
Console.WriteLine($"{time} : {LogMessage}");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static void Run()
{
// Bridge Pattern allows independent variation between abstraction (logger) and implementation (formatting functionality)
var standardFormatter = new FormatterStandard();
var allCapsFormatter = new FormatterAllCaps();
var consoleLoggerInStandardFormat = new LoggerConsole(standardFormatter);
var consoleLoggerInAllCaps = new LoggerConsole(allCapsFormatter);
var fileLoggerInStandardFormat = new LoggerFile(standardFormatter);
var fileLoggerInAllCaps = new LoggerFile(allCapsFormatter);
const string title = "The Title";
const string message = "This is the message.";
consoleLoggerInStandardFormat.Log(title, message);
consoleLoggerInAllCaps.Log(title, message);
fileLoggerInStandardFormat.Log(title, message);
fileLoggerInAllCaps.Log(title, message);
}
static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Welcome to eLogger");
Exception exception = new Exception();
ILogger console = new LoggerConsole();
ILogger file = new LoggerFile();
ILogger db = new LoggerDatabase(new LoggerDao());
console.Fatal("Fatal Error found.", exception);
console.Error("Error found.", exception);
console.Warning("Warning found.", exception);
console.Info("Informative message.");
console.Debug("Debug message.");
console.Trace("Trace message.");
file.Fatal("Fatal Error found.", exception);
file.Error("Error found.", exception);
file.Warning("Warning found.", exception);
file.Info("Informative message.");
file.Debug("Debug message.");
file.Trace("Trace message.");
db.Fatal("Fatal Error found.", exception);
db.Error("Error found.", exception);
db.Warning("Warning found.", exception);
db.Info("Informative message.");
db.Debug("Debug message.");
db.Trace("Trace message.");
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Press a key to continue");
Console.ReadKey();
}
public override void CheckConstructorSyntax()
{
base.CheckConstructorSyntax();
switch (Definition.ObjectType)
{
default:
throw new ArgumentException(string.Format("Unknown area type '{0}'", Definition.ObjectType));
case "CYLINDER":
AssertNumberOfParametersOrDie(Definition.ObjectParameters.Length >= 2 && Definition.ObjectParameters.Length <= 4);
center = ResolveOrDie <ScriptingPoint>(0); // point will be static or null
radius = ParseOrDie <double>(1, Parsers.ParseLength);
if (Definition.ObjectParameters.Length >= 3)
{
upperLimit = ParseOrDie <double>(2, Parsers.ParseLength);
}
if (Definition.ObjectParameters.Length >= 4)
{
lowerLimit = ParseOrDie <double>(3, Parsers.ParseLength);
}
maxHorizontalInfringement = 2 * radius;
break;
case "SPHERE":
AssertNumberOfParametersOrDie(Definition.ObjectParameters.Length == 2);
center = ResolveOrDie <ScriptingPoint>(0); // point will be static or null
radius = ParseOrDie <double>(1, Parsers.ParseLength);
maxHorizontalInfringement = 2 * radius;
break;
case "PRISM":
AssertNumberOfParametersOrDie(Definition.ObjectParameters.Length >= 1 && Definition.ObjectParameters.Length <= 3);
var fileName = ParseOrDie <string>(0, s => s);
var trackLog = LoggerFile.Load(fileName, Engine.Settings.UtcOffset);
outline = Engine.Settings.GetTrack(trackLog);
if (Definition.ObjectParameters.Length >= 2)
{
upperLimit = ParseOrDie <double>(1, Parsers.ParseLength);
}
if (Definition.ObjectParameters.Length >= 3)
{
lowerLimit = ParseOrDie <double>(2, Parsers.ParseLength);
}
for (var i = 1; i < outline.Count; i++)
{
for (var j = 0; j < i; j++)
{
maxHorizontalInfringement = Math.Max(maxHorizontalInfringement, Physics.Distance2D(outline[i], outline[j]));
}
}
break;
case "TIME":
AssertNumberOfParametersOrDie(Definition.ObjectParameters.Length == 2);
lowerTime = Engine.Settings.Date.Date + ParseOrDie <TimeSpan>(0, Parsers.ParseTimeSpan);
upperTime = Engine.Settings.Date.Date + ParseOrDie <TimeSpan>(1, Parsers.ParseTimeSpan);
break;
case "UNION":
case "INTERSECTION":
case "SUBTRACTION":
AssertNumberOfParametersOrDie(Definition.ObjectParameters.Length > 1);
areas = new List <ScriptingArea>();
foreach (var areaName in Definition.ObjectParameters)
{
var area = Engine.Heap.Values.FirstOrDefault(o => o is ScriptingArea && o.Definition.ObjectName == areaName) as ScriptingArea;
if (area == null)
{
throw new ArgumentException("undeclaread area " + areaName);
}
areas.Add(area);
}
break;
}
}
//factory
public static FlightReport Load(string debriefer, string filePath, FlightSettings settings)
{
FlightReport report = null;
var ext = Path.GetExtension(filePath).ToLower();
if (ext == SerializedFileExtension)
{
//deserialize report
report = ObjectSerializer <FlightReport> .Load(filePath, serializationFormat);
report.Debriefer = debriefer;
report.DoTrackCleanUp();
}
else
{
var logFile = LoggerFile.Load(filePath, settings.UtcOffset, settings.AltitudeCorrectionsFileName);
//check pilot id
var pilotId = logFile.PilotId;
if (pilotId == 0)
{
//try to get the pilot Id from filename
//The file name must contain a P or p followed with pilot number (1 to 3 digits)
//examples: f001_p021_l0.trk, Flight01P001.trk, 20120530AM_p01.trk, 0530AMP02_1.trk
var pattern = @"P(\d{1,3})";
var input = Path.GetFileName(filePath);
var matches = Regex.Matches(input, pattern, RegexOptions.IgnoreCase);
if (matches.Count == 1)
{
pilotId = int.Parse(matches[0].Groups[1].Value);
}
if (pilotId == 0)
{
throw new Exception(
"The pilot id is not present in the track log file and it could not be inferred from the file name.\n" +
"The file name must contain a P or p followed with pilot number (1 to 3 digits)\n" +
"examples: f001_p021_l0.trk, Flight01P001.trk, 20120530AM_p01.trk, 0530AMP02_1.trk"
);
}
}
//Convert geographical coordinates to AX coordinates
var tracklog = logFile.GetTrackLog();
var track = new AXPoint[tracklog.Length];
Parallel.For(0, track.Length, i =>
{
track[i] = settings.FromGeoToAXPoint(tracklog[i], logFile.IsAltitudeBarometric);
});
var markers = new ObservableCollection <AXWaypoint>();
foreach (var m in logFile.GetMarkers())
{
markers.Add(settings.FromGeoToAXWaypoint(m, logFile.IsAltitudeBarometric));
}
var declarations = new ObservableCollection <GoalDeclaration>();
foreach (var d in logFile.GetGoalDeclarations())
{
declarations.Add(d);
}
//Make new report
report = new FlightReport(settings)
{
Debriefer = debriefer,
IsDirty = true,
LogFile = logFile,
SignatureStatus = logFile.SignatureStatus,
pilotId = pilotId, //don't use PilotId on constructor!
LoggerModel = logFile.LoggerModel,
LoggerSerialNumber = logFile.LoggerSerialNumber,
OriginalTrack = track,
Markers = markers,
DeclaredGoals = declarations,
Notes = new ObservableCollection <string>()
};
switch (logFile.SignatureStatus)
{
case SignatureStatus.NotSigned:
report.Notes.Add("The log file is not signed");
break;
case SignatureStatus.Genuine:
report.Notes.Add("The log file has a valid signature");
break;
case SignatureStatus.Counterfeit:
report.Notes.Add("*** THE LOG FILE HAS AN INVALID SIGNATURE! ***");
break;
}
report.DoTrackCleanUp();
report.DetectTakeOffAndLanding();
}
return(report);
}
