private void traceGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
try
{
if (traceGrid.SelectedItem != null)
{
var selectedItem = ((IDictionary <string, object>)(traceGrid.SelectedItem));
TraceDto trace = new TraceDto
{
Message = ((dynamic)traceGrid.SelectedItem).Message,
SystemTime = ((dynamic)traceGrid.SelectedItem).SystemTime,
TraceKey = ((dynamic)traceGrid.SelectedItem).TraceKey,
Writer = ((dynamic)traceGrid.SelectedItem).Writer
};
string[] defaultCols = new string[] { "Message", "SystemTime", "TraceKey", "Writer" };
foreach (var key in selectedItem.Keys.Except(defaultCols))
{
trace.Data.Add(key, selectedItem[key]?.ToString());
}
OpenDetailsWindow(trace);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
private void AddTraceEventToTraceList(TraceEvent e)
{
var level = 2;
switch (e.Level)
{
case TraceEventLevel.Always:
case TraceEventLevel.Verbose:
case TraceEventLevel.Informational:
level = 2;
break;
case TraceEventLevel.Critical:
case TraceEventLevel.Error:
level = 1;
break;
case TraceEventLevel.Warning:
level = 3;
break;
}
var data = (string)e.PayloadByName("data");
var trace = new TraceDto
{
Message = e.FormattedMessage,
Level = level,
TraceKey = (string)e.PayloadByName("traceKey") ?? string.Empty,
Writer = (string)e.PayloadByName("writer") ?? string.Empty,
Data = data != null?Newtonsoft.Json.JsonConvert.DeserializeObject <Dictionary <string, string> >(data) : null
};
AddTraceToTraceList(trace);
}
private static int GetSizeOfTrace(TraceDto trace)
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
MemoryStream memorystream = new MemoryStream();
binaryFormatter.Serialize(memorystream, trace);
return(memorystream.ToArray().Length);
}
public TraceDetailsWindow(TraceDto data)
{
InitializeComponent();
this.Detail = data;
this.DataContext = this;
}
public void SubmitData(TraceDto trace)
{
if (trace == null || trace.Data == null || string.IsNullOrEmpty(trace.Message))
{
throw new System.Exception("one or more property (like Data or Message) in 'Source' should be filled ");
}
else if (IsTraceEnabled(trace.TraceKey))
{
trace.Writer = AppName;
this.SubmitData(trace.Message, trace.Writer, trace.SerializedData, string.IsNullOrEmpty(trace.TraceKey) ? "GeneralTraceKey" : trace.TraceKey);
}
}
private static void CalculateWriterSize(TraceDto trace)
{
var traceSize = GetSizeOfTrace(trace);//Core.Cmn.Extensions.SerializationExtensions.SerializetoBinary(trace).LongLength;
long writerSize;
if (WritersInfo.TryGetValue(trace.Writer, out writerSize))
{
WritersInfo[trace.Writer] += traceSize;
}
else
{
WritersInfo.Add(trace.Writer, traceSize);
}
}
public async Task ShouldBeAbleToCreateTraceAsync()
{
const int createdId = 100;
const string testTraceTitle = "TestTitle";
const string testTraceDescription = "TestDescription";
const string testTracePropertyId = "PROP";
var testTraceDueDate = DateTime.Now.Add(TimeSpan.FromDays(2)).Date;
var testCreateTrace = new CreateTraceItemModel
{
Title = testTraceTitle,
Description = testTraceDescription,
DueDate = testTraceDueDate,
PropertyId = testTracePropertyId
};
var resultTraceDto = new TraceDto
{
Id = createdId,
Title = testTraceTitle,
Description = testTraceDescription.Some(),
DueDate = testTraceDueDate.ToLocalDateTime().Date,
State = TraceState.Active,
PropertyId = testTracePropertyId
};
_traceServiceMock.Setup(x => x.CreateTraceAsync(
It.Is <CreateTraceDto>(v =>
v.Title == testTraceTitle &&
v.Description.ValueOrFailure() == testTraceDescription &&
v.DueDate.ToDateTimeUnspecified().Date == testTraceDueDate)))
.ReturnsAsync(resultTraceDto);
var creationResult = await _traceModifierService.CreateTraceAsync(testCreateTrace);
creationResult.Should().NotBeNull();
creationResult.Success.Should().BeTrue();
creationResult.ErrorMessage.HasValue.Should().BeFalse();
creationResult.Result.HasValue.Should().BeTrue();
var result = creationResult.Result.ValueOrFailure();
result.Should().NotBeNull();
result.Id.Should().Be(createdId);
result.Title.Should().Be(testTraceTitle);
result.Description.Should().Be(testTraceDescription);
result.State.Should().Be(TraceState.Active);
result.DueDate.Should().Be(testTraceDueDate);
result.PropertyId.Should().Be(testTracePropertyId);
}
public async Task ShouldBeAbleToCreateTraceWithReservationIdAsync()
{
const string testTraceTitle = "ReservationTrace";
const string testTraceDescription = "ReservationTraceDescription";
var testTraceDueDate = DateTime.Today.AddDays(2);
const string testReservationId = "REALRESERVATION_1";
const int resultTraceId = 10;
const string resultPropertyId = "PROP";
var createTraceItemModel = new CreateTraceItemModel
{
Title = testTraceTitle,
Description = testTraceDescription,
DueDate = testTraceDueDate,
ReservationId = testReservationId
};
var resultTraceDto = new TraceDto
{
Id = resultTraceId,
Title = testTraceTitle,
Description = testTraceDescription.Some(),
State = TraceState.Active,
DueDate = testTraceDueDate.ToLocalDateTime().Date,
PropertyId = resultPropertyId,
ReservationId = testReservationId.Some()
};
_traceServiceMock.Setup(x => x.CreateTraceFromReservationAsync(It.Is <CreateTraceDto>(
t => t.Title == testTraceTitle &&
t.Description.ValueOrFailure() == testTraceDescription &&
t.DueDate == testTraceDueDate.ToLocalDateTime().Date&&
t.ReservationId.ValueOrFailure() == testReservationId &&
string.IsNullOrWhiteSpace(t.PropertyId))))
.ReturnsAsync(resultTraceDto);
var result = await _traceModifierService.CreateTraceWithReservationIdAsync(createTraceItemModel);
result.Success.Should().BeTrue();
var resultContent = result.Result.ValueOrFailure();
resultContent.Id.Should().Be(resultTraceId);
resultContent.Title.Should().Be(testTraceTitle);
resultContent.Description.Should().Be(testTraceDescription);
resultContent.State.Should().Be(TraceState.Active);
resultContent.DueDate.Should().Be(testTraceDueDate);
resultContent.ReservationId = testReservationId;
}
public static TraceItemModel ConvertToTraceItemModel(this TraceDto dto)
{
Check.NotNull(dto, nameof(dto));
return(new TraceItemModel
{
Id = dto.Id,
Title = dto.Title,
Description = dto.Description.ValueOr(string.Empty),
State = dto.State,
DueDate = dto.DueDate.ToDateTimeUnspecified(),
PropertyId = dto.PropertyId,
ReservationId = dto.ReservationId.ValueOr(string.Empty),
AssignedRole = dto.AssignedRole.ValueOr(string.Empty)
});
}
internal static void AddTraceToTraceList(TraceDto trace)
{
if (TraceList.ContainsKey(trace.Writer))
{
TraceList[trace.Writer].Enqueue(trace);
}
else
{
var traceWriterList = new ConcurrentQueue <TraceDto>();
traceWriterList.Enqueue(trace);
TraceList.Add(trace.Writer, traceWriterList);
}
CalculateWriterSize(trace);
SparseWriter(trace.Writer);
}
private TraceDto registerErrorInTrace(Exception exception)
{
var exeptionData = new Dictionary <string, string>();
foreach (KeyValuePair <string, string> item in exception.Data)
{
exeptionData.Add(item.Key, item.Value);
}
TraceDto expTrace = new TraceDto
{
Writer = "TraceHost",
Data = exeptionData,
Level = 1,
Message = exception.Message + "\t Details:" + exception?.InnerException?.Message,
TraceKey = "TraceHostError"
};
ETWRegistrant.AddTraceToTraceList(expTrace);
return(expTrace);
}
public void Exception(Exception exception, string traceKey = "")
{
// if (IsTraceEnabled(traceKey))
// {
//var data = GetDataFromException(exception, null);
//var serializedData = Newtonsoft.Json.JsonConvert.SerializeObject(data);
//var message = Newtonsoft.Json.JsonConvert.SerializeObject(exception);
//this.Exception(message, this.AppName, serializedData, traceKey);
//
var customException = new ExceptionInfo(exception);
var trace = new TraceDto
{
Data = GetDataFromException(customException, null),
Message = Newtonsoft.Json.JsonConvert.SerializeObject(customException),
Writer = AppName,
TraceKey = traceKey
};
this.Exception(trace.Message, trace.Writer, trace.SerializedData, trace.TraceKey);
// }
}
private void OpenDetailsWindow(TraceDto selectedSource)
{
var detailsWindow = new TraceDetailsWindow(selectedSource);
detailsWindow.Show();
}
public TraceViewModel(TraceDto trace)
{
Data = trace;
}
public MetaResponseDto Post(TraceDto trace)
{
this.Logger.LogWarning(trace.Content);
return(new MetaResponseDto());
}
