public IHttpActionResult Put(int id, string sessionId, [FromBody] Event value) { var repository = EventRepositoryCache.Instance.Get(sessionId.ToGuidWithAccessDenied()); var validationResult = EventValidator.ValidateV3Update(value, true); if (!string.IsNullOrWhiteSpace(validationResult)) { return(InternalServerError(new ArgumentException(validationResult))); } var item = repository.GetById(id); if (item == null || !repository.IsInteraction(item)) { return(NotFound()); } item.Date = value.Date; item.AddressType = value.AddressType; item.Broker = value.Broker; item.BrokerAttendees = value.BrokerAttendees; item.Companies = value.Companies; item.Duration = value.Duration; item.InteractionType = value.InteractionType; item.InvestorAttendees = value.InvestorAttendees; item.Location = value.Location; item.MeetingTypes = value.MeetingTypes; item.Sectors = value.Sectors; item.Title = value.Title; repository.SetUpdated(item); return(Ok()); }
public IActionResult SubmitForm(EventValidator data) { if (ModelState.IsValid) { if (data.Date < DateTime.Now) { ViewBag.Error = "Date has to be in future"; return(View("EventForm")); } else { int? x = HttpContext.Session.GetInt32("ID"); string totalDuration = data.Duration + "" + data.Duration2; DateTime thisDate = data.Date; DateTime g = thisDate.Add(data.Time); Event newEvent = new Event { Title = data.Title, Description = data.Description, Datetime = g, Duration = totalDuration, UserId = (int)x }; _context.events.Add(newEvent); _context.SaveChanges(); return(RedirectToAction("Main")); } } else { return(View("EventForm")); } }
public void Tree_Lazy_Child_ResolvesOnlyOnce() { var client = BaseTest.Initialize_Client(new TreeRequestResponse(TreeRequestScenario.MultiLevelContainer)); var validator = new EventValidator(client, new[] { //Get Object UnitRequest.Objects("filter_objid=1001"), //Get Probe UnitRequest.Probes("filter_objid=1001&filter_parentid=0"), //Probe -> Devices/Groups UnitRequest.Devices("filter_parentid=1001"), UnitRequest.Groups("filter_parentid=1001"), //Probe -> Device -> Sensors UnitRequest.Sensors("filter_parentid=3001") }); validator.MoveNext(2); var tree = client.GetTreeLazy(1001); validator.MoveNext(2); var child = tree.Children[0]; var childAgain = tree.Children[0]; validator.MoveNext(); var grandChild = child.Children[0]; var grandChildAgain = child.Children[0]; }
public ServiceSlotServiceInterceptor(EventValidator eventValidator, ServiceSlotValidator serviceSlotValidator) { _eventValidator = eventValidator; _serviceSlotValidator = serviceSlotValidator; var mappings = new Dictionary <string, Action <IInvocation> > { { nameof(AddServiceSlotAsync), x => AddServiceSlotAsync((ServiceSlot)x.Arguments[0]) }, { nameof(DeleteServiceSlotAsync), x => DeleteServiceSlotAsync((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(GetAllServiceSlotsForEventAsync), x => GetAllServiceSlotsForEventAsync((int)x.Arguments[0]) }, { nameof(GetServiceSlotAsync), x => GetServiceSlotAsync((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(UpdateServiceSlotAsync), x => UpdateServiceSlotAsync((ServiceSlot)x.Arguments[0]) } }; BuildUp(mappings); }
public void Execute(string[] parameters) { if (LogedUser.User == null) { throw new InvalidOperationException(ConsoleMessages.LogInFirst); } if (parameters.Length != 5) { throw new InvalidOperationException(ConsoleMessages.InvalidArgumentCount); } string name = parameters[1]; string description = parameters[2]; DateTime?startDate = parameters[3].CanConvertTo(typeof(DateTime)) ? (DateTime?)DateTime.Parse(parameters[3]) : null; DateTime?endDate = parameters[4].CanConvertTo(typeof(DateTime)) ? (DateTime?)DateTime.Parse(parameters[4]) : null; var inputEvent = new InputEvent() { Name = parameters[1], Description = parameters[2], StartDate = parameters[3], EndDate = parameters[4] }; using (var ctx = new TeamBuilderContext()) { var validator = new EventValidator(); CommandUtils.ValidateAndThrowErrorCode(validator, inputEvent); var e = new Event(); Mapper.Map(inputEvent, e); CreateEvent(ctx, e); } this.SucessMessage = $"Event {name} was created successfully!"; }
public async Task <CoapMessage> PutAsync(CoapMessage message) { CoapUri uri = new CoapUri(message.ResourceUri.ToString()); ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable; //EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated //if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted)) if (EventValidator.Validate(false, uri.Resource, channel, graphManager).Validated) { return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token)); } if (coapObserved.ContainsKey(uri.Resource) || coapUnobserved.Contains(uri.Resource)) { //resource previously subscribed return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.NotAcceptable, message.Token)); } //this point the resource is not being observed, so we can // #1 subscribe to it // #2 add to unobserved resources (means not coap observed) SubscriptionMetadata metadata = new SubscriptionMetadata() { IsEphemeral = true, Identity = session.Identity, Indexes = session.Indexes }; string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata); coapUnobserved.Add(uri.Resource); return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token)); }
public AttendeeServiceInterceptor(AttendeeValidator attendeeValidator, EventValidator eventValidator, PersonValidator personValidator) { _attendeeValidator = attendeeValidator; _eventValidator = eventValidator; _personValidator = personValidator; var mappings = new Dictionary <string, Action <IInvocation> > { { nameof(CreateAttendeeRelationshipAsync), x => CreateAttendeeRelationshipAsync((AttendeeRelationship)x.Arguments[0]) }, { nameof(DeleteAttendeeRelationshipAsync), x => DeleteAttendeeRelationshipAsync((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(GetAllRelationshipsForEventAsync), x => GetAllRelationshipsForEventAsync((int)x.Arguments[0]) }, { nameof(GetSingleRelationshipAsync), x => GetSingleRelationshipAsync((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(UpdateAttendeeRelationshipAsync), x => UpdateAttendeeRelationshipAsync((AttendeeRelationship)x.Arguments[0]) } }; BuildUp(mappings); }
public async Task <CoapMessage> ObserveAsync(CoapMessage message) { if (!message.Observe.HasValue) { //RST because GET needs to be observe/unobserve await logger?.LogWarningAsync($"CoAP observe received without Observe flag and will return RST for {session.Identity}"); await logger?.LogDebugAsync($"Returning RST because GET needs to be observe/unobserve for {session.Identity}"); return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage)); } CoapUri uri = new CoapUri(message.ResourceUri.ToString()); ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable; ValidatorResult result = EventValidator.Validate(false, uri.Resource, channel, graphManager); if (!result.Validated) { await logger?.LogErrorAsync($"{result.ErrorMessage} for {session.Identity}"); return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token)); } if (!message.Observe.Value) { //unsubscribe await logger?.LogInformationAsync($"CoAP unobserve '{message.ResourceUri.ToString()}' for {session.Identity}."); await adapter.UnsubscribeAsync(uri.Resource); await logger?.LogDebugAsync($"CoAP unsubscribed '{message.ResourceUri.ToString()} for {session.Identity}'."); coapObserved.Remove(uri.Resource); } else { //subscribe SubscriptionMetadata metadata = new SubscriptionMetadata() { IsEphemeral = true, Identity = session.Identity, Indexes = session.Indexes }; await logger?.LogInformationAsync($"CoAP subscribed '{message.ResourceUri.ToString()}' for {session.Identity}"); string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata); if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list { coapObserved.Add(uri.Resource, message.Token); await logger?.LogDebugAsync("Key added to observable resource."); } } return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token)); }
public EventController( IEventService eventService, IImageProfileManager imageProfileManager) { _eventService = eventService; _imageProfileManager = imageProfileManager; _validator = new EventValidator(T); }
public EventTest() { _Name = "Event name Test"; _Description = "Event description"; _StartDate = "2019/03/07"; _FinishDate = "2019/03/07"; validator = new EventValidator(); }
private async Task PublishAsync(PublishMessage message) { MessageAuditRecord record = null; EventMetadata metadata = null; try { MqttUri mqttUri = new MqttUri(message.Topic); metadata = await graphManager.GetPiSystemMetadataAsync(mqttUri.Resource); if (EventValidator.Validate(true, metadata, Channel, graphManager, context).Validated) { EventMessage msg = new EventMessage(mqttUri.ContentType, mqttUri.Resource, ProtocolType.MQTT, message.Encode(), DateTime.UtcNow, metadata.Audit); if (!string.IsNullOrEmpty(mqttUri.CacheKey)) { msg.CacheKey = mqttUri.CacheKey; } if (mqttUri.Indexes != null) { List <KeyValuePair <string, string> > list = GetIndexes(mqttUri); await adapter.PublishAsync(msg, list); } else { await adapter.PublishAsync(msg); } } else { if (metadata.Audit) { record = new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, Channel.TypeId, "MQTT", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements"); } throw new SecurityException(string.Format("'{0}' not authorized to publish to '{1}'", session.Identity, metadata.ResourceUriString)); } } catch (Exception ex) { await logger?.LogErrorAsync(ex, $"MQTT adapter PublishAsync error on channel '{Channel.Id}'."); OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex)); } finally { if (metadata != null && metadata.Audit && record != null) { await messageAuditor?.WriteAuditRecordAsync(record); } } }
public void Tree_Lazy_Object_NoAPIRequests() { var client = BaseTest.Initialize_Client(new TreeRequestResponse(TreeRequestScenario.ContainerWithGrandChild)); var validator = new EventValidator(client, new string[] {}); var tree = client.GetTreeLazy(new Group { Id = 0 }); }
private static void TestSbSingle() { var bus = ServiceBusFactory.GetServiceBus(); var eventId = new Guid("cf0a200c-e6d3-472e-8c2c-286b2032ba6e"); const string EventType = "ITOperations.Mating.HeatEvent"; var validationResult = new EventValidator("Animal", "animalIdentity").GetValidationResult(eventId); const string ValidatorQueueName = "EventProcessing.ValidationAggregator.service.input"; using (var ts = new TransactionScope()) { bus.Send(ValidatorQueueName, new ValidationResult { EventID = eventId, EventServiceBoundary = AIWebAPI.ResourceLocator.ServiceName, EventSource = AnimalIdentityServiceEventSources.MindaPro, ValidationOutcome = ValidationResultFlag.Valid, EventType = EventType }); bus.Send(ValidatorQueueName, new ValidationResult { EventID = eventId, EventServiceBoundary = AIWebAPI.ResourceLocator.ServiceName, EventSource = AnimalIdentityServiceEventSources.MindaPro, ValidationOutcome = ValidationResultFlag.Valid, EventType = EventType }); bus.Send(ValidatorQueueName, new ValidationResult { EventID = eventId, EventServiceBoundary = "ITOperations.AnimalCharacteristic", EventSource = AnimalIdentityServiceEventSources.MindaPro, ValidationOutcome = ValidationResultFlag.Valid, EventType = EventType }); bus.Send(ValidatorQueueName, new ValidationResult { EventID = eventId, EventServiceBoundary = AIWebAPI.ResourceLocator.ServiceName, EventSource = AnimalIdentityServiceEventSources.MindaPro, ValidationOutcome = ValidationResultFlag.Valid, EventType = EventType }); ts.Complete(); } }
public IHttpActionResult Post(string sessionId, FileFormat fileFormat) { if (HttpContext.Current.Request.Files.AllKeys.Any()) { var repository = EventRepositoryCache.Instance.Get(sessionId.ToGuidWithAccessDenied()); var httpPostedFile = HttpContext.Current.Request.Files["Data"]; if (httpPostedFile != null) { string result = StreamToString(httpPostedFile.InputStream); List <Event> events; try { switch (fileFormat) { case FileFormat.Csv: events = DeserializeCsv(result); break; case FileFormat.Xml: events = DeserializeXml(result); break; case FileFormat.Json: events = DeserializeJson(result); break; default: return(InternalServerError(new ArgumentException("FileFormat"))); } } catch (Exception e) { return(InternalServerError(new IOException("Parsing error", e))); } foreach (Event e in events) { var validationResult = EventValidator.ValidateCorrect(e, null); if (!string.IsNullOrWhiteSpace(validationResult)) { return(InternalServerError(new ArgumentException(validationResult))); } repository.Create(e); } return(Ok()); } return(BadRequest("File is not provided")); } return(BadRequest("File is not provided")); }
public IHttpActionResult Post(string sessionId, [FromBody] Event value) { var repository = EventRepositoryCache.Instance.Get(sessionId.ToGuidWithAccessDenied()); var validationResult = EventValidator.ValidateCorrect(value, false); if (!string.IsNullOrWhiteSpace(validationResult)) { return(InternalServerError(new ArgumentException(validationResult))); } var result = repository.Create(value); return(Ok(result)); }
public void Tree_Lazy_Id_OneAPIRequest() { var client = BaseTest.Initialize_Client(new TreeRequestResponse(TreeRequestScenario.ContainerWithGrandChild)); var validator = new EventValidator(client, new[] { UnitRequest.Objects("filter_objid=1001"), UnitRequest.Probes("filter_objid=1001&filter_parentid=0") }); validator.MoveNext(2); var tree = client.GetTreeLazy(1001); }
public async Task <CoapMessage> PostAsync(CoapMessage message) { try { CoapUri uri = new CoapUri(message.ResourceUri.ToString()); ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable; EventMetadata metadata = await graphManager.GetPiSystemMetadataAsync(uri.Resource); ValidatorResult result = EventValidator.Validate(true, metadata, null, graphManager); if (!result.Validated) { if (metadata.Audit) { await auditor?.WriteAuditRecordAsync(new MessageAuditRecord("XXXXXXXXXXXX", session.Identity, this.channel.TypeId, "COAP", message.Payload.Length, MessageDirectionType.In, false, DateTime.UtcNow, "Not authorized, missing resource metadata, or channel encryption requirements")).LogExceptions(logger); } logger?.LogErrorAsync(result.ErrorMessage); return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token)); } string contentType = message.ContentType.HasValue ? message.ContentType.Value.ConvertToContentType() : "application/octet-stream"; EventMessage msg = new EventMessage(contentType, uri.Resource, ProtocolType.COAP, message.Encode(), DateTime.UtcNow, metadata.Audit); if (!string.IsNullOrEmpty(uri.CacheKey)) { msg.CacheKey = uri.CacheKey; } if (uri.Indexes == null) { await adapter.PublishAsync(msg); } else { List <KeyValuePair <string, string> > indexes = GetIndexes(uri); await adapter.PublishAsync(msg, indexes); } return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token)); } catch (Exception ex) { logger?.LogErrorAsync(ex, $"CoAP POST fault for {session.Identity}."); throw ex; } }
public async Task <IActionResult> Run([HttpTrigger(AuthorizationLevel.Function, "post", Route = null)] HttpRequest req, ILogger log) { var newEvent = JsonConvert.DeserializeObject <Event>(await req.ReadAsStringAsync()); var validator = new EventValidator(); var validatorResults = validator.Validate(newEvent); if (!validatorResults.IsValid) { return(new BadRequestObjectResult(validatorResults.Errors)); } await newEvent.SaveAsync(Repository); return(new JsonResult(newEvent)); }
public EventLocationServiceInterceptor(EventValidator eventValidator) { _eventValidator = eventValidator; var mappings = new Dictionary <string, Action <IInvocation> > { { nameof(GetLocationForEventAsync), x => GetLocationForEventAsync((int)x.Arguments[0]) }, { nameof(UpdateLocationForEventAsync), x => UpdateLocationForEventAsync((int)x.Arguments[0], (Location)x.Arguments[1]) } }; BuildUp(mappings); }
/// <summary> /// Used when an event is raised and the event needs to be published to the analytics server instantly /// </summary> /// <param name="package">Event package we are sending</param> public static void PublishEvent(EventPackage package) { var result = UnityEngine.Analytics.AnalyticsEvent.Custom(ApplicationVersion + ":" + package.EventName, package.Data); if (result != UnityEngine.Analytics.AnalyticsResult.Ok) { UnityEngine.Debug.LogError(package.EventName + " Failed: " + result.ToString()); Log.Write(package.EventName + " Failed: " + result.ToString()); } #if (UNITY_EDITOR || UNITY_EDITOR_OSX) if (Application.isEditor) { //var sendName = ApplicationVersion + ":" + package.EventName + "(" + result.ToString() + ")"; //package.EventName = sendName; EventValidator.RecieveEvent(package, result); //ConvertToJSON(package); } #endif }
public AgreementServiceInterceptor(AgreementValidator agreementValidator, EventValidator eventValidator, ServiceSlotValidator serviceSlotValidator, EventServiceModelValidator eventServiceModelValidator) { _agreementValidator = agreementValidator; _eventValidator = eventValidator; _serviceSlotValidator = serviceSlotValidator; _eventServiceModelValidator = eventServiceModelValidator; BuildUp(new Dictionary <string, Action <IInvocation> > { { nameof(GetSingleServiceAgreementByEventSlot), x => GetSingleServiceAgreementByEventSlot((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(GetAllServiceAgreementsByEvent), x => GetAllServiceAgreementsByEvent((int)x.Arguments[0]) }, { nameof(CreateServiceAgreement), x => CreateServiceAgreement((int)x.Arguments[0], (int)x.Arguments[1], (int)x.Arguments[2]) }, { nameof(UpdateServiceAgreement), x => UpdateServiceAgreement((ServiceAgreement)x.Arguments[0]) }, { nameof(DeleteAgreement), x => DeleteAgreement((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(ProposeAgreement), x => ProposeAgreement((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(AcceptAgreement), x => AcceptAgreement((int)x.Arguments[0], (int)x.Arguments[1]) }, { nameof(DeclineAgreement), x => DeclineAgreement((int)x.Arguments[0], (int)x.Arguments[1]) } }); }
static void Main() { log4net.Config.XmlConfigurator.Configure(); logger.Info("Program Started"); UserDbRepo urepo = new UserDbRepo(); ChildDbRepo crepo = new ChildDbRepo(); EventDbRepository erepo = new EventDbRepository(); ChildValidator cvalidator = new ChildValidator(); EventValidator evalidator = new EventValidator(); UserService userv = new UserService(urepo); ChildService cserv = new ChildService(crepo, cvalidator); EventService eserv = new EventService(erepo, evalidator); Application.EnableVisualStyles(); Application.SetCompatibleTextRenderingDefault(false); Application.Run(new Login(userv, cserv, eserv)); //ChildDbRepo repo = new ChildDbRepo(); //Child c = repo.save(new Child("Adrian", "Ionel", 9)); logger.Info("Program ended."); }
public Notification <bool> CreateEvent(Event ev) { ev.SetId(GetMaxId() + 1); EventValidator validator = new EventValidator(ev); bool valid = validator.Validate(); Notification <bool> notifier = new Notification <bool>(); if (!valid) { foreach (var error in validator.GetErrors()) { notifier.AddError(error); } notifier.SetResult(false); } else { notifier.SetResult(eventRepo.Create(ev)); } return(notifier); }
public IActionResult Post([FromBody] EventItem item) { if (item == null) { _logger.LogDebug("Item is null"); return(BadRequest()); } var validator = new EventValidator(); if (!validator.isValid(item)) { _logger.LogDebug("Item is not valid"); return(BadRequest("One or more properties is not valid")); } _context.EventItems.Add(item); _context.SaveChanges(); _logger.LogDebug(string.Format("Created item with id {0}", item.Id.ToString())); return(CreatedAtRoute("GetEvent", new { id = item.Id }, item)); }
private void Session_OnUnsubscribe(object sender, MqttMessageEventArgs args) { try { UnsubscribeMessage msg = (UnsubscribeMessage)args.Message; foreach (var item in msg.Topics) { MqttUri uri = new MqttUri(item.ToLowerInvariant()); if (EventValidator.Validate(false, uri.Resource, Channel, graphManager, context).Validated) { adapter.UnsubscribeAsync(uri.Resource).GetAwaiter(); logger?.LogInformationAsync($"MQTT adapter unsubscribed {uri.ToString()}"); } } } catch (Exception ex) { logger?.LogErrorAsync(ex, $"MQTT adapter Session_OnUnsubscribe error on channel '{Channel.Id}'.").GetAwaiter(); OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex)); } }
public async Task PrtgClient_ParsesInvalidXml_RetainsDirtyAsync() { var xml = "<property><value>\01</value></property>"; var client = BaseTest.Initialize_Client(new BasicResponse(xml.ToString())); var validator = new EventValidator <string>(new[] { //First - retry a dirty response "https://prtg.example.com/api/table.xml?content=objects&columns=objid,name,tags,type,active,basetype&count=*&username=username&passhash=12345678", "XmlSerializer encountered exception ''.', hexadecimal value 0x00, is an invalid character. Line 1, position 18.' while processing request. Retrying request and flagging engine as dirty.", "https://prtg.example.com/api/table.xml?content=objects&columns=objid,name,tags,type,active,basetype&count=*&username=username&passhash=12345678", //Second - engine should be already marked as dirty "https://prtg.example.com/api/table.xml?content=objects&columns=objid,name,tags,type,active,basetype&count=*&username=username&passhash=12345678" }); client.LogVerbose += (s, e) => { var message = e.Message; if (message.StartsWith("Synchronously") || message.StartsWith("Asynchronously")) { message = Regex.Replace(e.Message, "(.+ request )(.+)", "$2"); } Assert.AreEqual(validator.Get(message), message); }; validator.MoveNext(3); var result = await client.ObjectEngine.GetObjectAsync <DummyElementRoot>(new PrtgObjectParameters()); validator.MoveNext(); result = await client.ObjectEngine.GetObjectAsync <DummyElementRoot>(new PrtgObjectParameters()); Assert.IsTrue(validator.Finished, "Did not process all requests"); }
private List <string> Session_OnSubscribe(object sender, MqttMessageEventArgs args) { List <string> list = new List <string>(); try { SubscribeMessage message = args.Message as SubscribeMessage; SubscriptionMetadata metadata = new SubscriptionMetadata { Identity = session.Identity, Indexes = session.Indexes, IsEphemeral = true }; foreach (var item in message.Topics) { MqttUri uri = new MqttUri(item.Key); string resourceUriString = uri.Resource; if (EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated) { Task <string> subTask = Subscribe(resourceUriString, metadata); string subscriptionUriString = subTask.Result; list.Add(resourceUriString); } } } catch (Exception ex) { logger?.LogErrorAsync(ex, $"MQTT adapter Session_OnSubscribe error on channel '{Channel.Id}'.") .GetAwaiter(); OnError?.Invoke(this, new ProtocolAdapterErrorEventArgs(Channel.Id, ex)); } return(list); }
public EventValidatorTests() { _validator = new EventValidator(); }
public void Setup() { _dateConverter = new Mock <IDateConverter>(); _eventValidator = new EventValidator(_dateConverter.Object); }
public AgreementValidator(DataContext dataContext, IPersonService personService, EventValidator eventValidator) { _dataContext = dataContext; _personService = personService; _eventValidator = eventValidator; }