private void ExecuteAboutDataCommand(CommandDto commandDto) { if (commandDto.CommandType == CommandTypes.ADD) { ICommandAdd command = new AddAboutDataCommand(_loggerFactory, commandDto); command.Execute(_context); _commandDataAccessProvider.AddCommand(CommandEntity.CreateCommandEntity(commandDto)); _commandDataAccessProvider.Save(); command.UpdateIdforNewItems(); _undocommands.Push(command); } if (commandDto.CommandType == CommandTypes.UPDATE) { ICommand command = new UpdateAboutDataCommand(_loggerFactory, commandDto); command.Execute(_context); _commandDataAccessProvider.AddCommand(CommandEntity.CreateCommandEntity(commandDto)); _commandDataAccessProvider.Save(); _undocommands.Push(command); } if (commandDto.CommandType == CommandTypes.DELETE) { ICommand command = new DeleteAboutDataCommand(_loggerFactory, commandDto); command.Execute(_context); _commandDataAccessProvider.AddCommand(CommandEntity.CreateCommandEntity(commandDto)); _commandDataAccessProvider.Save(); _undocommands.Push(command); } }
public async Task <bool> TryHandlingCustomCommand(ICommandContext context, string message) { if (message[0] != char.Parse(_botConfig.Prefix)) { return(false); } string cleanMsg = message.Substring(1, message.Length - 1); var command = new CommandDto { GuildID = context.Guild.Id, Name = cleanMsg }; var payload = _discordPayloadFactory.CreateDiscordObjectPayload <CommandAPIPayload>(command); var result = await _apiService.GetAsync(payload); if (result.IsSuccessStatusCode) { var resultCommand = await result.Content.ReadAsJsonAsync <CommandDto>(); await context.Channel.SendMessageAsync(resultCommand.Body); return(true); } return(false); }
public async Task <string> ExecuteCommand(CommandDto command) { try { using (Runspace runspace = RunspaceFactory.CreateRunspace()) { runspace.Open(); Pipeline pipeline = runspace.CreatePipeline(); pipeline.Commands.AddScript(command.Argument); pipeline.Commands.Add("Out-String"); Collection <PSObject> results = pipeline.Invoke(); runspace.CloseAsync(); StringBuilder stringBuilder = new StringBuilder(); foreach (var result in results) { stringBuilder.AppendLine(result.ToString()); } _logger.LogInformation(stringBuilder.ToString()); return(stringBuilder.ToString()); } } catch (Exception e) { _logger.LogError(e.Message); return(e.Message); } }
public void CanCreateProductWithCommand_CallsRepository() { var commandRepoMock = new Mock <ICommandStateRepository>(); var productsMock = new Mock <IProductService>(); var commandState = new Fakes.CommandState(); commandRepoMock.Setup(t => t.CreateCommandState()).Returns(commandState); var guid = Guid.NewGuid(); var name = "New Project"; var sut = new CommandManager(commandRepoMock.Object, new DateTimeProvider()); var commandConfig = new CommandConfig { Assembly = TestGlobals.Assembly, NameSpace = TestGlobals.Namespace, Name = CommandTypes.Create.ToString(), ProcessorName = TestGlobals.Entity, Processor = productsMock.Object }; sut.AddConfig(commandConfig); var commandDto = new CommandDto { Entity = TestGlobals.Entity, EntityGuid = guid, Name = CommandTypes.Create.ToString(), ParametersJson = @"{name: '" + name + "'}" }; var sutResult = sut.ProcessCommand(commandDto); productsMock.Verify(v => v.CreateProduct(guid, name), Times.Once); }
private Command CreateCommand(CommandDto commandDto) // TODO: Move to a command factory class { if (commandDto == null) { throw new CommandParseException("Unknown command"); } switch (commandDto.Type) { case CommandType.StartGame: return(new StartGameCommand()); case CommandType.RedrawCard: if (!commandDto.CardId.HasValue) { throw new CommandParseException(); } return(new RedrawCardCommand { CardId = commandDto.CardId.Value }); case CommandType.EndRedrawCard: return(new EndRedrawCardCommand()); case CommandType.ForfeitGame: return(new ForfeitGameCommand()); case CommandType.Pass: return(new PassCommand()); case CommandType.PickStartingPlayer: if (!commandDto.StartingPlayerUserId.HasValue) { throw new CommandParseException(); } return(new PickStartingPlayerCommand { StartingPlayerUserId = commandDto.StartingPlayerUserId.Value }); case CommandType.PlayCard: if (!commandDto.CardId.HasValue || !commandDto.Slot.HasValue) { throw new CommandParseException(); } return(new PlayCardCommand { CardId = commandDto.CardId.Value, TargetCardId = commandDto.ResurrectCardId, Slot = commandDto.Slot.Value }); case CommandType.UseBattleKingCard: return(new UseBattleKingCardCommand()); default: throw new CommandParseException("Unknown command"); } }
public async Task Post(CommandDto commandDto) { _logger.LogInformation($"Started to execute command:{commandDto.CommandName}, for device:{commandDto.DeviceName}"); await _commandInvoker.InvokeAsync(commandDto.CommandName, commandDto.DeviceName); _logger.LogInformation($"Command executed"); }
public void ExecuteCommand(CommandDto command) { _netMQManage.ExecuteCommand(command); _opertionRepository.InsertAsync(new OperationInfo() { Type = OperationType.Command, Remark = "直播云端命令:" + command.CommandType.ToEnumDesc(), ParamValue = command.ToJson() }); }
public ActionResult <CommandDto> CreateCommand(CommandDto commandDto) { var commandModel = _mapper.Map <Command>(commandDto); _repository.CreateCommand(commandModel); _repository.SaveChanges(); return(CreatedAtRoute(nameof(GetCommandById), new { commandDto.Id }, commandDto)); }
public void Restart() { _isPaused = true; var dto = new CommandDto(DtoType.Restart); _timer.Dispose(); _objectStateTimer.Dispose(); _client.Send(JsonConvert.SerializeObject(dto)); }
public async Task <IRpcMethodResult> ExecuteWithCorrelationAndHeaders( string routingKey, CommandDto command, string authorizationToken, string correlationId, Dictionary <string, string> headers ) { if (string.IsNullOrWhiteSpace(routingKey)) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Routing Key must be provided.")); } if (command == null) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Command must be provided.")); } if (string.IsNullOrWhiteSpace(command.Name)) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Command Name must be provided.")); } if (command.Data == null) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Command Data must be provided.")); } if (string.IsNullOrWhiteSpace(authorizationToken)) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Authorization Token must be provided.")); } if (string.IsNullOrWhiteSpace(correlationId)) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Correlation ID must be provided.")); } if (headers == null) { return(new RpcMethodErrorResult((int)RpcErrorCode.InvalidParams, "Headers must be provided.")); } headers[CommandMessageHeaderNames.RoutingKey] = routingKey; headers[CommandMessageHeaderNames.AuthorizationToken] = authorizationToken; headers[CommandMessageHeaderNames.CorrelationId] = correlationId; CommandMessage commandMessage = new CommandMessage( new CommandMessageBody(command.Name, command.Data), new HeaderCollection(headers) ); try { await _commandGateway.Send(commandMessage); } catch (Exception exception) { return(new RpcMethodErrorResult((int)RpcErrorCode.InternalError, exception.Message)); } return(new RpcMethodSuccessResult(new ExecuteResponseDto() { CorrelationId = correlationId })); }
public void ExecuteCommand(CommandDto command) { try { netMQService.Publish(command.FactoryCode, command); LogHelper.Debug("命令已发送:" + command.ToJson()); } catch (Exception ex) { LogHelper.Error(ex); } }
public CommandDto ActualCommandDtoForNewState(string commandType) { var aboutData = _commandDto.Payload.ToObject <AboutData>(); var commandDto = new CommandDto(); commandDto.ActualClientRoute = _commandDto.ActualClientRoute; commandDto.CommandType = _commandDto.CommandType; commandDto.PayloadType = _commandDto.PayloadType; aboutData.Deleted = _aboutData.Deleted; commandDto.Payload = JObject.FromObject(aboutData); return(commandDto); }
public Task <IRpcMethodResult> Execute( string routingKey, CommandDto command, string authorizationToken ) { return(ExecuteWithCorrelationAndHeaders( routingKey, command, authorizationToken, Guid.NewGuid().ToString(), new Dictionary <string, string>() )); }
public void StopPush(CommandDto commandDto) { ChannelPusher channelPusher = ChannelPusherService.GetChannelPusherById(commandDto); if (channelPusher != null) { channelPusher.CTS.Cancel(); PushAMsgIn(commandDto.ChanneId, commandDto.Id, $"推流日志:发送停止命令完毕.", LiveStateType.Stoped); ChannelPusherService.RemoveChannelPusher(channelPusher); //重新序列化命令组 SerializationCommangs(); } }
public ActionResult UpdateCommand(int id, CommandDto commandUpdateDto) { var commandModelFromRepo = _repository.GetCommandById(id); if (commandModelFromRepo == null) { return(NotFound()); } _mapper.Map(commandUpdateDto, commandModelFromRepo); _repository.UpdateCommand(commandModelFromRepo); _repository.SaveChanges(); return(NoContent()); }
public CommandDto ActualCommandDtoForNewState(string commandType) { if (commandType == CommandTypes.UNDO) { var commandDto = new CommandDto(); commandDto.ActualClientRoute = _commandDto.ActualClientRoute; commandDto.CommandType = _commandDto.CommandType; commandDto.PayloadType = _commandDto.PayloadType; commandDto.Payload = JObject.FromObject(_previousHomeData); return(commandDto); } else { return(_commandDto); } }
public void CreatePostReturnsCreatedCommandAsync() { // Arrange var testGuid = Guid.NewGuid(); var newIdea = new CommandDto { Entity = "Product", Name = "Create", EntityGuid = testGuid, ParametersJson = @"{ Name: 'Test Project'}" }; // Act var response = _client.PostAsJsonAsync("/api/commands", newIdea).Result; // Assert response.EnsureSuccessStatusCode(); var returnedSession = response.Content.ReadAsJsonAsync <CommandDto>().Result; Assert.Equal(testGuid, returnedSession.EntityGuid); }
public void CommandManager_CanMergeCommandsWithNoExistingState() { Guid entityGuid = Guid.NewGuid(); var existingCreateCommand = new Fakes.CommandState { CommandTypeId = "CreateContactCommand", EntityGuid = entityGuid, Guid = Guid.NewGuid(), CreatedOn = DateTime.Now, ExecutedOn = DateTime.Now, ReceivedOn = DateTime.Now, ParametersJson = "{'Name': 'John Smith'}" }; var existingChangeEmailCommand = new Fakes.CommandState { CommandTypeId = "ChangeEmailForContactCommand", EntityGuid = entityGuid, Guid = Guid.NewGuid(), CreatedOn = DateTime.Now, ExecutedOn = DateTime.Now, ReceivedOn = DateTime.Now, ParametersJson = "{'Email': '*****@*****.**'}" }; var existingCommands = new List <ICommandState> { existingCreateCommand, existingChangeEmailCommand }; DateTimeProvider dateTimeProvider = new DateTimeProvider(); var repo = new Mock <ICommandStateRepository>(); repo.Setup(s => s.CreateCommandState()).Returns(new Fakes.CommandState()); repo.Setup(s => s.GetCommandStates(entityGuid)).Returns(existingCommands); var contactRepo = new EventSourcedMainRepository(); var processor = new ContactService(contactRepo, dateTimeProvider); // todo: make builder var sut = new CommandManager(repo.Object, dateTimeProvider); var processorConfig = new ProcessorConfig(); processorConfig.Assembly = "SoftwareManagementCore"; processorConfig.NameSpace = "ContactsShared"; processorConfig.Entity = "Contact"; processorConfig.Processor = processor; sut.AddConfig(processorConfig); // todo: make builder var updateEmailCommandDto = new CommandDto { CreatedOn = DateTime.Now.AddTicks(1), Entity = "Contact", EntityGuid = entityGuid, Guid = Guid.NewGuid(), Name = "ChangeEmailFor", ParametersJson = @"{Email: '*****@*****.**', OriginalEmail:'*****@*****.**'}" }; // var updateNameCommandDto = new CommandDto { CreatedOn = DateTime.Now.AddTicks(2), Entity = "Contact", EntityGuid = entityGuid, Guid = Guid.NewGuid(), Name = "Rename", ParametersJson = @"{ Name: 'James Smith', OriginalName: 'John Smith'}" }; var commandDtos = new List <CommandDto> { updateEmailCommandDto }; sut.MergeCommands(commandDtos); var contact = processor.GetContact(entityGuid); Assert.Equal("John Smith", contact.Name); Assert.Equal("*****@*****.**", contact.Email); }
public void PausePlay() { if (_isPaused) { _isPaused = false; var dto = new CommandDto(DtoType.Play); _timer = new Timer(Tick, null, DateTime.Now.Second, _syncInterval); _client.Send(JsonConvert.SerializeObject(dto)); } else { _isPaused = true; var dto = new CommandDto(DtoType.Pause); _timer.Dispose(); _objectStateTimer.Dispose(); _client.Send(JsonConvert.SerializeObject(dto)); } }
public GameHubResult <GameDto> RecieveClientCommand(CommandDto commandDto) { try { Command command = CreateCommand(commandDto); long senderUserId = UserId; command.SenderUserId = senderUserId; int retryCount = Constants.RetryExecuteCommandCount; while (retryCount > 0) { try { return(ExecuteClientCommand(command)); } catch (OptimisticConcurrencyException) { retryCount--; } } return(new GameHubResult <GameDto> { Error = string.Format("Hub: Unable to execute command after {0} tries", Constants.RetryExecuteCommandCount) }); } catch (Exception e) { GwintException gwintException = e as GwintException; if (gwintException != null) { return(new GameHubResult <GameDto> { Error = e.Message }); } return(new GameHubResult <GameDto> { Error = "Hub: Internal server error" }); } }
public async Task <IActionResult> Post([FromBody] CommandDto command) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } string connectionString = this.configuration["ConnectionStrings:EventHub"]; string deviceId = "MyFirstIoTHubDevice"; using (var serviceClient = ServiceClient.CreateFromConnectionString(connectionString)) { var commandMessage = new Message(); commandMessage.Properties.Add(new KeyValuePair <string, string>("Command", command.Command)); commandMessage.Ack = DeliveryAcknowledgement.Full; await serviceClient.SendAsync(deviceId, commandMessage); } return(Ok()); }
public void Execute(CommandDto commandDto) { if (commandDto.PayloadType == PayloadTypes.ABOUT) { ExecuteAboutDataCommand(commandDto); return; } if (commandDto.PayloadType == PayloadTypes.HOME) { ExecuteHomeDataCommand(commandDto); return; } if (commandDto.PayloadType == PayloadTypes.NONE) { ExecuteNoDataCommand(commandDto); return; } }
/// 将一个频道压入工作列表 /// </summary> /// <param name="liveChannel"></param> /// <returns></returns> public static ChannelPusher PushChannelIntoWorkingList(CommandDto commandDto) { lock (_lockObj) { if (!IsChannelExistingInWorkingList(commandDto)) { var channelPusher = new ChannelPusher { CommandDto = commandDto }; //所有压入到工作表的状态都会修改为开始 channelPusher.CommandDto.CommandType = CommandTypeEnum.Start; ChannelPushers.Add(channelPusher); return(channelPusher); } else { return(null); } } }
public void ExecuteCommand(CommandDto command) { switch (command.CommandType) { case CommandTypeEnum.Start: StartPush(command); break; case CommandTypeEnum.Stop: StopPush(command); break; case CommandTypeEnum.Switch: case CommandTypeEnum.ReStart: RestartPush(command); break; default: PushAMsgIn(Guid.Empty, Guid.Empty, $"服务日志: 错误的命令类型,请检查!{command.ToString()}", LiveStateType.Error); break; } }
public async Task InitializePublisher(ClientConfiguration configuration) { var options = new MqttClientOptionsBuilder() .WithClientId(configuration.ClientId) .WithCleanSession(false) .WithTcpServer(configuration.Host, configuration.Port) .WithCredentials(configuration.Username, configuration.Password) .WithKeepAlivePeriod(TimeSpan.FromMilliseconds(configuration.KeepAlivePeriod)) .WithCommunicationTimeout(TimeSpan.FromMilliseconds(configuration.CommunicationTimeout)).Build(); var mqttClient = new MqttFactory().CreateMqttClient(); var connectResult = await mqttClient.ConnectAsync(options); Console.WriteLine($"Publisher connection result : {connectResult.ResultCode}"); var rpcOptions = new MqttRpcClientOptions() { TopicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy() }; var rpcClient = new MqttRpcClient(mqttClient, rpcOptions); var command = new CommandDto { Id = 1, Message = "Say Hello world!" }; var payload = JsonConvert.SerializeObject(command); Console.WriteLine($"Publisher requesting work \"DoWork\" with Id : 1"); var responseMqtt = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(50), "DoWork", payload, MqttQualityOfServiceLevel.AtLeastOnce); var response = Encoding.Default.GetString(responseMqtt); Console.WriteLine($"Publisher got response : {response}"); }
public ActionResult UpdateCommand(int id, CommandDto command) { try { var model = _repository.GetCommandById(id); if (model == null) { return(NotFound()); } _mapper.Map(command, model); _repository.UpdateCommand(model); _repository.SaveChanges(); return(NoContent()); } catch (Exception ex) { return(BadRequest(ex.Message)); } }
// TODO add return object for UI public CommandDto Redo() { var commandDto = new CommandDto(); commandDto.CommandType = CommandTypes.REDO; commandDto.PayloadType = PayloadTypes.NONE; commandDto.ActualClientRoute = "NONE"; if (_redocommands.Count > 0) { ICommand command; if (_redocommands.TryPop(out command)) { _undocommands.Push(command); command.Execute(_context); commandDto.Payload = command.ActualCommandDtoForNewState(CommandTypes.REDO).Payload; _commandDataAccessProvider.AddCommand(CommandEntity.CreateCommandEntity(commandDto)); _commandDataAccessProvider.Save(); return(command.ActualCommandDtoForNewState(CommandTypes.REDO)); } } return(commandDto); }
public AddHomeDataCommand(ILoggerFactory loggerFactory, CommandDto commandDto) { _logger = loggerFactory.CreateLogger("AddHomeDataCommand"); _commandDto = commandDto; }
public DeleteAboutDataCommand(ILoggerFactory loggerFactory, CommandDto commandDto) { _logger = loggerFactory.CreateLogger("DeleteAboutDataCommand"); _commandDto = commandDto; }
public void RestartPush(CommandDto commandDto) { StopPush(commandDto); Thread.Sleep(commandDto.CommandType == CommandTypeEnum.Switch ? 500 : 2000); StartPush(commandDto); }