public TicketItemProperty ToggleProperty(MenuItemPropertyGroup group, MenuItemProperty menuItemProperty)
{
var ti = _model.ToggleProperty(group, menuItemProperty);
if (ti != null)
{
RuleExecutor.NotifyEvent(RuleEventNames.ModifierSelected,
new
{
Ticket = AppServices.MainDataContext.SelectedTicket,
TicketItem = Model,
TicketTag = AppServices.MainDataContext.SelectedTicket.Tag,
MenuItemName = _model.MenuItemName,
ModifierGroupName = group.Name,
ModifierName = menuItemProperty.Name,
ModifierPrice = ti.PropertyPrice.Amount + ti.VatAmount,
ModifierQuantity = ti.Quantity,
IsRemoved = !_model.Properties.Contains(ti),
IsPriceAddedToParentPrice = ti.CalculateWithParentPrice,
TotalPropertyCount = Model.Properties.Count,
TotalModifierQuantity = Model.Properties.Where(x => x.PropertyGroupId == group.Id).Sum(x => x.Quantity),
TotalModifierPrice = Model.Properties.Where(x => x.PropertyGroupId == group.Id).Sum(x => x.PropertyPrice.Amount + x.VatAmount)
});
}
RefreshProperties();
RaisePropertyChanged("Properties");
RaisePropertyChanged("TotalPrice");
RaisePropertyChanged("Quantity");
return(ti);
}
public void UpdateTag(TicketTagGroup tagGroup, TicketTag ticketTag)
{
Model.SetTagValue(tagGroup.Name, ticketTag.Name);
if (tagGroup.Numerator != null)
{
Model.TicketNumber = "";
AppServices.MainDataContext.UpdateTicketNumber(Model, tagGroup.Numerator);
}
if (ticketTag.AccountId > 0)
{
AppServices.MainDataContext.AssignCustomerToTicket(Model,
Dao.SingleWithCache <Customer>(x => x.Id == ticketTag.AccountId));
}
ClearSelectedItems();
var tagData = new TicketTagData {
Action = tagGroup.Action, TagName = tagGroup.Name, TagValue = ticketTag.Name, NumericValue = tagGroup.NumericTags || tagGroup.PriceTags ? Convert.ToDecimal(ticketTag.Name) : 0
};
RuleExecutor.NotifyEvent(RuleEventNames.TicketTagSelected,
new
{
Ticket = Model,
tagData.TagName,
tagData.TagValue,
tagData.NumericValue,
TicketTag = Model.Tag
});
tagData.PublishEvent(EventTopicNames.TagSelectedForSelectedTicket);
}
public static void AssignTableToSelectedTicket(int locationId)
{
var oldLocation = AppServices.MainDataContext.SelectedTicket != null ? AppServices.MainDataContext.SelectedTicket.LocationName : "";
AppServices.MainDataContext.AssignTableToSelectedTicket(locationId);
RuleExecutor.NotifyEvent(RuleEventNames.TicketLocationChanged, new { Ticket = AppServices.MainDataContext.SelectedTicket, OldLocation = oldLocation, NewLocation = AppServices.MainDataContext.SelectedTicket.LocationName });
}
private static void RegisterNotifiers()
{
EventServiceFactory.EventService.GetEvent <GenericEvent <Message> >().Subscribe(x =>
{
if (x.Topic == EventTopicNames.MessageReceivedEvent && x.Value.Command == "ActionMessage")
{
RuleExecutor.NotifyEvent(RuleEventNames.MessageReceived, new { Command = x.Value.Data });
}
if (x.Topic == EventTopicNames.MessageReceivedEvent && x.Value.Command == "SHUTDOWN")
{
RuleExecutor.NotifyEvent(RuleEventNames.MessageReceived, new { Command = "SHUTDOWN" });
}
});
EventServiceFactory.EventService.GetEvent <GenericEvent <User> >().Subscribe(x =>
{
if (x.Topic == EventTopicNames.UserLoggedIn)
{
RuleExecutor.NotifyEvent(RuleEventNames.UserLoggedIn, new { User = x.Value, UserName = x.Value.Name, RoleName = x.Value.UserRole.Name });
}
if (x.Topic == EventTopicNames.UserLoggedOut)
{
RuleExecutor.NotifyEvent(RuleEventNames.UserLoggedOut, new { User = x.Value, UserName = x.Value.Name, RoleName = x.Value.UserRole.Name });
}
});
}
public async Task ExecuteAsync(RuleImp rule)
{
foreach (var item in Order.Items)
{
this.GetService <OrderStateService>().CurrentOrderItem = item;
await RuleExecutor.ExecuteAsync(this, rule);
}
}
private void OnStartOfDayExecute(string obj)
{
AppServices.MainDataContext.StartWorkPeriod(StartDescription, CashAmount, CreditCardAmount, TicketAmount);
Refresh();
AppServices.MainDataContext.CurrentWorkPeriod.PublishEvent(EventTopicNames.WorkPeriodStatusChanged);
RuleExecutor.NotifyEvent(RuleEventNames.WorkPeriodStarts, new { WorkPeriod = AppServices.MainDataContext.CurrentWorkPeriod, UserName = AppServices.CurrentLoggedInUser.Name });
InteractionService.UserIntraction.GiveFeedback(Resources.StartingWorkPeriodCompleted);
EventServiceFactory.EventService.PublishEvent(EventTopicNames.ActivateNavigation);
}
private void OnEndOfDayExecute(string obj)
{
StopTimer();
AppServices.MainDataContext.StopWorkPeriod(EndDescription);
Refresh();
AppServices.MainDataContext.CurrentWorkPeriod.PublishEvent(EventTopicNames.WorkPeriodStatusChanged);
RuleExecutor.NotifyEvent(RuleEventNames.WorkPeriodEnds, new { WorkPeriod = AppServices.MainDataContext.CurrentWorkPeriod, UserName = AppServices.CurrentLoggedInUser.Name });
InteractionService.UserIntraction.GiveFeedback(Resources.WorkPeriodEndsMessage);
EventServiceFactory.EventService.PublishEvent(EventTopicNames.ActivateNavigation);
}
private void ProcessPayment(PaymentType paymentType)
{
var tenderedAmount = GetTenderedValue();
var originalTenderedAmount = tenderedAmount;
var remainingTicketAmount = GetPaymentValue();
var returningAmount = 0m;
if (tenderedAmount == 0)
{
tenderedAmount = remainingTicketAmount;
}
if (tenderedAmount > remainingTicketAmount)
{
returningAmount = tenderedAmount - remainingTicketAmount;
tenderedAmount = remainingTicketAmount;
}
if (tenderedAmount > 0)
{
if (tenderedAmount > AppServices.MainDataContext.SelectedTicket.GetRemainingAmount())
{
tenderedAmount = AppServices.MainDataContext.SelectedTicket.GetRemainingAmount();
}
TicketViewModel.AddPaymentToSelectedTicket(tenderedAmount, paymentType);
PaymentAmount = (GetPaymentValue() - tenderedAmount).ToString("#,#0.00");
LastTenderedAmount = tenderedAmount <= AppServices.MainDataContext.SelectedTicket.GetRemainingAmount()
? tenderedAmount.ToString("#,#0.00")
: AppServices.MainDataContext.SelectedTicket.GetRemainingAmount().ToString("#,#0.00");
}
ReturningAmount = string.Format(Resources.ChangeAmount_f, returningAmount.ToString(LocalSettings.DefaultCurrencyFormat));
ReturningAmountVisibility = returningAmount > 0 ? Visibility.Visible : Visibility.Collapsed;
if (returningAmount > 0)
{
RuleExecutor.NotifyEvent(RuleEventNames.ChangeAmountChanged,
new { Ticket = SelectedTicket.Model, TicketAmount = SelectedTicket.Model.TotalAmount, ChangeAmount = returningAmount, TenderedAmount = originalTenderedAmount });
}
if (returningAmount == 0 && AppServices.MainDataContext.SelectedTicket.GetRemainingAmount() == 0)
{
ClosePaymentScreen();
}
else
{
PersistMergedItems();
}
}
private decimal ProcessTransaction(TransactionRequest request)
{
//To insert fresh Record
InsertOperation repo = new InsertOperation();
repo.InsertFreshTransaction(request);
RuleExecutor rule = new RuleExecutor();
var score = rule.RunRules(request.Transactionid);
return(score);
}
public TicketItemViewModel AddNewItem(int menuItemId, decimal quantity, bool gift, string defaultProperties, string portionName)
{
if (!Model.CanSubmit)
{
return(null);
}
ClearSelectedItems();
var menuItem = AppServices.DataAccessService.GetMenuItem(menuItemId);
if (menuItem.Portions.Count == 0)
{
return(null);
}
var portion = menuItem.Portions[0];
if (!string.IsNullOrEmpty(portionName) && menuItem.Portions.Count(x => x.Name == portionName) > 0)
{
portion = menuItem.Portions.First(x => x.Name == portionName);
}
var departmentId = AppServices.CurrentTerminal.DepartmentId > 0
? AppServices.MainDataContext.SelectedDepartment.Id
: Model.DepartmentId;
var ti = Model.AddTicketItem(AppServices.CurrentLoggedInUser.Id, departmentId, menuItem, portion.Name, AppServices.MainDataContext.SelectedDepartment.PriceTag, defaultProperties);
ti.Quantity = quantity > 9 ? decimal.Round(quantity / portion.Multiplier, LocalSettings.Decimals) : quantity;
ti.Gifted = gift;
var ticketItemViewModel = new TicketItemViewModel(ti);
_items.Add(ticketItemViewModel);
RecalculateTicket();
RuleExecutor.NotifyEvent(RuleEventNames.TicketLineAdded, new
{
Ticket = AppServices.MainDataContext.SelectedTicket,
TicketItem = ti,
TicketId = AppServices.MainDataContext.SelectedTicket.Id,
TicketTag = AppServices.MainDataContext.SelectedTicket.Tag,
Quantity = quantity,
Model.CustomerId,
Model.CustomerName,
Model.CustomerGroupCode,
MenuItemName = menuItem.Name,
MenuItemGroupCode = menuItem.GroupCode
});
ticketItemViewModel.PublishEvent(EventTopicNames.TicketItemAdded);
return(ticketItemViewModel);
}
public void UpdatePortion(MenuItemPortion portion, string priceTag)
{
_model.UpdatePortion(portion, priceTag, AppServices.MainDataContext.GetVatTemplate(portion.MenuItemId));
RuleExecutor.NotifyEvent(RuleEventNames.PortionSelected,
new
{
Ticket = AppServices.MainDataContext.SelectedTicket,
TicketItem = Model,
TicketTag = AppServices.MainDataContext.SelectedTicket.Tag,
MenuItemName = _model.MenuItemName,
PortionName = portion.Name,
PortionPrice = _model.Price
});
RaisePropertyChanged("Description");
RaisePropertyChanged("TotalPrice");
}
private static void OnCronTrigger(CronObject cronobject)
{
using (var workspace = WorkspaceFactory.Create())
{
var trigger = workspace.Single <Trigger>(x => x.Id == ((Trigger)cronobject.Object).Id);
if (trigger != null)
{
trigger.LastTrigger = DateTime.Now;
workspace.CommitChanges();
if (AppServices.ActiveAppScreen != AppScreens.Dashboard)
{
RuleExecutor.NotifyEvent(RuleEventNames.TriggerExecuted, new { TriggerName = trigger.Name });
}
}
else
{
cronobject.Stop();
}
}
}
public void CancelItems(IEnumerable <TicketItemViewModel> ticketItems, int userId)
{
VoidItems(ticketItems, 0, userId);
foreach (var ticketItemViewModel in ticketItems)
{
var mi = AppServices.DataAccessService.GetMenuItem(ticketItemViewModel.Model.MenuItemId);
RuleExecutor.NotifyEvent(RuleEventNames.TicketLineCancelled, new
{
Ticket = AppServices.MainDataContext.SelectedTicket,
TicketItem = ticketItemViewModel.Model,
TicketTag = AppServices.MainDataContext.SelectedTicket.Tag,
ticketItemViewModel.Quantity,
Model.CustomerId,
Model.CustomerName,
Model.CustomerGroupCode,
ticketItemViewModel.Model.MenuItemName,
MenuItemGroupCode = mi.GroupCode
});
}
}
public async Task <IActionResult> Index([FromBody] RuleModel request)
{
try
{
var sampleDefinition = new RuleDefinition()
{
//EngineCode = "{if (Values[\"IsCallEvent\"].ToString() == \"true\" & ((long)Values[\"StatusId\"] == 8005 | (long)Values[\"StatusId\"] == 8010)) { if ((long)Values[\"CallDuration\"] >= 127) Values[\"StatusId\"] = (long)8015; }}"
//EngineCode = "{ if (Values[\"IsCallEvent\"].ToBool() == true & (Values[\"StatusId\"].ToInt() == 8005 | Values[\"StatusId\"].ToInt() == 8010)) { if (Values[\"CallDuration\"].ToNumber() >= 127) Values[\"StatusId\"] = 8015; else if (Values[\"CallDuration\"].ToNumber() < 127 ) Values[\"StatusId\"] = 8010; }}"
EngineCode = "{ if (Values[\"IsCallEvent\"].ToBool() == true & Values[\"StatusId\"].ToInt().IsOneOf(8005, 8010)) { if (Values[\"CallDuration\"].ToNumber() >= 127) Values[\"StatusId\"] = 8015; else if (Values[\"CallDuration\"].ToNumber() < 127 ) Values[\"StatusId\"] = 8010; }}"
};
var executor = new RuleExecutor(sampleDefinition);
var result = await executor.ApplyAsync(request);
return(Ok(result));
}
catch (Exception ex)
{
return(Ok());
}
}
public static void RecalculateTicket(Ticket ticket)
{
var total = ticket.TotalAmount;
AppServices.MainDataContext.Recalculate(ticket);
if (total != ticket.TotalAmount)
{
RuleExecutor.NotifyEvent(RuleEventNames.TicketTotalChanged,
new
{
Ticket = ticket,
PreviousTotal = total,
TicketTotal = ticket.GetSum(),
DiscountTotal = ticket.GetDiscountAndRoundingTotal(),
GiftTotal = ticket.GetTotalGiftAmount(),
PaymentTotal = ticket.GetPaymentAmount(),
ticket.CustomerName,
ticket.CustomerId,
ticket.CustomerGroupCode
});
}
}
public static void AddPaymentToSelectedTicket(decimal amount, PaymentType paymentType)
{
var ticket = AppServices.MainDataContext.SelectedTicket;
var departmentId = AppServices.CurrentTerminal.DepartmentId > 0
? AppServices.MainDataContext.SelectedDepartment.Id
: ticket.DepartmentId;
ticket.AddPayment(DateTime.Now, amount, paymentType, AppServices.CurrentLoggedInUser.Id, departmentId);
string paymentName = Resources.Cash;
if (paymentType == PaymentType.CreditCard)
{
paymentName = Resources.CreditCard;
}
if (paymentType == PaymentType.Ticket)
{
paymentName = Resources.Voucher;
}
RuleExecutor.NotifyEvent(RuleEventNames.PaymentReceived,
new { Ticket = ticket, PaymentType = paymentName, Amount = amount, TicketTag = ticket.Tag, ticket.CustomerId, ticket.CustomerName, ticket.CustomerGroupCode, SelectedLinesCount = ticket.GetPaidItems().Count() });
}
public async Task <HttpResponseMessage> RunAsync(HttpRequestMessage req, CancellationToken cancellationToken)
{
_log.LogDebug($"Context: {_context.InvocationId} {_context.FunctionName} {_context.FunctionDirectory} {_context.FunctionAppDirectory}");
var ruleName = _context.FunctionName;
var aggregatorVersion = GetCustomAttribute <System.Reflection.AssemblyInformationalVersionAttribute>()?.InformationalVersion;
_log.LogInformation($"Aggregator v{aggregatorVersion} executing rule '{ruleName}'");
cancellationToken.ThrowIfCancellationRequested();
// Get request body
var eventData = await GetWebHookEvent(req);
if (eventData == null)
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Request body is empty"));
}
// sanity check
if (!DevOpsEvents.IsValidEvent(eventData.EventType) ||
eventData.PublisherId != DevOpsEvents.PublisherId)
{
return(req.CreateErrorResponse(HttpStatusCode.BadRequest, "Not a good Azure DevOps post..."));
}
var eventContext = CreateContextFromEvent(eventData);
if (eventContext.IsTestEvent())
{
return(req.CreateTestEventResponse(aggregatorVersion, ruleName));
}
var configContext = GetConfigurationContext();
var configuration = AggregatorConfiguration.ReadConfiguration(configContext)
.UpdateFromUrl(ruleName, req.RequestUri);
var logger = new ForwarderLogger(_log);
var ruleProvider = new AzureFunctionRuleProvider(logger, _context.FunctionDirectory);
var ruleExecutor = new RuleExecutor(logger, configuration);
using (_log.BeginScope($"WorkItem #{eventContext.WorkItemPayload.WorkItem.Id}"))
{
try
{
var rule = await ruleProvider.GetRule(ruleName);
var execResult = await ruleExecutor.ExecuteAsync(rule, eventContext, cancellationToken);
if (string.IsNullOrEmpty(execResult))
{
return(req.CreateResponse(HttpStatusCode.OK));
}
else
{
_log.LogInformation($"Returning '{execResult}' from '{rule.Name}'");
return(req.CreateResponse(HttpStatusCode.OK, execResult));
}
}
catch (Exception ex)
{
_log.LogWarning($"Rule '{ruleName}' failed: {ex.Message}");
return(req.CreateErrorResponse(HttpStatusCode.NotImplemented, ex));
}
}
}
protected override void InitializeShell()
{
LocalizeDictionary.ChangeLanguage(LocalSettings.CurrentLanguage);
LocalSettings.SetTraceLogPath("app");
InteractionService.UserIntraction = ServiceLocator.Current.GetInstance <IUserInteraction>();
InteractionService.UserIntraction.ToggleSplashScreen();
AppServices.MainDispatcher = Application.Current.Dispatcher;
AppServices.MessagingService.RegisterMessageListener(new MessageListener());
if (LocalSettings.StartMessagingClient)
{
AppServices.MessagingService.StartMessagingClient();
}
GenericRuleRegistator.RegisterOnce();
PresentationServices.Initialize();
base.InitializeShell();
try
{
var creationService = new DataCreationService();
creationService.CreateData();
}
catch (Exception e)
{
if (!string.IsNullOrEmpty(LocalSettings.ConnectionString))
{
var connectionString =
InteractionService.UserIntraction.GetStringFromUser(
"Connection String",
Resources.DatabaseErrorMessage + e.Message,
LocalSettings.ConnectionString);
var cs = String.Join(" ", connectionString);
if (!string.IsNullOrEmpty(cs))
{
LocalSettings.ConnectionString = cs.Trim();
}
AppServices.LogError(e, Resources.CurrentErrorLoggedMessage);
}
else
{
AppServices.LogError(e);
LocalSettings.ConnectionString = "";
}
LocalSettings.SaveSettings();
Environment.Exit(1);
}
if (string.IsNullOrEmpty(LocalSettings.MajorCurrencyName))
{
LocalSettings.MajorCurrencyName = Resources.Dollar;
LocalSettings.MinorCurrencyName = Resources.Cent;
LocalSettings.PluralCurrencySuffix = Resources.PluralCurrencySuffix;
}
Application.Current.MainWindow = (Shell)Shell;
Application.Current.MainWindow.Show();
InteractionService.UserIntraction.ToggleSplashScreen();
TriggerService.UpdateCronObjects();
RuleExecutor.NotifyEvent(RuleEventNames.ApplicationStarted, new { CommandLineArguments = LocalSettings.StartupArguments });
}
public async Task <IActionResult> RunAsync(/*HttpRequest request, */ WebHookEvent eventData, CancellationToken cancellationToken)
{
_log.LogDebug($"Context: {_executionContext.InvocationId} {_executionContext.FunctionName} {_executionContext.FunctionDirectory} {_executionContext.FunctionAppDirectory}");
var ruleName = _executionContext.FunctionName;
var aggregatorVersion = RequestHelper.AggregatorVersion;
_log.LogInformation($"Aggregator v{aggregatorVersion} executing rule '{ruleName}'");
cancellationToken.ThrowIfCancellationRequested();
if (eventData == null)
{
return(BadRequest("Request body is empty"));
}
// sanity check
if (!DevOpsEvents.IsValidEvent(eventData.EventType) ||
eventData.PublisherId != DevOpsEvents.PublisherId)
{
_log.LogDebug("return BadRequest");
return(BadRequest(new { Error = "Not a good Azure DevOps post..." }));
}
var helper = new RequestHelper(_log);
var eventContext = helper.CreateContextFromEvent(eventData);
if (eventContext.IsTestEvent())
{
Response.AddCustomHeaders(aggregatorVersion, ruleName);
return(RespondToTestEventMessage(aggregatorVersion, ruleName));
}
var configContext = GetConfigurationContext();
var configuration = AggregatorConfiguration.ReadConfiguration(configContext)
.UpdateFromUrl(ruleName, GetRequestUri());
var logger = new ForwarderLogger(_log);
var ruleProvider = new AzureFunctionRuleProvider(logger, _executionContext.FunctionDirectory);
var ruleExecutor = new RuleExecutor(logger, configuration);
using (_log.BeginScope($"WorkItem #{eventContext.WorkItemPayload.WorkItem.Id}"))
{
try
{
var rule = await ruleProvider.GetRule(ruleName);
var execResult = await ruleExecutor.ExecuteAsync(rule, eventContext, cancellationToken);
if (string.IsNullOrEmpty(execResult))
{
return(Ok());
}
else
{
_log.LogInformation($"Returning '{execResult}' from '{rule.Name}'");
return(Ok(execResult));
}
}
catch (Exception ex)
{
_log.LogWarning($"Rule '{ruleName}' failed: {ex.Message}");
return(BadRequest(ex.Message));
}
}
}
public void ExecutingNonExistingRule()
{
var ruleExecuter = new RuleExecutor();
Assert.AreEqual(ruleExecuter.Execute(string.Empty, string.Empty), string.Empty);
}
public async Task <IActionResult> PostAsync(WebHookEvent eventData, string ruleName, CancellationToken cancellationToken)
{
var aggregatorVersion = RequestHelper.AggregatorVersion;
_log.LogInformation($"Aggregator v{aggregatorVersion} executing rule '{ruleName}'");
var webHookStartEvent = new EventTelemetry()
{
Name = "WebHookEvent Start"
};
webHookStartEvent.Properties["rule"] = ruleName;
webHookStartEvent.Properties["eventType"] = eventData?.EventType;
webHookStartEvent.Properties["resourceVersion"] = eventData?.ResourceVersion;
Telemetry.TrackEvent(webHookStartEvent);
if (eventData == null)
{
return(BadRequest("Request body is empty"));
}
// sanity check
if (!DevOpsEvents.IsValidEvent(eventData.EventType) ||
eventData.PublisherId != DevOpsEvents.PublisherId)
{
_log.LogDebug("return BadRequest");
return(BadRequest(new { Error = "Not a good Azure DevOps post..." }));
}
var helper = new RequestHelper(_log);
var eventContext = helper.CreateContextFromEvent(eventData);
if (eventContext.IsTestEvent())
{
Response.AddCustomHeaders(aggregatorVersion, ruleName);
return(RespondToTestEventMessage(aggregatorVersion, ruleName));
}
var configContext = _configuration;
var configuration = AggregatorConfiguration.ReadConfiguration(configContext)
.UpdateFromUrl(ruleName, GetRequestUri());
var logger = new ForwarderLogger(_log);
var ruleProvider = new AspNetRuleProvider(logger, _configuration);
var ruleExecutor = new RuleExecutor(logger, configuration);
using (_log.BeginScope($"WorkItem #{eventContext.WorkItemPayload.WorkItem.Id}"))
{
try
{
var rule = await ruleProvider.GetRule(ruleName);
var ruleStartEvent = new EventTelemetry()
{
Name = "Rule Exec Start"
};
ruleStartEvent.Properties["rule"] = rule.Name;
ruleStartEvent.Properties["ImpersonateExecution"] = rule.ImpersonateExecution.ToString();
ruleStartEvent.Properties["EnableRevisionCheck"] = rule.Settings.EnableRevisionCheck.ToString();
ruleStartEvent.Properties["eventType"] = eventContext.EventType;
Telemetry.TrackEvent(ruleStartEvent);
var ruleExecTimer = new Stopwatch();
ruleExecTimer.Start();
var execResult = await ruleExecutor.ExecuteAsync(rule, eventContext, cancellationToken);
ruleExecTimer.Stop();
var ruleEndEvent = new EventTelemetry()
{
Name = "Rule Exec End"
};
ruleEndEvent.Properties["rule"] = ruleName;
ruleEndEvent.Metrics["duration"] = ruleExecTimer.ElapsedMilliseconds;
Telemetry.TrackEvent(ruleEndEvent);
if (string.IsNullOrEmpty(execResult))
{
return(Ok());
}
else
{
_log.LogInformation($"Returning '{execResult}' from '{rule.Name}'");
return(Ok(execResult));
}
}
catch (Exception ex)
{
_log.LogWarning($"Rule '{ruleName}' failed: {ex.Message}");
Telemetry.TrackException(ex);
return(BadRequest(ex.Message));
}
}
}
public static void CreateNewTicket()
{
AppServices.MainDataContext.CreateNewTicket();
RuleExecutor.NotifyEvent(RuleEventNames.TicketCreated, new { Ticket = AppServices.MainDataContext.SelectedTicket });
}
