public async Task EventHistory_ShouldSupress() { var beacon = new Beacon(); beacon.Id1 = "7367672374000000ffff0000ffff0007"; beacon.Id2 = 8008; beacon.Id3 = 5; beacon.Timestamp = DateTimeOffset.Now; var args = new BeaconEventArgs(); args.Beacon = beacon; args.EventType = BeaconEventType.Exit; var resolvedActionEventArgs = new ResolvedActionsEventArgs() {BeaconPid = beacon.Pid, BeaconEventType = BeaconEventType.Enter}; BeaconAction beaconaction1 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "1223"}; BeaconAction beaconaction2 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "5678"}; BeaconAction beaconaction3 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "9678"}; ResolvedAction res1 = new ResolvedAction() {SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction1}; ResolvedAction res2 = new ResolvedAction() {SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction2}; ResolvedAction res3 = new ResolvedAction() {SuppressionTime = 1, SendOnlyOnce = true, BeaconAction = beaconaction3}; EventHistory eventHistory = new EventHistory(); await eventHistory.SaveBeaconEventAsync(args, null); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction1); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction3); eventHistory.ShouldSupressAsync(res1); eventHistory.ShouldSupressAsync(res3); await Task.Delay(2000); bool shouldSupress1 = eventHistory.ShouldSupressAsync(res1); bool shouldSupress2 = eventHistory.ShouldSupressAsync(res2); bool shouldSupress3 = eventHistory.ShouldSupressAsync(res3); Assert.IsTrue(shouldSupress1); Assert.IsFalse(shouldSupress2); Assert.IsFalse(shouldSupress3); //Supression time should be over }
public DeviceManager(DeviceFactory deviceFactory, EventHistory eventHistory) { _device = deviceFactory.GetDeviceAsync().Result; _eventHistory = eventHistory; ParticleCloud.SharedCloud.SubscribeToDeviceEventsWithPrefixAsync(OnParticleEvent, _device.Id).Wait(); }
public async Task <Unit> Handle(UpdateInterfaceStatusCommand request, CancellationToken cancellationToken) { bool isResendRequest = true; var eventDto = new EventDto(request.PaymentInterfaceError.CashId, request.PaymentInterfaceError.DocumentReference, (int)BusinessObjectType.PaymentOrder, request.Company); var eventStatus = await _interfaceEventLogService.FindEventAsync(eventDto); if (eventStatus != null) { var processInterfaceData = new ProcessInterfaceDataChangeLogsRequest { CompanyId = request.Company, TransactionDocumentId = request.PaymentInterfaceError.TransactionDocumentId, CashId = request.PaymentInterfaceError.CashId, DocumentReference = request.PaymentInterfaceError.DocumentReference, BusinessApplicationType = (int)BusinessApplicationType.TRAX, }; if (Enum.TryParse(request.PaymentInterfaceStatus, out InterfaceStatus status)) { if (status == InterfaceStatus.ReadyToTransmit) { // Made changes to process the document directly instead of queueing into Process.Queue // Processing it instead of queueing since we received bug which states document status after resend is not updated immediately var companyDate = await _systemDateTimeService.GetCompanyDate(processInterfaceData.CompanyId); _unitOfWork.BeginTransaction(); try { await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.ReadyToTransmit, "Resend from Interface Monitoring Screen", processInterfaceData.ESBMessage, null, null, processInterfaceData.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.ReadyToTransmit, "Resend from Interface Monitoring Screen"); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } _logger.LogInformation("Cash with DocumentId {Atlas_PaymentRequestCashDocumentId} having status {Atlas_PaymentRequestStatus} is sent to Treasury System at {Atlas_DateTime}", processInterfaceData.CashDocumentRef, InterfaceStatus.ReadyToTransmit, companyDate); var paymentRequestMessage = await _paymentRequestRepository.GetTRAXMessageAsync(processInterfaceData.CashId, processInterfaceData.CompanyId); var eventHistory = new EventHistory(eventStatus.EventId, "Message Generated", paymentRequestMessage, null, null); _unitOfWork.BeginTransaction(); try { await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, processInterfaceData.CompanyId); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } var legalEntityCode = await _paymentRequestRepository.GetLegalEntityCodeAsync(processInterfaceData.CompanyId, processInterfaceData.BusinessApplicationType); // send the business object to Interface await SendBusinessObjectToInterface(processInterfaceData, paymentRequestMessage, legalEntityCode, eventStatus.EventId); } } _logger.LogInformation("Accounting Error with id {Atlas_DocumentReference} updated.", processInterfaceData.DocumentReference); } return(Unit.Value); }
public void AssertEvents(Evt mask, ExpectedEvent[] expected, ArrayList actual) { AssertEvents(mask, expected, actual, "Event history did not match expected result. Got:\n" + EventHistory.ToString(mask, actual) + "\n\nExpected:\n" + EventHistory.ToString(expected)); }
public void OnWristbandStepsCollected(StepsData stepsData) { EventHistory.Add(new WristbandHistoryEvent("OnWristbandStepsCollected > " + stepsData.totalStepsWalked().ToString(), false)); }
public void Insert(Guid calendarID) { using (var context = new EventContext(_credentials)) { this.CalendarID = calendarID; var e = new Event(); e.Contents = this.Contents; e.EndTime = this.EndTime; e.ID = this.EventID; e.IsAllDay = this.IsAllDay; e.IsReoccuring = this.IsReoccuring; e.Location = this.Location; e.StartTime = this.StartTime; e.Title = this.Title; e.Type = this.Type; e.CalendarID = this.CalendarID; e.AuthorID = _credentials.UserID; // Add and save here so we have the event id context.Events.Add(e); context.SaveChanges(); // Grab the event ID after saved this.EventID = e.ID; // Add the reminders foreach (var item in Reminders) { context.EventReminders.Add(item); } if (this.Type == EventType.None) { this.Type = EventType.Private; } // Do the calendar sharing if (this.Type == EventType.Public || this.Type == EventType.EmployeesOnly) { // Add the individuals who are already invited to the calendar // only if the event is made public var employeeInvitees = (from c in context.CalendarInvitees join u in context.Users on c.InviteeID equals u.ID where c.Type == InviteeType.Employee select new EventInvitee { EventID = this.EventID, InviteeID = u.ID, Type = InviteeType.Employee }).ToList(); Invitees.AddRange(employeeInvitees); // add the customers if (this.Type == EventType.Public) { var customerInvitees = (from c in context.CalendarInvitees join customers in context.Customers on c.InviteeID equals customers.ID where c.Type == InviteeType.Employee select new EventInvitee { EventID = this.EventID, InviteeID = customers.ID, Type = InviteeType.Customer }).ToList(); Invitees.AddRange(customerInvitees); } } // Add the invitees foreach (var item in Invitees) { context.EventInvitees.Add(item); } // set the transaction dates this.DateCreated = DateTime.Now; this.DateEdied = this.DateCreated; // need to save the date created and date edited // need to do this here because we need the event id EventHistory history = new EventHistory(); history.UserID = _credentials.UserID; history.TransactionDate = this.DateCreated; history.EventID = this.EventID; history.TransactionType = EventHistoryType.Create; context.EventHistory.Add(history); // save the history context.SaveChanges(); // set the creator this.Creator = context.Users.Where(w => w.ID == e.AuthorID).First(); } }
private void OnNext(MonitorEvent ev) { EventHistory.Add(ev); }
/// <summary> /// Add literal text that is not a property and not editable. /// </summary> /// <param name="_ss"/> public void AddString(ITsString _ss) { EventHistory.Add(new StringAdded { Content = _ss }); }
protected virtual bool CheckAgainst(float lastTime, EventHistory actualEvent) { if(CommonChecks(actualEvent)) return false; if(CheckTimes(lastTime, actualEvent)) return false; if(CheckState(actualEvent)) return false; if(CheckOther(actualEvent)) return false; return true; }
public static string ToString(EventHistory[] eventHistory) { System.Text.StringBuilder sb = new System.Text.StringBuilder(); foreach(EventHistory h in eventHistory) { sb.Append(h.ToString()).Append("\n"); } return sb.ToString(); }
public async Task <Unit> Handle(ProcessInterfaceDataChangeLogsRequest request, CancellationToken cancellationToken) { int tAorJLTypeId = 0; // There should be no record in DB the first time. var docStatus = await _accountingInterfaceRepository.GetDocumentStatus((int)BusinessApplicationType.AX, request.CompanyId, null, request.TransactionDocumentId, request.DocumentId); var docReference = await _accountingInterfaceRepository.GetDocumentReferenceByAccountingId(request.DocumentId, (int)request.DocumentTypeId, request.CompanyId); if (docStatus == InterfaceStatus.None || docStatus == InterfaceStatus.TransmitError) { long eventId; if (request.DocumentTypeId == DocumentType.ManualTemporaryAdjustment) { tAorJLTypeId = await _accountingInterfaceRepository.GetTATypeIdAsync(request.TransactionDocumentId, request.DocumentTypeId, request.CompanyId); } if (request.DocumentTypeId == DocumentType.RegularJournal) { tAorJLTypeId = await _accountingInterfaceRepository.GetJLTypeIdAsync(request.TransactionDocumentId, request.DocumentTypeId, request.CompanyId); } EventSubType eventSubType = await GetEventSubType(request.DocumentTypeId, tAorJLTypeId); _unitOfWork.BeginTransaction(); var eventdata = new Event((int)eventSubType, request.DocumentId, docReference, (int)InterfaceStatus.ReadyToTransmit, request.CompanyId, null); try { eventId = await _interfaceEventLogService.CreateEventAsync(eventdata); // Insert Record into InterfaceStatus await ProcessStatusUpdate(request, InterfaceStatus.InterfaceReady, "Ready To be Interfaced"); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } var companyDate = await _systemDateTimeService.GetCompanyDate(request.CompanyId); _logger.LogInformation("Accounting Document with DocumentId {Atlas_DocumentId} having status {Atlas_InterfaceStatus} is sent to Accounting System at {Atlas_DateTime}", request.DocumentId, docStatus.ToString(), companyDate); var accountingInterfaceXMLMessage = await _accountingInterfaceRepository.GetESBMessageAsync(request.DocumentId, request.CompanyId); var eventHistory = new EventHistory(eventId, "Message Generated", accountingInterfaceXMLMessage, null, null); _unitOfWork.BeginTransaction(); try { await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } await SendBusinessObjectToInterface(request, accountingInterfaceXMLMessage, tAorJLTypeId, eventId, false); } else { _logger.LogWarning("Invalid Document ({Atlas_DocumentReference}) status {Atlas_InterfaceStatus}.", request.DocumentReference, docStatus.ToString()); } return(Unit.Value); }
public async Task <ProcessESBResult> Handle(ProcessESBResponse esbRequest, CancellationToken cancellationToken) { CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture; TextInfo textInfo = cultureInfo.TextInfo; var companyDate = await _systemDateTimeService.GetCompanyDate(esbRequest.CompanyId); long sourceId = await _interfaceEventLogService.GetAccountingIdandCashIdbyDocumentReference(esbRequest.CompanyId, esbRequest.DocumentReference, (int)BusinessApplicationType.AX, (int)esbRequest.BusinessObjectType); var eventDto = new EventDto(sourceId, esbRequest.DocumentReference, (int)esbRequest.BusinessObjectType, esbRequest.CompanyId); var eventStatus = await _interfaceEventLogService.FindEventAsync(eventDto); if (eventStatus != null) { var eventHistoryData = new EventHistory(eventStatus.EventId, "Callback message received from ESB", esbRequest.ESBMessage, null, null); await _interfaceEventLogService.CreateEventHistoryAsync(eventHistoryData, esbRequest.CompanyId); _unitOfWork.BeginTransaction(); try { var responseToESB = await ValidateESBResponse(esbRequest); if (responseToESB.IsSuccess) { var processInterfaceData = new ProcessInterfaceDataChangeLogsRequest(); processInterfaceData.DocumentReference = esbRequest.DocumentReference; processInterfaceData.CompanyId = esbRequest.CompanyId; processInterfaceData.BusinessApplicationType = BusinessApplicationType.AX; processInterfaceData.ESBMessage = esbRequest.ESBMessage; processInterfaceData.AcknowledgementId = esbRequest.AckBusinessDocId; processInterfaceData.TransactionDate = esbRequest.TransactionDate.GetValueOrDefault() == default(DateTime) ? null : esbRequest.TransactionDate; processInterfaceData.TimeStamp = esbRequest.TimeStamp; processInterfaceData.JournalNumber = esbRequest.JournalNumber; InterfaceStatus status; if (Enum.TryParse(textInfo.ToTitleCase(esbRequest.ResponseStatus.ToLowerInvariant()), out status)) { switch (status) { case InterfaceStatus.Completed: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Completed, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Ok.ToString(), null, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Completed, esbRequest.ResponseMessage); break; case InterfaceStatus.Error: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Error, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Error.ToString(), esbRequest.ResponseMessage, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Error, esbRequest.ResponseMessage); break; case InterfaceStatus.Rejected: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Rejected, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Error.ToString(), esbRequest.ResponseMessage, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Rejected, esbRequest.ResponseMessage); break; } } } _unitOfWork.Commit(); _logger.LogInformation("Document with DocumentId {Atlas_AccountingDocumentReference} received status {Atlas_AccountingStatus} from Accounting System at {Atlas_DateTime}", esbRequest.DocumentReference, esbRequest.ResponseStatus, companyDate); return(responseToESB); } catch { _unitOfWork.Rollback(); throw; } } else { processESBResult.Error = "Invalid Document Reference"; processESBResult.IsSuccess = false; return(processESBResult); } }
private async Task ProcessAccountingInterfaceRequest(ProcessInterfaceDataChangeLogsRequest request, string accountingInterfaceXMLMessage, int tAorJLTypeId, long eventId, bool isResendRequest) { try { // Esb call inside its own try/catch request.UUID = await _esbService.CallESBClient(accountingInterfaceXMLMessage, request.DocumentTypeId, tAorJLTypeId); } catch (Exception e) { _logger.LogError(e, e.Message); _unitOfWork.BeginTransaction(); try { var updateEventStatus = new Event(eventId, (long)InterfaceStatus.TransmitError, e.Message); var eventHistory = new EventHistory(eventId, "Sending the message to ESB", null, ResultCode.Error.ToString(), e.Message); await _interfaceEventLogService.UpdateEventStatusAsync(updateEventStatus, request.CompanyId); await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId); await ProcessStatusUpdate(request, InterfaceStatus.TransmitError, e.Message); _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } if (!isResendRequest) { throw; } } _unitOfWork.BeginTransaction(); try { if (request.UUID != null) { var updateEventStatus = new Event(eventId, (long)InterfaceStatus.StandBy, request.UUID); var eventHistory = new EventHistory(eventId, "Sending the message to ESB", null, ResultCode.Ok.ToString(), request.UUID); await _interfaceEventLogService.UpdateEventStatusAsync(updateEventStatus, request.CompanyId); await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId); await ProcessStatusUpdate(request, InterfaceStatus.StandBy, accountingInterfaceXMLMessage); } else { var updateEventStatus = new Event(eventId, (long)InterfaceStatus.TransmitError, accountingInterfaceXMLMessage); var eventHistory = new EventHistory(eventId, "Sending the message to ESB", null, ResultCode.Error.ToString(), accountingInterfaceXMLMessage); await _interfaceEventLogService.UpdateEventStatusAsync(updateEventStatus, request.CompanyId); await _interfaceEventLogService.CreateEventHistoryAsync(eventHistory, request.CompanyId); await ProcessStatusUpdate(request, InterfaceStatus.TransmitError, accountingInterfaceXMLMessage); } _unitOfWork.Commit(); } catch { _unitOfWork.Rollback(); throw; } }
/// <summary> /// Persons the event list asynchronous. /// </summary> /// <param name="personId">The person identifier.</param> /// <param name="searchParameters">The search parameters.</param> /// <returns> /// Instance of Event History /// </returns> public async Task<ListResult<EventHistory>> PersonEventListAsync(string personId, PersonEventSearchParameter searchParameters) { var eventHistoryCollection = new ListResult<EventHistory>(); var eventHistory = new EventHistory(); ////TODO : Implement Date time value to pass to mas service to retrieve drill events. DateTime dateTime; try { DateTime.TryParseExact(searchParameters.DateTime, CustomDateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out dateTime); } catch { dateTime = DateTime.UtcNow; } //// TODO : Will remove later after 2015-11-23 Release. if (dateTime.Equals(DateTime.MinValue)) { dateTime = DateTime.UtcNow; } var drillEvents = RetrieveDrillEvents(dateTime, personId, searchParameters.PersonType.ToString(CultureInfo.CurrentCulture)); var gangwayEvents = this.personEventClientRepository.RetrieveEventListAsync(new PersonHistorySearchParameters { ShipId = searchParameters.ShipId, PersonIds = searchParameters.PersonId, PersonTypeId = searchParameters.PersonTypeId, MaxResults = searchParameters.MaxResults, OrderBy = searchParameters.OrderBy, PageNumber = searchParameters.PageNumber, Parts = searchParameters.Parts }); await Task.WhenAll(drillEvents, gangwayEvents); eventHistory.AssignGangwayEvents(PersonEventHistoryMapper.MapListAsync(gangwayEvents.Result.Items)); eventHistory.AssignDrillEvents(drillEvents.Result); eventHistoryCollection.Items.Add(eventHistory); eventHistoryCollection.TotalResults = gangwayEvents.Result.TotalResults; return eventHistoryCollection; }
public void Update() { WasLazyLoaded = false; // need to make sure the event is saved if (this.EventID == Guid.Empty) { throw new iONCalendarEventException(this, "Event ID Empty, cannot update"); } using (var context = new EventContext(_credentials)) { var e = context.Events.Find(this.EventID); // someone else could have removed the event if (e == null) { throw new iONCalendarEventException(this, "Event not found, cannot update"); } e.Contents = this.Contents; e.EndTime = this.EndTime; e.ID = this.EventID; e.IsAllDay = this.IsAllDay; e.IsReoccuring = this.IsReoccuring; e.Location = this.Location; e.StartTime = this.StartTime; e.Title = this.Title; // update the reminders, need to see if they changed foreach (var item in Reminders) { if (item.MarkedForRemoval) { context.EventReminders.Remove(item); } } // update the invitees, need to see if they changed foreach (var item in Invitees) { if (item.MarkedForRemoval) { context.EventInvitees.Remove(item); } } // do an atomic save here context.SaveChanges(); // need to save the date created and date edited // need to do this here because we need the event id EventHistory history = new EventHistory(); history.UserID = _credentials.UserID; history.TransactionDate = DateTime.Now; history.EventID = e.ID; history.TransactionType = EventHistoryType.Edit; context.EventHistory.Add(history); // save the history context.SaveChanges(); } }
public void Update(EventHistory eventHistory) { _context.Entry(eventHistory).State = EntityState.Modified; }
public static void Test() { try { Console.WriteLine("Connecting to database..."); using (var init = new InitDatabaseService()) { Console.WriteLine("Connection successful.\nResetting the database..."); init.Reset(); Console.WriteLine("Reset successful.\nLoading data..."); //create dummy pharmacy Pharmacy pharm = new Pharmacy(1, "CSV Pharmacy", "19187661052", "1400 chrissartin street"); using (var service = new PharmacyService()) { service.Create(pharm); } //create dummy patient Patient patient = new Patient(1, "Chris", "Sartin", new DateTime(2000, DateTime.Today.Month, DateTime.Today.Day), "77777", "19183994836", "*****@*****.**", pharm); Patient patient1 = new Patient(2, "Matthew", "Miller", new DateTime(2000, DateTime.Today.Month, DateTime.Today.Day), "8675309", "19187661052", "*****@*****.**", pharm); using (var service = new PatientService()) { service.Create(patient); service.Create(patient1); } //create dummy drug Drug drug = new Drug(1, "Taco Medication"); using (var service = new DrugService()) { service.Create(drug); } //create dummy prescription Prescription prescription = new Prescription(1, patient, drug, 7, 7); Prescription prescription1 = new Prescription(2, patient1, drug, 6, 6); using (var service = new PrescriptionService()) { service.Create(prescription); service.Create(prescription1); } EventRefill RefillEvent; //create dummy event using (var service = new EventService()) { //create dummy eventRefill Event Event = new Event(patient, "this is a message", EventStatus.ToSend, EventType.REFILL); Event Event1 = new Event(patient, "refill test event", EventStatus.Sent, EventType.REFILL); Event Event2 = new Event(patient1, "this is a test", EventStatus.Fill, EventType.REFILL); RefillEvent = new EventRefill(prescription, Event); EventRefill RefillEvent1 = new EventRefill(prescription1, Event1); EventRefill RefillEvent2 = new EventRefill(prescription1, Event2); using (var service2 = new EventRefillService()) { service.Create(Event); service2.Create(RefillEvent); service.Create(Event1); service2.Create(RefillEvent1); service.Create(Event2); service2.Create(RefillEvent2); } //create dummy birthdayevent Event BirthdayEvent = new Event(patient, "this is a message", EventStatus.ToSend, EventType.BIRTHDAY); service.Create(BirthdayEvent); //create dummy recallevent Event = new Event(patient, "this is a message", EventStatus.ToSend, EventType.REFILL); EventRecall RecallEvent = new EventRecall(Event); using (var service2 = new EventRecallService()) { service.Create(Event); service2.Create(RecallEvent); } //create dummy eventhistory EventHistory history = new EventHistory(Event, EventStatus.InActive, new DateTime(2000, 7, 14)); using (var service2 = new EventHistoryService()) { service2.Create(history); } } //create dummy pharmacist in the pharmacy Pharmacist pharmacist = new Pharmacist("James", "Taco", "*****@*****.**", "18884443333", new byte[] { 0 }, new byte[] { 0 }); Pharmacist pharmacist1 = new Pharmacist("Matthew", "Miller", "*****@*****.**", "19187661052", new byte[] { 0 }, new byte[] { 0 }); Pharmacist pharmacist2 = new Pharmacist("Luke", "Thorne", "*****@*****.**", "14056932048", new byte[] { 0 }, new byte[] { 0 }); Pharmacist pharmacist3 = new Pharmacist("Emily", "Pielemeier", "*****@*****.**", "13177536066", new byte[] { 0 }, new byte[] { 0 }); Pharmacist pharmacist4 = new Pharmacist("Tom", "Hartnett", "*****@*****.**", "14696671743", new byte[] { 0 }, new byte[] { 0 }); using (var service = new PharmacistService()) { service.Create(pharmacist); service.Create(pharmacist1); service.Create(pharmacist2); service.Create(pharmacist3); service.Create(pharmacist4); } //create dummy fillhistory FillHistory fill = new FillHistory(RefillEvent, pharmacist, new DateTime(2000, 7, 14)); using (var service = new FillHistoryService()) { service.Create(fill); } //create dummy sysadmins (us) SystemAdmin admin = new SystemAdmin("testing", "the stuff", "*****@*****.**", "19184661052", new byte[] { 0 }, new byte[] { 0 }); SystemAdmin admin1 = new SystemAdmin("Tom", "Hartnett", "*****@*****.**", "14696671743", new byte[] { 0 }, new byte[] { 0 }); SystemAdmin admin2 = new SystemAdmin("Luke", "Thorne", "*****@*****.**", "14056932048", new byte[] { 0 }, new byte[] { 0 }); SystemAdmin admin3 = new SystemAdmin("Jon", "Hartnett", "*****@*****.**", "14696671064", new byte[] { 0 }, new byte[] { 0 }); SystemAdmin admin4 = new SystemAdmin("Emily", "Pielemeier", "*****@*****.**", "13177536066", new byte[] { 0 }, new byte[] { 0 }); using (var service = new SystemAdminService()) { service.Create(admin); service.Create(admin1); service.Create(admin2); service.Create(admin3); service.Create(admin4); } //create dummy job Job job = new Job(pharm, pharmacist, true, false); using (var service = new JobService()) { service.Create(job); Job j1 = new Job(pharm, pharmacist1, true, true); service.Create(j1); Job j2 = new Job(pharm, pharmacist2, true, true); service.Create(j2); Job j3 = new Job(pharm, pharmacist3, true, true); service.Create(j3); Job j4 = new Job(pharm, pharmacist4, true, true); service.Create(j4); } init.LoadFromFile(@"..\..\App_Data\Scrubbed_Data.xlsx - Sheet1.csv", pharm); Console.WriteLine("Loading data successful.\nAll tests successful..."); } } catch (Exception ex) { Console.WriteLine(ex); Console.ReadKey(); } }
protected virtual bool CheckOther(EventHistory actualEvent) { // TODO: Make this less sucky. Come up with something that's clean and easy // for various event types... if((otherData != null) && (otherData != actualEvent.otherData)) return true; return false; }
public async Task EventHistory_FlushHistory() { var beacon = new Beacon(); beacon.Id1 = "7367672374000000ffff0000ffff0007"; beacon.Id2 = 8008; beacon.Id3 = 5; beacon.Timestamp = DateTimeOffset.Now; var args = new BeaconEventArgs(); args.Beacon = beacon; args.EventType = BeaconEventType.Exit; var resolvedActionEventArgs = new ResolvedActionsEventArgs() {BeaconPid = beacon.Pid, BeaconEventType = BeaconEventType.Enter}; BeaconAction beaconaction1 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "1223"}; BeaconAction beaconaction2 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "5678"}; BeaconAction beaconaction3 = new BeaconAction() {Body = "body", Url = "http://www.com", Uuid = "9678"}; ResolvedAction res1 = new ResolvedAction() {SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction1}; ResolvedAction res2 = new ResolvedAction() {SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction2}; ResolvedAction res3 = new ResolvedAction() {SuppressionTime = 1, SendOnlyOnce = true, BeaconAction = beaconaction3}; EventHistory eventHistory = new EventHistory(); await eventHistory.SaveBeaconEventAsync(args, null); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction1); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction3); await eventHistory.FlushHistoryAsync(); }
protected virtual bool CheckState(EventHistory actualEvent) { if((enabledState != actualEvent.enabledState) || (activeState != actualEvent.activeState)) return true; return false; }
private void InterceptEvent(EventItem item) { lock (Hooks) { EventHistory.Enqueue(item); } }
protected virtual bool CheckTimes(float lastTime, EventHistory actualEvent) { // Make sure we're on the exact frame we expect. if((frame > 0) && (frame != actualEvent.frame)) return true; // Make sure that at the specified time value is in the past (lets us test // that a certain amount of time has been waited). if((realtimeSinceStartup > 0) && (realtimeSinceStartup > actualEvent.realtimeSinceStartup)) return true; else if(realtimeSinceStartup < 0) { // Use negative values to specify relative times. float tmp = Mathf.Abs(realtimeSinceStartup) + lastTime; if(tmp > actualEvent.realtimeSinceStartup) return true; } return false; }
public void OnWristbandUnknownProfile(string pheriperalID, string pheriperalName) { EventHistory.Add(new WristbandHistoryEvent("OnWristbandUnknownProfile > name: " + pheriperalName + ", id: " + pheriperalID, false)); }
protected virtual bool CommonChecks(EventHistory actualEvent) { if(actualEvent == null) return true; // Make sure we're looking at the right event type. if(name != actualEvent.name) return true; return false; }
public void OnWristbandWriteComplete() { EventHistory.Add(new WristbandHistoryEvent("OnWristbandWriteComplete", false)); }
protected override bool CheckState(EventHistory actualEvent) { if(enabledState != actualEvent.enabledState) return true; return false; }
public async Task <ProcessESBResult> Handle(ProcessESBResponse esbRequest, CancellationToken cancellationToken) { var eventHistoryData = new EventHistory(); var eventData = new Event(); CultureInfo cultureInfo = Thread.CurrentThread.CurrentCulture; TextInfo textInfo = cultureInfo.TextInfo; var companyDate = await _systemDateTimeService.GetCompanyDate(esbRequest.CompanyId); long sourceId = await _interfaceEventLogService.GetAccountingIdandCashIdbyDocumentReference(esbRequest.CompanyId, esbRequest.DocumentReference, (int)BusinessApplicationType.TRAX, (int)esbRequest.BusinessObjectType); var eventDto = new EventDto(sourceId, esbRequest.DocumentReference, (int)esbRequest.BusinessObjectType, esbRequest.CompanyId); var eventStatus = await _interfaceEventLogService.FindEventAsync(eventDto); eventHistoryData = new EventHistory(eventStatus.EventId, "Callback message received from ESB", esbRequest.ESBMessage, null, null); await _interfaceEventLogService.CreateEventHistoryAsync(eventHistoryData, esbRequest.CompanyId); var paymentRequestStatus = await _paymentRequestRepository.GetPaymentRequestStatus((int)BusinessApplicationType.TRAX, esbRequest.CompanyId, esbRequest.DocumentReference); _unitOfWork.BeginTransaction(); try { var responseToESB = await ValidateEsbResponse(esbRequest, paymentRequestStatus); if (responseToESB.IsSuccess) { var processInterfaceData = new ProcessInterfaceDataChangeLogsRequest(); processInterfaceData.CashDocumentRef = esbRequest.DocumentReference; processInterfaceData.CompanyId = esbRequest.CompanyId; processInterfaceData.BusinessApplicationType = Convert.ToInt32(BusinessApplicationType.TRAX, CultureInfo.InvariantCulture); processInterfaceData.ESBMessage = esbRequest.ESBMessage; processInterfaceData.AcknowledgementId = esbRequest.AckBusinessDocId; processInterfaceData.DocumentDate = esbRequest.ValueDate; InterfaceStatus status; if (Enum.TryParse(textInfo.ToTitleCase(esbRequest.ResponseStatus.ToLower(CultureInfo.InvariantCulture)), out status)) { switch (status) { case InterfaceStatus.Signed: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Signed, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Ok.ToString(), null, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Signed, esbRequest.ESBMessage); await EnqueueMessage(paymentRequestStatus.TransactionDocumentId.ToString(CultureInfo.InvariantCulture), esbRequest.CompanyId); break; case InterfaceStatus.Error: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Error, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Error.ToString(), esbRequest.ResponseMessage, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Error, esbRequest.ResponseMessage); break; case InterfaceStatus.Included: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Included, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Ok.ToString(), null, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Interfaced, esbRequest.ResponseMessage); break; case InterfaceStatus.Rejected: await ProcessEventUpdate(eventStatus.EventId, InterfaceStatus.Rejected, "ESB callback Message integration", esbRequest.ESBMessage, ResultCode.Error.ToString(), esbRequest.ResponseMessage, esbRequest.CompanyId); await ProcessStatusUpdate(processInterfaceData, InterfaceStatus.Rejected, esbRequest.ResponseMessage); break; } } } _unitOfWork.Commit(); _logger.LogInformation("Cash with DocumentId {Atlas_PaymentRequestCashDocumentId} recieved status {Atlas_PaymentRequestStatus} from Treasury System at {Atlas_DateTime}", esbRequest.DocumentReference, esbRequest.ResponseStatus, companyDate); return(responseToESB); } catch { _unitOfWork.Rollback(); throw; } }
/// <summary> /// For creating event history. /// </summary> /// <param name="newEvent">Data for creating event history.</param> /// <param name="companyId">Company Identifier.</param> /// <returns>Creates event history.</returns> public async Task CreateEventHistoryAsync(EventHistory newEvent, string companyId) { await _eventRepository.CreateEventHistoryAsync(newEvent, companyId); }
/// <summary> /// Retrieves the person event asynchronous. /// </summary> /// <param name="dateTime">The date time.</param> /// <param name="personId">The person identifier.</param> /// <param name="personType">The person type.</param> /// <returns>The person events.</returns> public async Task<EventHistory> RetrievePersonHistoryAsync(string dateTime, string personId, PersonType personType) { var workstation = DIContainer.Instance.Resolve<Workstation>(); ListResult<EventHistory> eventData = new ListResult<EventHistory>(); var eventHistory = new EventHistory(); var personTypeId = personType.RetrievePersonTypeId(); var command = this.Database.GetStoredProcCommand(RetrieveGangwayHistoryByPersonIdStoredProcedure) .AddParameter(PersonTypeId, DbType.Int16, personTypeId) .AddParameter(PersonIds, DbType.String, personId) .AddParameter(ShipIds, DbType.String, workstation.Ship.ShipId) .AddParameter(SortColumn1, DbType.String, AddedDate) .AddParameter(SortTypeColumn1, DbType.String, DESC) .AddParameter(PageNumber, DbType.Int32, OfflineConstants.DefaultPageNumber) .AddParameter(PageSize, DbType.Int32, OfflineConstants.DefaultPageSize); var list = await this.ExecuteReaderAsync(command, GangwayHistoryMapper.MapGangwayHistory); eventHistory.AssignGangwayEvents(PersonEventHistoryMapper.MapPersonHistory(list.Items)); eventData.Items.Add(eventHistory); var data = eventData != null ? eventData.Items.FirstOrDefault() : new EventHistory(); return await Task.FromResult(data); }
public async Task EventHistory_ShouldSupress() { var beacon = new Beacon(); beacon.Id1 = "7367672374000000ffff0000ffff0007"; beacon.Id2 = 8008; beacon.Id3 = 5; beacon.Timestamp = DateTimeOffset.Now; var args = new BeaconEventArgs(); args.Beacon = beacon; args.EventType = BeaconEventType.Exit; var resolvedActionEventArgs = new ResolvedActionsEventArgs() { BeaconPid = beacon.Pid, BeaconEventType = BeaconEventType.Enter }; BeaconAction beaconaction1 = new BeaconAction() { Body = "body", Url = "http://www.com", Uuid = "1223" }; BeaconAction beaconaction2 = new BeaconAction() { Body = "body", Url = "http://www.com", Uuid = "5678" }; BeaconAction beaconaction3 = new BeaconAction() { Body = "body", Url = "http://www.com", Uuid = "9678" }; ResolvedAction res1 = new ResolvedAction() { SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction1 }; ResolvedAction res2 = new ResolvedAction() { SuppressionTime = 100, SendOnlyOnce = true, BeaconAction = beaconaction2 }; ResolvedAction res3 = new ResolvedAction() { SuppressionTime = 1, SendOnlyOnce = true, BeaconAction = beaconaction3 }; EventHistory eventHistory = new EventHistory(); await eventHistory.SaveBeaconEventAsync(args, null); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction1); await eventHistory.SaveExecutedResolvedActionAsync(resolvedActionEventArgs, beaconaction3); eventHistory.ShouldSupressAsync(res1); eventHistory.ShouldSupressAsync(res3); await Task.Delay(2000); bool shouldSupress1 = eventHistory.ShouldSupressAsync(res1); bool shouldSupress2 = eventHistory.ShouldSupressAsync(res2); bool shouldSupress3 = eventHistory.ShouldSupressAsync(res3); Assert.IsTrue(shouldSupress1); Assert.IsFalse(shouldSupress2); Assert.IsFalse(shouldSupress3); //Supression time should be over }
public void Insert(EventHistory eventHistory) { _context.EventsHistoriesContext.Add(eventHistory); }
public DeviceController(DeviceManager deviceManager, EventHistory eventHistory) { _deviceManager = deviceManager; _eventHistory = eventHistory; }
public void Delete(int eventHistoryId) { EventHistory eventHistory = _context.EventsHistoriesContext.Find(eventHistoryId); _context.EventsHistoriesContext.Remove(eventHistory); }
private void UpdateReaderList(IEnumerable <string> readerNames) { Readers.ClearOnScheduler(); EventHistory.ClearOnScheduler(); Readers.AddRangeOnScheduler(readerNames); }
private void AddEventHistory(EventHistory eventHistory) => this.EventHistories.Add(eventHistory);
public void OnBluetoothDeInitialized() { EventHistory.Add(new WristbandHistoryEvent("OnBluetoothDeInitialized", false)); }
public void OnError(WristbandProtocolError error, string info) { EventHistory.Add(new WristbandHistoryEvent("OnError > " + info, true)); }
public void OnWristbandDebugMessage(string msg) { EventHistory.Add(new WristbandHistoryEvent("OnWristbandDebugMessage > " + msg, false)); }
public static void ArchiveEvents() { EventHistory.Add(TodaysEvents); TodaysEvents = new List <Event>(); }
public void OnWristbandConnected(string pheriperalID, string pheriperalName, WristbandProfile profile) { EventHistory.Add(new WristbandHistoryEvent("OnWristbandConnected > name:" + pheriperalName + ", id:" + pheriperalID + ", profile: " + profile.description.ToString(), false)); }
private void OnError(Exception exception) { Debug.Print(exception.Message); Readers.Clear(); EventHistory.Clear(); }
public void OnWristbandDisconnected() { EventHistory.Add(new WristbandHistoryEvent("OnWristbandDisconnected", false)); }
public async Task PostAsync(EventHistory _event) { _unitOfWork.GetRepoInstance <EventHistory>().Insert(_event); await _unitOfWork.saveAsync(); }
/// <summary> /// Creates a new Engine object. /// </summary> /// <param name="createdOnForeground">bool for indication if the engine works on foreground.</param> public SdkEngine(bool createdOnForeground) { ServiceManager.Clear(); ServiceManager.ApiConnction = new ApiConnection(); ServiceManager.BeaconScanner = new Scanner() {DisableFilter = true}; ServiceManager.LayoutManager = new LayoutManager(); ServiceManager.StorageService = new StorageService(createdOnForeground); ServiceManager.SettingsManager = new SettingsManager(); ServiceManager.LocationService = _locationService = new LocationService(); ServiceManager.WriterFactory = new WriterFactory(); _appIsOnForeground = createdOnForeground; Resolver = new Resolver(!createdOnForeground) {EventHistory = _eventHistory = new EventHistory()}; _nextTimeToProcessDelayedActions = DateTimeOffset.MaxValue; }