protected override async Task <ResponseCommand <T2> > Execute(RequestCommand <T, T2> context, Func <RequestCommand <T, T2>, Task <ResponseCommand <T2> > > next) { Request = context.RestRequest; var profile = context.Profile; Polly.AsyncPolicy <IRestResponse <T2> > policy = Policy.NoOpAsync <IRestResponse <T2> >(); if (context.Authenticate) { policy = context.CustomPolicy ?? Policy.NoOpAsync <IRestResponse <T2> >(); Polly.AsyncPolicy <IRestResponse <T2> > mainPolicy = Policy .HandleResult <IRestResponse <T2> >(resp => resp.StatusCode == System.Net.HttpStatusCode.Unauthorized) .RetryAsync( retryCount: 1, onRetryAsync: async(result, retryNumber, ctx) => await GetAuthorizationTokenAsync(profile, true) ); policy = mainPolicy.WrapAsync(policy); await GetAuthorizationTokenAsync(profile); } var response = await policy.ExecuteAsync(async() => await RestClient.ExecuteAsync <T2>(context.RestRequest)); var responseCommand = new ResponseCommand <T2> { Response = response }; return(responseCommand); }
private static void ReceiveAndPickResponse(Socket client, ICommand receivedCommand) { ICommand response; var watch = Stopwatch.StartNew(); while (true) { if (!Responses.TryDequeue(out response !)) { if (watch.ElapsedMilliseconds >= ResponseQueueTimeout) { response = new ResponseCommand(receivedCommand, "Timeout"); break; } continue; } watch.Restart(); Console.WriteLine("Received a response..."); if (CheckConsistency(response)) { break; } } client.SendCompletelyWithEof(response.ToBytes()); Console.WriteLine($"Propagated {response}."); }
private static void SendResponse(Socket client, ICommand receivedCommand, ExecuteCommandVisitor visitor) { var response = new ResponseCommand(receivedCommand, visitor.Message); client.SendCompletelyWithEof(response.ToBytes()); Console.WriteLine($"Responded with {response}."); }
private void ProcessReadAck(ResponseCommand cmd) { if (cmd.Model != Gateway.SensorKey) { GetOrAddDeviceByCommand(cmd); } }
private MiHomeDevice GetOrAddDeviceByCommand(ResponseCommand cmd) { if (_gateway != null && cmd.Sid == _gateway.Sid) { return(_gateway); } if (_devicesList.TryGetValue(cmd.Sid, out var miHomeDevice)) { return(miHomeDevice); } var device = _devicesMap[cmd.Model](cmd.Sid); if (_namesMap != null && _namesMap.TryGetValue(cmd.Sid, out var deviceName)) { device.Name = deviceName; } if (cmd.Data != null) { device.ParseData(cmd.Data); } _devicesList.TryAdd(cmd.Sid, device); return(device); }
public void Check_WaterLeakSensor_Raised_NoLeak() { // Arrange var cmd = Helpers .CreateCommand("heartbeat", "sensor_wleak.aq1", "158d0001d561e2", 18101, new Dictionary <string, object> { { "voltage", "3005" } }); // Act WaterLeakSensor device = _deviceFactory.GetDeviceByCommand <WaterLeakSensor>(cmd); bool noleakRaised = false; device.OnNoLeak += (_, __) => noleakRaised = true;; cmd = Helpers .CreateCommand("report", "sensor_wleak.aq1", "158d0001d561e2", 18101, new Dictionary <string, object> { { "status", "no_leak" } }); device.ParseData(ResponseCommand.FromString(cmd).Data); // Assert Assert.True(noleakRaised); }
public void Run() { Test.Initialize(); Guid test = new Guid("8b265223-dc9e-4789-a6df-69d19f644ad7"); /** * State sent to Saga * ***/ SendCommand command = new SendCommand(); command.RequestId = test; command.state = MyMessages.MessageParts.StateCodes.SentMyWCFClient; /** * State sent to WCF CLient * ***/ ResponseCommand resp = new ResponseCommand(); resp.RequestId = test; resp.state = MyMessages.MessageParts.StateCodes.CompleteMyWCFClient; Test.Saga<PaymentRequestSaga>() .ExpectTimeoutToBeSetIn<SendCommand>((state, span) => span == TimeSpan.FromHours(3)) .ExpectSend<SendCommand>() .ExpectReplyToOrginator<ResponseCommand>() .When(s => s.Handle(command)); Test.Saga<PaymentRequestSaga>() .ExpectReplyToOrginator<ResponseCommand>() .When(s => s.Handle(resp)); Test.Saga<PaymentRequestSaga>() .ExpectSend<ResponseCommand>() .WhenSagaTimesOut(); }
public void Check_DoorWindowSensor_Raised_Closed_Event() { // Arrange var cmd = Helpers .CreateCommand("heartbeat", "magnet", "158d0001233529", 64996, new Dictionary <string, object> { { "voltage", 2985 } }); // Act DoorWindowSensor device = _deviceFactory.GetDeviceByCommand <DoorWindowSensor>(cmd); bool closedRaised = false; device.OnClose += (_, __) => closedRaised = true; cmd = Helpers .CreateCommand("report", "magnet", "158d0001233529", 64996, new Dictionary <string, object> { { "status", "close" } }); device.ParseData(ResponseCommand.FromString(cmd).Data); // Assert Assert.True(closedRaised); }
internal async Task Send(ResponseCommand responseCommand) { var command = JsonConvert.SerializeObject(responseCommand); byte[] res = Encoding.UTF8.GetBytes(command); await client.SendAsync(new ArraySegment <byte>(res), WebSocketMessageType.Text, true, CancellationToken.None); }
public void Check_MotionSensor_Reports_NoMotion_Data() { // Arrange var cmd = Helpers .CreateCommand("report", "motion", "158d00011c0", 52754, new Dictionary <string, object> { { "no_motion", "120" } }); // Act MotionSensor device = _fixture.GetDeviceByCommand <MotionSensor>(cmd); var noMotionRaised = false; var moMotionSeconds = 0; device.OnNoMotion += (_, args) => { noMotionRaised = true; moMotionSeconds = args.Seconds; }; device.ParseData(ResponseCommand.FromString(cmd).Data); // Assert Assert.Equal("motion", device.Type); Assert.Equal("158d00011c0", device.Sid); Assert.Equal("no motion", device.Status); Assert.True(noMotionRaised); Assert.Equal(120, device.NoMotion); }
private void ProcessReadAck(ResponseCommand cmd) { if (cmd.Model != "gateway") { GetOrAddDeviceByCommand(cmd); } }
private void DiscoverGatewayAndDevices(ResponseCommand cmd) { if (_gatewaySid == null) { if (_gateway == null) { _gateway = new Gateway(cmd.Sid, _transport); } _transport.SetToken(cmd.Token); } else if (_gatewaySid == cmd.Sid) { _gateway = new Gateway(cmd.Sid, _transport); _transport.SetToken(cmd.Token); } if (_gateway == null) { return; } _transport.SendCommand(new ReadDeviceCommand(cmd.Sid)); foreach (var sid in JArray.Parse(cmd.Data)) { _transport.SendCommand(new ReadDeviceCommand(sid.ToString())); Task.Delay(ReadDeviceInterval).Wait(); // need some time in order not to loose message } }
public void Check_MotionSensor_Reports_Motion_Data() { // Arrange var cmd = Helpers .CreateCommand("report", "motion", "158d00011c0", 52754, new Dictionary <string, object> { { "status", "motion" } }); // Act MotionSensor device = _fixture.GetDeviceByCommand <MotionSensor>(cmd); var motionRaised = false; device.OnMotion += (_, args) => { motionRaised = true; }; var timeDiff = DateTime.Now - device.MotionDate.Value; device.ParseData(ResponseCommand.FromString(cmd).Data); // Assert Assert.Equal("motion", device.Type); Assert.Equal("158d00011c0", device.Sid); Assert.Equal("motion", device.Status); Assert.True(timeDiff <= TimeSpan.FromSeconds(1)); Assert.True(motionRaised); }
public async Task <ResponseCommand> Handle(CreateLancamentoCommand command) { var response = new ResponseCommand(); command.Validate(); if (command.Invalid) { response.AddNotifications(command.Notifications); return(response); } var lancamento = new Models.Lancamento( command.NumeroContaOrigem, command.NumeroContaDestino, command.Valor); await _lancamentoRepository.GerarLancamento(lancamento); response.AddValue(new { Mensagem = "Lançamento efetuado com sucesso.", Compovante = lancamento.Id, Origem = lancamento.NumeroContaOrigem, Destino = lancamento.NumeroContaDestino, Valor = lancamento.Valor, Data = lancamento.DataLancamento.ToString("dd-MM-yyyy") }); return(response); }
private MiHomeDevice GetOrAddDeviceByCommand(ResponseCommand cmd) { if (_gateway != null && cmd.Sid == _gateway.Sid) { return(_gateway); } if (_devicesList.ContainsKey(cmd.Sid)) { return(_devicesList[cmd.Sid]); } var device = _devicesMap[cmd.Model](cmd.Sid); if (_namesMap != null && _namesMap.ContainsKey(cmd.Sid)) { device.Name = _namesMap[cmd.Sid]; } if (cmd.Data != null) { device.ParseData(cmd.Data); } _devicesList.TryAdd(cmd.Sid, device); return(device); }
public async Task <ResponseCommand> Handle(CreateUserCommand command) { var response = new ResponseCommand(); command.Validate(); if (command.Invalid) { response.AddNotifications(command.Notifications); return(response); } if (await _userRepository.UserExiste(command.Login) != null) { response.AddNotification(new Notification("Usuario", "Usuário já existe.")); return(response); } var user = new Models.Usuario(command.Login, command.Senha); await _userRepository.Save(user); response.AddValue(new { Mensagem = "Usuário Cadastrado", Id = user.Id, Login = user.Login }); return(response); }
private async Task StartReceivingMessagesAsync(CancellationToken ct) { // Receive messages while (!ct.IsCancellationRequested) { try { var str = await _transport.ReceiveAsync().ConfigureAwait(false); var respCmd = ResponseCommand.FromString(str); if (LogRawCommands) { _logger?.LogInformation(str); } if (!_commandsToActions.TryGetValue(respCmd.Command, out var actionCommand)) { _logger?.LogInformation($"Command '{respCmd.RawCommand}' is not a response command, skipping it"); continue; } actionCommand(respCmd); } catch (Exception e) { _logger?.LogError(e, "Unexpected error"); } } }
private void UpdateDevicesList(ResponseCommand cmd) { if (cmd.Model == "gateway") { return; // no need to add gateway to list of devices } var device = _devicesList.FirstOrDefault(x => x.Sid == cmd.Sid); if (device != null) { return; } device = _devicesMap[cmd.Model](cmd.Sid); if (_namesMap != null && _namesMap.ContainsKey(cmd.Sid)) { device.Name = _namesMap[cmd.Sid]; } if (cmd.Data != null) { device.ParseData(cmd.Data); } _devicesList.Add(device); }
public override void FinishStatesCallBack(Int32 message) { this.resCmd = (ResponseCommand)message; if (this.resCmd == ResponseCommand.RESPONSE_FINISH_GOBACK_FRONTLINE) { } }
public async Task <ResponseViewModel> UpdateAsync(UserUpdateRequestViewModel request) { using (_unitOfWork) { // Inicia a transação _unitOfWork.BeginTransaction(); // Atualiza o Perfil ProfileUpdateCommand profileUpdateCommand = new ProfileUpdateCommand(Convert.ToInt32(request.IdType), request.GuidProfile, request.Avatar, request.CpfCnpj, request.Address); ResponseCommand profileUpdateResponse = await _mediator.Send(profileUpdateCommand, CancellationToken.None).ConfigureAwait(true); if (!profileUpdateResponse.Success) { return(new ResponseViewModel(false, profileUpdateResponse.Object)); } // Atualiza o Usuário UserUpdateCommand userUpdateCommand = new UserUpdateCommand(request.GuidUser, request.Name, request.Email); ResponseCommand userUpdateResponse = await _mediator.Send(userUpdateCommand, CancellationToken.None).ConfigureAwait(true); if (!userUpdateResponse.Success) { return(new ResponseViewModel(false, userUpdateResponse.Object)); } // Comita e Retorna _unitOfWork.CommitTransaction(); return(new ResponseViewModel(true, "User updated")); } }
public async Task <ResponseViewModel> DeleteAsync(string guidUser, string guidProfile) { // Obs: Fiz pensando em ser um para um entre usuário e perfil, poderia ser um para muitos e ai neste caso não excluiria o perfil quando o usuário fosse excluido using (_unitOfWork) { // Inicia a transação _unitOfWork.BeginTransaction(); // Remove o Usuário UserDeleteCommand userDeleteCommand = new UserDeleteCommand(guidUser); ResponseCommand userAddResponse = await _mediator.Send(userDeleteCommand, CancellationToken.None).ConfigureAwait(true); if (!userAddResponse.Success) { return(new ResponseViewModel(false, userAddResponse.Object)); } // Deleta o Perfil ProfileDeleteCommand profileDeleteCommand = new ProfileDeleteCommand(guidProfile); ResponseCommand profileDeleteResponse = await _mediator.Send(profileDeleteCommand, CancellationToken.None).ConfigureAwait(true); if (!profileDeleteResponse.Success) { return(new ResponseViewModel(false, profileDeleteResponse.Object)); } // Comita e Retorna _unitOfWork.CommitTransaction(); return(new ResponseViewModel(true, "User deleted")); } }
public void Check_SmokeSensor_Alarm_Event_Raised() { // Arrange var cmd = Helpers .CreateCommand("report", "smoke", "158d0001d8f8f7", 25885, new Dictionary <string, object> { { "alarm", "0" }, }); // Act SmokeSensor device = _fixture.GetDeviceByCommand <SmokeSensor>(cmd); var alarmEventRaised = false; device.OnAlarm += (_, args) => { alarmEventRaised = true; }; var cmd1 = Helpers .CreateCommand("report", "smoke", "158d0001d8f8f7", 25885, new Dictionary <string, object> { { "alarm", "1" }, }); device.ParseData(ResponseCommand.FromString(cmd1).Data); // Assert Assert.True(device.Alarm); Assert.True(alarmEventRaised); }
public void Send(ResponseCommand command) { UnityEngine.Debug.Assert(command != null, "command != null"); UnityEngine.Debug.Assert(command.Recipient != null, $"command.Recipient != null, Type: {command.GetType().Name}"); Send((Command)command); }
public void DadoUmComandoInvalidoDeveInterromperExecucao() { var command = new CreateTodoCommand("", DateTime.Now, ""); var handle = new TodoHandler(new FakeTodoRepository()); ResponseCommand result = (ResponseCommand)handle.Handle(command); Assert.AreEqual(result.Success, false); }
private void ProcessReport(ResponseCommand cmd) { if (_gateway != null && cmd.Sid == _gateway.Sid) { return; } GetOrAddDeviceByCommand(cmd).ParseData(cmd.Data); }
public T GetDeviceByCommand <T>(string cmd) where T : MiHomeDevice { var respCmd = ResponseCommand.FromString(cmd); T device = MiHomeDeviceFactory.CreateByModel(respCmd.Model, respCmd.Sid) as T; device.ParseData(respCmd.Data); return(device); }
public void DadoUmComandoValidoDeveCriarTarefa() { var command = new CreateTodoCommand("Titulo da Descrição", DateTime.Now, "Usuário"); var handle = new TodoHandler(new FakeTodoRepository()); ResponseCommand result = (ResponseCommand)handle.Handle(command); Assert.AreEqual(result.Success, true); }
public void Deve_Retornar_Mensagem_Sucesso() { ResponseCommand responseCommand = _anuncioHandler.Handle(_anuncioAdicionarCommand); Assert.IsTrue(Convert.ToInt32(responseCommand.Objeto) > 0); Assert.AreEqual(responseCommand.Sucesso, true); Assert.AreEqual(responseCommand.Mensagem, "Anuncio adicionado com sucesso"); }
public void CheckToken(string str, string token) { // Act var rcmd = ResponseCommand.FromString(str); // Assert Assert.Equal(token, rcmd.Token); }
public void Handle(SendTime message) { ResponseCommand command = new ResponseCommand(); command.RequestId = message.RequestId; command.state = StateCodes.ReceivedFromSaga; Bus.Send(command); }
public virtual void LineEnableCallBack(Int32 message) { ResponseCommand resCmd = (ResponseCommand)message; if (resCmd == ResponseCommand.RESPONSE_START_DETECT_LINE && !robot.onFlagGoBackReady) { robot.SwitchToDetectLine(true); } }
public static bool VerifyChecksum(ResponseCommand command, string payload, string checksum) { var calculatedChecksum = GetChecksum(command.GetStringValue() + payload); return calculatedChecksum.Equals(checksum); }