public IActionResult Persistir([FromBody] ClienteServicoPrestadorVM clienteServicoPrestadorVM)
        {
            SqlConnection eacessoConnection = new SqlConnection(_connectionStrings.Value.EacessoConnection);

            eacessoConnection.Open();
            SqlTransaction eacessoTran = eacessoConnection.BeginTransaction();

            if (clienteServicoPrestadorVM.Id == 0)
            {
                var clienteServicoPrestador   = Mapper.Map <ClienteServicoPrestador>(clienteServicoPrestadorVM);
                var clienteServicoPrestadorDB = _clienteServicoPrestadorService.Adicionar(clienteServicoPrestador);
                var prestador = _prestadorService.BuscarPorId(clienteServicoPrestador.IdPrestador);

                clienteServicoPrestador.Ativo = true;
                clienteServicoPrestadorVM.Id  = clienteServicoPrestadorDB.Id;
                //Atualiza Célula Prestador STFCORP
                prestador.IdCelula = clienteServicoPrestador.IdCelula;
                _prestadorService.AtualizarPrestador(prestador);


                if (prestador.CodEacessoLegado != null)
                {
                    _prestadorService.AtualizarEAcesso(prestador.Id, eacessoConnection, eacessoTran);
                }
                _clienteServicoPrestadorService.InserirClienteServicoPrestadorEAcesso(clienteServicoPrestador, eacessoConnection, eacessoTran);
            }
            else
            {
                var clienteServicoPrestador = Mapper.Map <ClienteServicoPrestador>(clienteServicoPrestadorVM);
                _clienteServicoPrestadorService.Atualizar(clienteServicoPrestador);
                var prestador = _prestadorService.BuscarPorId(clienteServicoPrestador.IdPrestador);
                clienteServicoPrestador.Prestador = prestador;
                //Atualiza Célula Prestador
                prestador.IdCelula = clienteServicoPrestador.IdCelula;
                _prestadorService.AtualizarPrestador(prestador);

                if (prestador.CodEacessoLegado != null)
                {
                    _prestadorService.AtualizarEAcesso(prestador.Id, eacessoConnection, eacessoTran);
                    _clienteServicoPrestadorService.AtualizarEAcesso(clienteServicoPrestador, eacessoConnection, eacessoTran);
                }
            }

            eacessoTran.Commit();

            clienteServicoPrestadorVM = Mapper.Map <ClienteServicoPrestadorVM>(_clienteServicoPrestadorService.BuscarPorId(clienteServicoPrestadorVM.Id));

            return(Ok(clienteServicoPrestadorVM));
        }
Beispiel #2
0
        public IActionResult Persistir([FromBody] PrestadorVM prestadorVM)
        {
            SqlConnection eacessoConnection = new SqlConnection(_connectionStrings.Value.EacessoConnection);

            eacessoConnection.Open();
            SqlTransaction eacessoTran  = eacessoConnection.BeginTransaction();
            var            rmConnection = new SqlConnection(_connectionStrings.Value.RMIntegracaoConnection);

            rmConnection.Open();
            var rmTran = rmConnection.BeginTransaction();

            using (IDbContextTransaction tran = _unitOfWork.BeginTran())
            {
                try
                {
                    if (prestadorVM.Id == 0)
                    {
                        foreach (var contrato in prestadorVM.ContratosPrestador)
                        {
                            if (!string.IsNullOrEmpty(contrato.ArquivoBase64))
                            {
                                var tipoArquivo = contrato.NomeAnexo.Split('.')[contrato.NomeAnexo.Split('.').Length - 1];
                                contrato.CaminhoContrato = $"{Guid.NewGuid().ToString()}.{tipoArquivo}";
                                _prestadorService.FazerUploadContratoPrestadorParaOMinIO(contrato.NomeAnexo, contrato.CaminhoContrato, contrato.ArquivoBase64);

                                foreach (ExtensaoContratoPrestadorVM extensao in contrato.ExtensoesContratoPrestador)
                                {
                                    if (!string.IsNullOrEmpty(extensao.ArquivoBase64))
                                    {
                                        var extensaoTipoArquivo = extensao.NomeAnexo.Split('.')[extensao.NomeAnexo.Split('.').Length - 1];
                                        extensao.CaminhoContrato = $"{Guid.NewGuid().ToString()}.{extensaoTipoArquivo}";
                                        _prestadorService.FazerUploadExtensaoContratoPrestadorParaOMinIO(extensao.NomeAnexo, extensao.CaminhoContrato, extensao.ArquivoBase64);
                                    }
                                }
                            }
                        }

                        foreach (var documento in prestadorVM.DocumentosPrestador)
                        {
                            if (!string.IsNullOrEmpty(documento.ArquivoBase64))
                            {
                                var tipoArquivo = documento.NomeAnexo.Split('.')[documento.NomeAnexo.Split('.').Length - 1];
                                documento.CaminhoDocumento = $"{Guid.NewGuid().ToString()}.{tipoArquivo}";
                                _prestadorService.FazerUploadDocumentoPrestadorParaOMinIO(documento.NomeAnexo, documento.CaminhoDocumento, documento.ArquivoBase64);
                            }
                        }

                        var prestador = Mapper.Map <Prestador>(prestadorVM);
                        prestador.Pessoa.Usuario    = _variablesToken.UserName ?? "STFCORP";
                        prestador.EmpresasPrestador = Mapper.Map <ICollection <EmpresaPrestador> >(prestadorVM.Empresas);
                        prestador.EmpresasPrestador.ToList().ForEach(x => x.Empresa.Usuario = _variablesToken.UsuarioToken);
                        prestador.Pessoa.Endereco = Mapper.Map <Endereco>(prestadorVM.Endereco);
                        prestador.Pessoa.Telefone = Mapper.Map <Telefone>(prestadorVM.Telefone);
                        prestador.ValoresPrestador.ToList().ForEach(x => x.Usuario = _variablesToken.UsuarioToken);


                        var valorPrestadoMaisRecente = prestador.ValoresPrestador
                                                       .ToList()
                                                       .OrderByDescending(x => x.DataAlteracao)
                                                       .FirstOrDefault();

                        if (valorPrestadoMaisRecente != null)
                        {
                            prestador.IdTipoRemuneracao = valorPrestadoMaisRecente.IdTipoRemuneracao;
                        }

                        var id = _prestadorService.Adicionar(prestador);
                        _pluginRMService.EnviarPrestadorRM(id, "I", true);
                        _prestadorService.AdicionarEAcesso(id, eacessoConnection, eacessoTran);
                    }
                    else
                    {
                        var prestador = Mapper.Map <Prestador>(prestadorVM);
                        prestador.Pessoa.Usuario    = _variablesToken.UserName ?? "STFCORP";
                        prestador.EmpresasPrestador = Mapper.Map <ICollection <EmpresaPrestador> >(prestadorVM.Empresas);
                        prestador.EmpresasPrestador.ToList().ForEach(x => x.Empresa.Usuario = _variablesToken.UsuarioToken);
                        prestador.ValoresPrestador = Mapper.Map <ICollection <ValorPrestador> >(prestadorVM.ValoresPrestador);
                        prestador.ValoresPrestador.ToList().ForEach(x => x.Usuario = _variablesToken.UsuarioToken);
                        prestador.IdTipoRemuneracao = prestadorVM.ValoresPrestador?.ToList()?.OrderByDescending(x => x.DataReferencia)?.FirstOrDefault()?.IdTipoRemuneracao;
                        _prestadorService.AtualizarPrestador(prestador);

                        if (prestador.CodEacessoLegado != null)
                        {
                            _prestadorService.AtualizarEAcesso(prestador.Id, eacessoConnection, eacessoTran);
                        }

                        _pluginRMService.EnviarPrestadorRM(prestadorVM.Id, "A", false);
                    }
                    tran.Commit();
                    eacessoTran.Commit();
                    rmTran.Commit();
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    eacessoTran.Rollback();
                    rmTran.Rollback();
                    throw ex;
                }
                return(Ok(true));
            }
        }