Exemplo n.º 1
0
        public Task <bool> Handle(UpdateFornecedorCommand message, CancellationToken cancellationToken)
        {
            if (!message.IsValid())
            {
                NotifyValidationErrors(message);
                return(Task.FromResult(false));
            }

            var fornecedor = new Fornecedor(message.Id, message.NomeCompanhia, message.NomeContato, message.TituloContato,
                                            message.Telefone, message.EnderecoEmail, message.Endereco, message.Cidade, message.Estado, message.Pais);

            var fornecedorExiste = _fornecedorRepository.GetByNomeCompanhia(fornecedor.NomeCompanhia);

            if (fornecedorExiste != null && fornecedorExiste.Id != fornecedor.Id)
            {
                if (!fornecedorExiste.Equals(fornecedor))
                {
                    Bus.RaiseEvent(new DomainNotification(message.MessageType, "A Categria já foi recebido."));
                    return(Task.FromResult(false));
                }
            }

            _fornecedorRepository.Update(fornecedor);

            if (Commit())
            {
                Bus.RaiseEvent(new FornecedorUpdatedEvent(fornecedor.Id, fornecedor.NomeCompanhia, fornecedor.NomeContato, fornecedor.TituloContato,
                                                          fornecedor.Telefone, fornecedor.EnderecoEmail, fornecedor.Endereco, fornecedor.Cidade, fornecedor.Estado, fornecedor.Pais));
            }

            return(Task.FromResult(true));
        }
        public async Task <Unit> Handle(UpdateFornecedorCommand request, CancellationToken cancellationToken)
        {
            var fornecedor = mapper.Map <Fornecedor>(request);

            if (fornecedor == null)
            {
                throw new Exception("Fornecedor não encontrado.");
            }

            var validation = new FornecedorValidation().Validate(fornecedor);

            if (!validation.IsValid)
            {
                throw new ValidationException(validation.Errors);
            }

            fornecedorDomainService.Update(fornecedor);

            await mediator.Publish(new FornecedorNotification
            {
                Fornecedor = fornecedor,
                Action     = ActionNotification.Atualizar
            });

            return(Unit.Value);
        }
Exemplo n.º 3
0
        public override Task <CommandResult> Update(FornecedorViewModel viewModel)
        {
            var command = new UpdateFornecedorCommand(viewModel.Id, viewModel.Nome, viewModel.Tipo, viewModel.Descricao);

            command.AttachContato(viewModel.ContatoCelular, viewModel.ContatoEmail, viewModel.ContatoTelefoneComercial, viewModel.ContatoTelefoneResidencial, viewModel.ContatoObservacao);
            command.AttachEndereco(viewModel.EnderecoNumero, viewModel.EnderecoRua, viewModel.EnderecoBairro, viewModel.EnderecoComplemento, viewModel.EnderecoCidadeId, viewModel.EnderecoCEP);
            command.AttachDocumento(viewModel.DocumentoCadastroNacional, viewModel.DocumentoCadastroEstadual);

            return(_mediator.SendCommand(command));
        }
        public async Task <IActionResult> Put(UpdateFornecedorCommand command)
        {
            try
            {
                await fornecedorApplicationService.Update(command);

                return(Ok(new { Message = "Fornecedor atualizado com sucesso." }));
            }
            catch (ValidationException e)
            {
                return(BadRequest(ValidationAdapter.Parse(e.Errors)));
            }
            catch (Exception e)
            {
                return(StatusCode(500, e.Message));
            }
        }
Exemplo n.º 5
0
        public Task <CommandResult> Handle(UpdateFornecedorCommand command, CancellationToken cancellationToken)
        {
            if (!command.IsValid())
            {
                NotifyCommandErrors(command);
                return(Response());
            }

            Cidade     cidade     = _cidadeRepository.GetById(command.EnderecoCidadeId);
            Documento  documento  = new Documento(command.DocumentoCadastroNacional, command.DocumentoCadastroEstadual);
            Contato    contato    = new Contato(command.ContatoCelular, command.ContatoEmail, command.ContatoTelefoneComercial, command.ContatoTelefoneResidencial, command.ContatoObservacao);
            Endereco   endereco   = new Endereco(command.EnderecoRua, command.EnderecoNumero, command.EnderecoBairro, command.EnderecoComplemento, cidade, command.EnderecoCEP);
            Fornecedor fornecedor = new Fornecedor(command.Id, command.Nome, command.Tipo, documento, contato, endereco, command.Observacao);

            _fornecedorRepository.Update(fornecedor);

            if (Commit())
            {
                _mediator.PublishEvent(new UpdatedFornecedorEvent(fornecedor));
            }

            return(Response());
        }
Exemplo n.º 6
0
        public async Task <IActionResult> Atualizar([FromBody] UpdateFornecedorCommand command)
        {
            var updateFornecedorResult = await Mediator.Send(command);

            return(Ok(updateFornecedorResult));
        }
 public async Task Update(UpdateFornecedorCommand command)
 {
     await mediator.Send(command);
 }