public LayOutViewModel(IServiceNavigation navigation, IServiceMessage message)
{
_navigation = navigation;
_message = message;
LblFollow = "33";
}
private static bool VerifyServiceMessage(TableRow row, IServiceMessage serviceMessage)
{
var messageNameRegex = new Regex(row[""]);
if (!messageNameRegex.IsMatch(serviceMessage.Name))
{
return(false);
}
foreach (var key in row.Keys)
{
if (string.IsNullOrWhiteSpace(key))
{
continue;
}
string rowValue;
if (!row.TryGetValue(key, out rowValue))
{
continue;
}
var serviceMessageValue = serviceMessage.GetValue(key) ?? "";
var rowValueRegex = new Regex(rowValue ?? "");
if (!rowValueRegex.IsMatch(serviceMessageValue))
{
return(false);
}
}
return(true);
}
public IServiceMessage UpdateServiceMessage(IServiceMessage message)
{
return(message.DefaultValue != null ? message : new PatchedServiceMessage(message)
{
{ "flowId", FlowId }
});
}
private Text ToText(IServiceMessage message)
{
var str = _messageFormatter.FormatMessage(message);
str = str.Replace("##teamcity", "@@teamcity");
return(new Text(str));
}
public Message(IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
Name = message.Name;
FlowIdAttr = message.GetValue("flowId");
Assert.IsNotEmpty(FlowIdAttr);
NameAttr = message.GetValue("name");
ParentAttr = message.GetValue("parent");
CaptureStandardOutputAttr = message.GetValue("captureStandardOutput");
DurationAttr = message.GetValue("duration");
OutAttr = message.GetValue("duration");
MessageAttr = message.GetValue("message");
TextAttr = message.GetValue("text");
DetailsAttr = message.GetValue("details");
TcTagsAttr = message.GetValue("tc:tags");
TestNameAttr = message.GetValue("testName");
TypeAttr = message.GetValue("type");
ValueAttr = message.GetValue("value");
}
private static string CreateErrorMessage(TableRow row, IServiceMessage serviceMessage)
{
var rowInfo = string.Join(", ", from key in row.Keys select $"{key} = {row[key]}");
var serviceMessageInfo = string.Join(", ", from key in serviceMessage.Keys select $"{key} = {serviceMessage.GetValue(key)}");
return($"Expected service message should has:\n{rowInfo}\nbut it has:\n{serviceMessageInfo}");
}
public override void AddServiceMessage(IServiceMessage serviceMessage)
{
if (serviceMessage.DefaultValue != null)
{
base.AddServiceMessage(serviceMessage);
return;
}
if (serviceMessage.Name == "flowStarted")
{
serviceMessage = new PatchedServiceMessage(serviceMessage)
{
{ "parent", FlowToString(serviceMessage.GetValue("parent")) }
}
}
;
var flowId = serviceMessage.GetValue("flowId");
if (flowId != null)
{
serviceMessage = new PatchedServiceMessage(serviceMessage)
{
{ "flowId", FlowToString(flowId) }
}
}
;
base.AddServiceMessage(serviceMessage);
}
public void AddServiceMessage(IServiceMessage serviceMessage)
{
if (serviceMessage == null)
{
throw new ArgumentNullException(nameof(serviceMessage));
}
_processor.AddServiceMessage(_updaters.Aggregate(serviceMessage, (current, updater) => updater.UpdateServiceMessage(current)));
}
public void Write([NotNull] IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
_writer.WriteRawMessage(message);
}
protected void PostMessage(IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
myTarget.AddServiceMessage(message);
}
public void AddServiceMessage(IServiceMessage serviceMessage)
{
if (serviceMessage == null)
{
throw new ArgumentNullException(nameof(serviceMessage));
}
_printer(_formatter.FormatMessage(serviceMessage));
}
/// <summary>
/// Serializes service message
/// </summary>
/// <param name="serviceMessage">parser service message</param>
/// <returns></returns>
public string FormatMessage(IServiceMessage serviceMessage)
{
if (serviceMessage.DefaultValue != null)
{
return(FormatMessage(serviceMessage.Name, serviceMessage.DefaultValue));
}
return(FormatMessage(serviceMessage.Name, serviceMessage.Keys.Select(key => new ServiceMessageProperty(key, serviceMessage.GetValue(key) ?? ""))));
}
public MainPresenter(IMainForm mainForm, IServiceMessage serviceMessage, IAreaCalculation areaCalculation)
{
this.mainForm = mainForm;
this.serviceMessage = serviceMessage;
this.areaCalculation = areaCalculation;
this.mainForm.CalculateAreaClick += MainForm_CalculateAreaClick;
}
public ListHttpViewModel(IServiceNavigation navigation, IServiceMessage message, IGetService service)
{
_service = service;
_navigation = navigation;
_message = message;
collection = new ObservableCollection <DataModel>();
LoadItens();
}
public HomeViewModel(IServiceNavigation navigation, IServiceMessage message)
{
_navigation = navigation;
_message = message;
_service = new MenuService();
ItensMenu = new FlowObservableCollection <MenuModel>();
LoadItensMenu();
}
/// <summary>
/// Copy constructor
/// </summary>
/// <param name="message">service message to copy from</param>
public ServiceMessage(IServiceMessage message)
: this(message.Name)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
AddRange(message.Keys.ToDictionary(x => x, message.GetValue));
}
public static T CreateFrom(IServiceMessage caller)
{
var message = Create();
message.CorrelationId = caller.CorrelationId == Guid.Empty
? caller.MessageId
: caller.CorrelationId;
return(message);
}
public PatchedServiceMessage([NotNull] IServiceMessage message)
: base(message.Name)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
AddRange(message.Keys.ToDictionary(x => x, message.GetValue));
}
public void WriteRawMessage(IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
CheckConsistency();
_processor.AddServiceMessage(message);
}
public static void FillPropertiesFromBrokeredMessageToServiceMessage(this IServiceMessage msg)
{
var m = (AzureServiceBusMessage)msg;
var t = m.Core;
var dicT = m.Properties;
var dicF = t.Properties;
CopyObjectsAmongDics(dicF, dicT);
}
public IServiceMessage UpdateServiceMessage(IServiceMessage message)
{
if (message.DefaultValue != null)
{
return(message);
}
return(new PatchedServiceMessage(message)
{
{ "flowId", myFlowId }
});
}
public IServiceMessage UpdateServiceMessage(IServiceMessage message)
{
if (message.DefaultValue != null)
{
return(message);
}
return(new PatchedServiceMessage(message)
{
{ "timestamp", myTimeService().ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.fff", CultureInfo.InvariantCulture) + "+0000" }
});
}
public IServiceMessage[] RecentMessages(int count)
{
int validCount = Math.Min(count, messages.Count);
IServiceMessage[] result = new IServiceMessage[validCount];
for (int i = 0; i < validCount; i++)
{
result[i] = messages[messages.Count - validCount + i];
}
return(result);
}
public void TriggerEvent(string eventName, IServiceMessage EventArgs)
{
if (eventOfferers.ContainsKey(eventName))
{
eventOfferers[eventName].HandleEvent(eventName, EventArgs);
}
else
{
Debug.Log($"No event with name {eventName} is registered");
}
}
/// <summary>
/// Serializes service message
/// </summary>
/// <param name="serviceMessage">parser service message</param>
/// <returns></returns>
public string FormatMessage(IServiceMessage serviceMessage)
{
if (serviceMessage == null)
{
throw new ArgumentNullException(nameof(serviceMessage));
}
if (serviceMessage.DefaultValue != null)
{
return(FormatMessage(serviceMessage.Name, serviceMessage.DefaultValue));
}
return(FormatMessage(serviceMessage.Name, serviceMessage.Keys.Select(key => new ServiceMessageProperty(key, serviceMessage.GetValue(key) ?? ""))));
}
public bool HandleMessage(IServiceMessage message)
{
if (message is ServerRegistrationMessage)
{
lock (syncObject)
{
ServerRegistrationMessage serverRegistrationMessage = (ServerRegistrationMessage)message;
serverDetails = serverRegistrationMessage.ServerDetails;
}
return(true);
}
return(false);
}
protected void HandleException <T, TException>(IServiceMessage <T> msg, TException exception) where TException : Exception
{
switch (exception)
{
case ServiceException serviceException:
msg.AddMessages(serviceException.Errors);
msg.ResCode = serviceException.ResCode;
break;
default:
msg.AddMessage(exception.Message);
break;
}
}
public IActionResult ProcessService <T>(IServiceMessage <T> msg)
{
if (msg.Success)
{
return(Ok(msg.Data));
}
if (msg.ResCode.HasValue)
{
return(StatusCode((int)msg.ResCode, msg.ErrorMessages));
}
return(BadRequest(msg.ErrorMessages));
}
public IServiceMessage UpdateServiceMessage(IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
if (message.DefaultValue != null)
{
return(message);
}
return(new PatchedServiceMessage(message)
{
{ "timestamp", _timeService().ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.fff", CultureInfo.InvariantCulture) + "+0000" }
});
}
public Message(IServiceMessage message)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
Name = message.Name;
FlowIdAttr = message.GetValue("flowId") ?? string.Empty;
NameAttr = message.GetValue("name");
ParentAttr = message.GetValue("parent");
CaptureStandardOutputAttr = message.GetValue("captureStandardOutput");
DurationAttr = message.GetValue("duration");
OutAttr = message.GetValue("duration");
MessageAttr = message.GetValue("message");
DetailsAttr = message.GetValue("details");
TcTagsAttr = message.GetValue("tc:tags");
IdentityAttr = message.GetValue("identity");
DescriptionAttr = message.GetValue("description");
KeyAttr = message.GetValue("key");
ValueAttr = message.GetValue("value");
}
