public ActionResult DeleteConfirmed(int id) { ServiceEvent serviceEvent = Repository.getServiceEvent(id); Repository.deleteServiceEvent(serviceEvent); return(RedirectToAction("Index")); }
public ActionResult AddEvent(AddEventModel viewModel) { var session = Session["Login"] as SessionModel; if (session != null) { using (var db = new MechAppProjectEntities()) { var serviceId = Convert.ToInt32(viewModel.WorkshopService.Value); var service = db.WorkshopServices.First(x => x.ServiceId == serviceId); var serviceStartTime = viewModel.ServiceHours.Value.Split(':'); var startDate = viewModel.ServiceDate + new TimeSpan(Convert.ToInt32(serviceStartTime[0]), Convert.ToInt32(serviceStartTime[1]), 0); var endDate = startDate + new TimeSpan(service.DurationInHrs, service.DurationInMinutes, 0); var serviceEventModel = new ServiceEvent() { CustomerId = session.UserId, ServiceId = service.ServiceId, OrderStatus = (int)OrderStatus.OrderReceived, StartDate = startDate, EndDate = endDate }; db.ServiceEvents.Add(serviceEventModel); db.SaveChanges(); } } return(RedirectToAction("Index", "Home")); }
/// <summary> /// Publish a service related event to the Disa Android client. /// /// IMPORTANT: Note that this is internal so that only the Disa.Framework assembly can call this function. /// </summary> /// <param name="eventAction">The type safe representation of the Event Action.</param> /// <param name="eventCategory">The type safe representation of the Event Category.</param> /// <param name="service">The <see cref="Service"/> to be associated with this Google Analytics event.</param> internal static void RaiseServiceEvent( EventAction eventAction, EventCategory eventCategory, Service service) { ServiceEvent?.Invoke(eventAction, eventCategory, service); }
private void OrdersPropertyChanged(object sender, ServiceEvent <SalepointAddedOrdersEvents> e) { switch (e.Type) { case SalepointAddedOrdersEvents.AddedList: this.Orders.Clear(); foreach (OrderSalepoint addedOrder in this.salepointOrdersService.AddedOrders) { CreateOrderViewModel(addedOrder); } break; case SalepointAddedOrdersEvents.AddedOrder: this.CreateOrderViewModel((OrderSalepoint)e.Resource); break; case SalepointAddedOrdersEvents.RemovedOrder: var orderToRemove = (OrderSalepoint)e.Resource; var orderVM = this.Orders.Where(x => x.Order.Id == orderToRemove.Id).FirstOrDefault(); if (orderVM != null) { this.Orders.Remove(orderVM); } break; } this.RaisePropertyChanged(() => this.Orders); }
public void ServiceAdded(ServiceEvent ev) { Log.Info(TAG, "ServiceAdded: " + ev.Name); // Required to force serviceResolved to be called again (after the first search) _mainActivity.JmDNS.RequestServiceInfo(ev.Type, ev.Name, 1); }
public void SaveEvent(ServiceEvent newEvent) { lock (rwLock) { Cache.Add(newEvent); } }
private async void onActiveRouteUpdated(object sender, ServiceEvent <CarrierRouteEvents> e) { //first init should be handled by InitializeSideViewContent method, after view load if (!dataInitialised) { return; } //handle only major route events if (e.Type == CarrierRouteEvents.CancelledPoint || e.Type == CarrierRouteEvents.PassedPoint) { return; } this.InProgress = true; BaseViewModel vmToLoad = e.Type == CarrierRouteEvents.AddedRoute ? this.activeRouteVM : (BaseViewModel)this.editRouteVM; Type currentChildType = this.currentChildViewModel?.GetType(); if (currentChildType != vmToLoad.GetType()) { await this.navigationService.Navigate(vmToLoad).ContinueWith(t => { this.InProgress = false; }); this.currentChildViewModel = vmToLoad; } }
internal void fireServiceEvent(ServiceEvent serviceEvent) { foreach (ServiceListener listener in serviceListenerList) { listener.serviceChanged(serviceEvent); } }
private static void OnTimedEvent(Object source, ElapsedEventArgs e) { try { var service = new ServiceController("OpenALPRMilestone"); if (service != null) { if (service.Status != ServiceControllerStatus.Running) { Logger.Log.Info("starting OpenALPRMilestone service"); ServiceEvent?.Invoke(null, new MessageEventArgs($"{DateTime.Now.ToString()}: OpenALPR Milestone service was not running, restarted now.")); service.Start(); } } else { Logger.Log.Warn("service object is null"); } } catch (Exception ex) { Logger.Log.Error(null, ex); } }
public void TestRemoveInCallback() { var event1 = new ServiceEvent(); int callback1Fired = 0; int callback2Fired = 0; int callback3Fired = 0; // Test removing the callback in the callback (oneshot) IDisposable unregister1 = event1.Register(() => callback1Fired++); IDisposable unregister2 = event1.Register(() => callback2Fired++); _unregister3 = event1.Register(() => { callback3Fired++; _unregister3.Dispose(); }); event1.Fire(); Assert.Equal(1, callback1Fired); Assert.Equal(1, callback2Fired); Assert.Equal(1, callback3Fired); unregister1.Dispose(); unregister2.Dispose(); // Remove the test of them and make none of them fire callback1Fired = 0; callback2Fired = 0; callback3Fired = 0; event1.Fire(); Assert.Equal(0, callback1Fired); Assert.Equal(0, callback2Fired); Assert.Equal(0, callback3Fired); _unregister3 = null; }
//Receive message ack event handle private void ReceiveMessageACK(ServiceEvent serviceEvent) { this.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, new Action(() => { try { if (!_msgRequesetIdMsgItemInfoDict.ContainsKey(serviceEvent._requestID)) { return; } //Get message ack result bool success = serviceEvent._eventData._result == 0 ? true : false; if (success == true) { MessageBox.Show("Send to " + _msgRequesetIdMsgItemInfoDict[serviceEvent._requestID] + " succed!"); } else { MessageBox.Show("Send to " + _msgRequesetIdMsgItemInfoDict[serviceEvent._requestID] + " failed!"); } _msgRequesetIdMsgItemInfoDict.Remove(serviceEvent._requestID); } catch (Exception exception) { } })); }
// GET: ServiceEvent/Create public ActionResult Create(string vin) { ServiceEvent myServiceEvent = new ServiceEvent(); myServiceEvent.Vin = vin; return(View(myServiceEvent)); }
public IEnumerable <IEventHandler> Get(string service, string @event) { var serviceEvent = new ServiceEvent(service, @event); return(_eventHandlers.TryGetValue(serviceEvent, out var handlers) ? handlers : new List <IEventHandler>()); }
public ActionResult MyEvents() { IserviceEvent spe = new ServiceEvent(); List <Event> eve = spe.GetMany(x => x.creator.username == User.Identity.Name).ToList(); return(View(eve)); }
public async Task CircuitBreaker_must_reply_with_special_failure_message_on_Write_requests_if_open() { var events = new[] { new DurableEvent("a", "emitter") }; breaker.Tell(ServiceEvent.Failed(LogId, 1, TestLogFailureException)); breaker.Tell(new Write(events, probe.Ref, probe.Ref, 1, 2)); probe.ExpectMsg(new WriteFailure(events, CircuitBreaker.Exception, 1, 2)); probe.Sender.Should().Be(probe.Ref); }
protected override void OnArgusTVEvent(SynchronizationContext uiSyncContext, ServiceEvent @event) { if (@event.Name == ServiceEventNames.UpcomingRecordingsChanged || @event.Name == ServiceEventNames.UpcomingAlertsChanged || @event.Name == ServiceEventNames.UpcomingSuggestionsChanged) { uiSyncContext.Post(s => RefreshUpcomingPrograms(), null); } }
protected override void OnArgusTVEvent(SynchronizationContext uiSyncContext, ServiceEvent @event) { if (@event.Name == ServiceEventNames.RecordingStarted || @event.Name == ServiceEventNames.RecordingEnded || @event.Name == ServiceEventNames.ActiveRecordingsChanged) { uiSyncContext.Post(s => RefreshActiveRecordings(), null); } }
public ActionResult Edit([Bind(Include = "Id,ServiceDate,Vin,ServiceType,ServiceMileage,ServiceAmount")] ServiceEvent serviceEvent) { if (ModelState.IsValid) { Repository.editServiceEvent(serviceEvent); return(RedirectToAction("Index")); } return(View(serviceEvent)); }
public FileContentResult GetServiceEventImage(int id) { ServiceEvent service = _unitOfWork.GetServiceEventById(id); if (service == null) { return(null); } return(File(service.Image, service.ContentType)); }
public ActionResult Create([Bind(Include = "Id,ServiceDate,Vin,ServiceType,ServiceMileage,ServiceAmount")] ServiceEvent serviceEvent, string vin) { if (ModelState.IsValid) { serviceEvent.Vin = vin; Repository.createServiceEvent(serviceEvent); return(RedirectToAction("Index")); } return(View(serviceEvent)); }
private void PublishEvent(ServiceEvent newEvent, string topicName, string filter) { ConnectionFactory connFactory = new ConnectionFactory() { HostName = config.brokerAddress, Port = config.brokerPort }; IConnection connection = null; IModel channel = null; try { connection = connFactory.CreateConnection(); channel = connection.CreateModel(); string txtEvent = JsonConvert.SerializeObject(newEvent); byte[] content = Encoding.UTF8.GetBytes(txtEvent); // Console.WriteLine("Publishing: " + txtEvent); channel.ExchangeDeclare(topicName, "topic", true, true, null); channel.BasicPublish(topicName, filter, false, null, content); } catch (Exception e) { Console.WriteLine($"Failed to establish connection with message broker: " + $"address: {config.brokerAddress}:{config.brokerPort}, " + $"reason: {e.Message} "); } finally { if (channel != null && channel.IsOpen) { channel.Close(); } if (connection != null && connection.IsOpen) { connection.Close(); } } }
protected virtual void FetchEventHandler(string type, ServiceEvent inEvent, float inProgress, object inObject, object inUserData) { if (inEvent == ServiceEvent.COMPLETE) { a1 = inObject as MockAPIData; } else { Debug.LogError("Mock PAI Data fetch"); } }
static void Main(string[] args) { //DriverExecute(); //Inicio IEventLogs iEventLogs = new EventLosgRepository(); ServiceEvent service = new ServiceEvent(iEventLogs); service.Insert_Event("Menu", "Juan"); service.Insert_Event("Menu1", "Juan"); service.Save_Event(); }
public async Task CircuitBreaker_must_publish_ServiceFailed_once_on_event_stream_when_opened() { Sys.EventStream.Subscribe(probe.Ref, typeof(ServiceEvent)); var serviceFailed = ServiceEvent.Failed(LogId, 1, TestLogFailureException); breaker.Tell(serviceFailed); probe.ExpectMsg(serviceFailed); breaker.Tell(ServiceEvent.Failed(LogId, 2, TestLogFailureException)); probe.ExpectNoMsg(300.Milliseconds()); }
public void LogMethodEndEvent(Guid correlationId, string methodName, long milliseconds) { var startEvent = new ServiceEvent() { CorrelationId = correlationId, DebugInfo = string.Concat("Ticks:", milliseconds), Message = string.Concat(methodName, " End Event"), EventId = EventId.MethodEndEventId }; ServiceEventSource.EventSource.LogServiceEvent(startEvent.ToLogLine()); }
public async Task CircuitBreaker_must_open_after_first_failed_retry() { breaker.Tell(ServiceEvent.Failed(LogId, 1, TestLogFailureException)); try { await breaker.Ask("a", Timeout); } catch (AggregateException e) when(e.Flatten().InnerException is EventLogUnavailableException) { // as expected } }
public async Task CircuitBreaker_must_publish_ServiceNormal_once_on_event_stream_when_closed() { Sys.EventStream.Subscribe(probe.Ref, typeof(ServiceEvent)); breaker.Tell(ServiceEvent.Failed(LogId, 1, TestLogFailureException)); probe.FishForMessage(msg => msg is ServiceEvent e && e.Type == ServiceEvent.EventType.ServiceFailed); breaker.Tell(ServiceEvent.Normal(LogId)); probe.ExpectMsg(ServiceEvent.Normal(LogId)); breaker.Tell(ServiceEvent.Normal(LogId)); probe.ExpectNoMsg(300.Milliseconds()); }
public async Task <IList <ServiceEvent> > GetServiceEventsAsync(string serviceName, Duration duration, IList <Type> types, CancellationToken token) { var filter = FilterFactory.CreateServiceFilter(this.traceStoreReader, types, serviceName); var allServiceEvents = (await this.traceStoreReader.ReadTraceRecordsAsync(duration, filter, token).ConfigureAwait(false)).Select(oneRecord => ServiceEventAdapter.Convert(oneRecord)).ToList(); if (this.traceStoreReader.IsPropertyLevelFilteringSupported() || string.IsNullOrWhiteSpace(serviceName)) { return(allServiceEvents); } return(allServiceEvents.Where(oneEvent => oneEvent.ServiceId.Equals(ServiceEvent.TransformServiceName(serviceName), StringComparison.InvariantCultureIgnoreCase)).ToList()); }
public RetentionPolicy Match(ServiceEvent seEvent, IEnumerable <RetentionPolicy> policies) { var matchScores = (from p in policies let score = (string.Equals(seEvent.AppName, p.ForAppName, StringComparison.CurrentCultureIgnoreCase) ? 10 : 0) + (seEvent.Severity == p.ForSeverity ? 10 : 0) + (string.Equals(seEvent.Description, p.ForDescription, StringComparison.CurrentCultureIgnoreCase) ? 10 : 0) select new { policy = p, score = score }).ToArray(); var highestScore = matchScores.OrderByDescending(ms => ms.score).FirstOrDefault(); return(highestScore?.policy); }
protected virtual void FetchEventHandler(string type, ServiceEvent inEvent, float inProgress, object inObject, object inUserData) { if (inEvent == ServiceEvent.COMPLETE) { mockData = inObject as MockAPIData; } else { Debug.LogError("Mock API Data fetch failed"); } PopulateList(); }
/// <summary> /// This method adds a service event to the collection. /// </summary> /// <param name="status">The event status</param> /// <param name="theEvent">The event</param> public void ServiceEventAdd(XimuraServiceStatus status, ServiceEvent value) { lock (this) { if (EventsCollection == null) EventsCollection = new Dictionary<XimuraServiceStatus, ServiceEvent>(); if (EventsCollection.ContainsKey(status)) EventsCollection[status] += value; else EventsCollection.Add(status, value); } }
/// <summary> /// This method fires an event to all parties that have registered with the ServiceEvent /// </summary> /// <param name="theEvent">The ServiceEvent Type to fire</param> protected virtual void ProcessEvent(ServiceEvent theEvent) { ProcessEvent(theEvent,this,null); }
private static void MakeDocumentationOfNode(ClinicalDocument ccda) { ServiceEvent se = new ServiceEvent(); se.EffectiveTime = new IVL<TS>(new TS(DateTime.Now), new TS(DateTime.Now)); Performer1 performer = new Performer1(); performer.AssignedEntity = MakeAssignedEntity("DocumentationOf"); performer.TypeCode = new CS<x_ServiceEventPerformer>(x_ServiceEventPerformer.PRF); DocumentationOf docOf = new DocumentationOf(); docOf.ServiceEvent = new ServiceEvent(); docOf.ServiceEvent = se; ccda.DocumentationOf = new List<DocumentationOf>(); ccda.DocumentationOf.Add(docOf); }
public void RaiseServiceEvent(ServiceEvent evnt) { m_eventServer.SendEvent(new ServiceEventDispatcher(m_serviceListeners, evnt)); m_eventServer.SendEvent(new AllServiceEventDispatcher(m_allServiceListeners, evnt)); }
/// <summary> /// This method fires an event to all parties that have registered with the ServiceEvent /// </summary> /// <param name="theEvent">The ServiceEvent Type to fire</param> /// <param name="e">The ServiceEventArgs object to pass</param> protected virtual void ProcessEvent(ServiceEvent theEvent, ServiceEventArgs e) { ProcessEvent(theEvent,this,e); }
/// <summary> /// This method handles service event removal. /// </summary> /// <param name="status">The service status.</param> /// <param name="value">The event.</param> public void ServiceEventRemove(XimuraServiceStatus status, ServiceEvent value) { lock (this) { if (EventsCollection == null) EventsCollection = new Dictionary<XimuraServiceStatus, ServiceEvent>(); if (!EventsCollection.ContainsKey(status)) return; ServiceEvent current = EventsCollection[status] - value; if (current == null) EventsCollection.Remove(status); else EventsCollection[status] = current; } }
/// <summary> /// This method fires an event to all parties that have registered with the ServiceEvent /// </summary> /// <param name="theEvent">The ServiceEvent Type to fire</param> /// <param name="sender">The sended object to pass</param> /// <param name="e">The ServiceEventArgs object to pass</param> public virtual void ProcessEvent(ServiceEvent theEvent, object sender, ServiceEventArgs e) { //Check whether anyone is attached to the event if (theEvent == null) return; foreach (ServiceEvent te in theEvent.GetInvocationList()) { te(sender, e); } }
/// <summary> /// This method fires an event to all parties that have registered with the ServiceEvent /// </summary> /// <param name="theEvent">The ServiceEvent Type to fire</param> /// <param name="e">The ServiceEventArgs object to pass</param> public virtual void ProcessEvent(ServiceEvent theEvent, ServiceEventArgs e) { ProcessEvent(theEvent, rootClass, e); }
/// <summary> /// This method fires an event to all parties that have registered with the ServiceEvent /// </summary> /// <param name="theEvent">The ServiceEvent Type to fire</param> public virtual void ProcessEvent(ServiceEvent theEvent) { ProcessEvent(theEvent, rootClass, null); }
public AllServiceEventDispatcher(ListenerQueue<IAllServiceListener> listeners, ServiceEvent evnt) { m_queueView = listeners.getView(); m_event = evnt; }
public ServiceEventDispatcher(ListenerQueue<IServiceListener> listeners, ServiceEvent evnt) { m_queueView = listeners.getView(); m_event = evnt; throw new NotImplementedException("add filtering first!!!"); }