public tb_operador BuscarOperadorPorCodigo(int cod_empresa, int cod_oper, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            var dao = transacao == null?_factory.GetDaoCorporativo <tb_operador>() : _factory.GetDaoCorporativo <tb_operador>(transacao);

            tb_operador retorno = null;

            if (cod_empresa == null || cod_empresa <= 0)
            {
                throw new ApplicationException("Código da empresa inválido");
            }

            if (cod_oper == null || cod_oper <= 0)
            {
                throw new ApplicationException("Código do operador inválido");
            }

            string where = $" cod_empresa = {cod_empresa} and cod_oper = {cod_oper} ";

            var listaEntity = dao.Obter(where);

            if (listaEntity != null && listaEntity.Any())
            {
                retorno = listaEntity.FirstOrDefault();
            }

            _log.TraceMethodEnd();
            return(retorno);
        }
예제 #2
0
        public void AtualizarOperadorGerente(tb_operador operador)
        {
            _log.TraceMethodStart();

            using (var transacao = _factoryCore.GetTransacao())
            {
                transacao.BeginTransaction();
                try
                {
                    _serviceOperador.EditarOperador(operador, transacao);

                    if (operador.tb_gerentes != null && operador.tb_gerentes.Any())
                    {
                        foreach (tb_gerente gerente in operador.tb_gerentes)
                        {
                            _serviceGerente.EditarGerente(gerente, transacao);
                        }
                    }

                    transacao.Commit();
                }
                catch (Exception ex)
                {
                    transacao.Rollback();
                    throw;
                }
            }
            _log.TraceMethodEnd();
        }
        public void ExcluirOperadorDependencia(int emp_cod, int oper_cod, int dep_cod, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            if (emp_cod == null || emp_cod <= 0)
            {
                throw new ApplicationException("Código da empresa inválido");
            }

            if (oper_cod == null || oper_cod <= 0)
            {
                throw new ApplicationException("Código do operador inválido");
            }

            if (dep_cod == null || dep_cod <= 0)
            {
                throw new ApplicationException("Código da dependencia inválido");
            }

            tb_empresa empresa = _empresaService.BuscarEmpresaPorCodigo(emp_cod, transacao);

            if (empresa == null)
            {
                throw new ApplicationException("Empresa informada não cadastrada");
            }

            tb_operador operador = _operadorService.BuscarOperadorPorCodigo(emp_cod, oper_cod, transacao);

            if (operador == null)
            {
                throw new ApplicationException("Operador informado não cadastrado");
            }

            tb_dependencia dependencia = _dependenciaService.BuscarDependenciaPorCodigo(emp_cod, oper_cod, transacao);

            if (operador == null)
            {
                throw new ApplicationException("Dependência informado não cadastrado");
            }

            var dao = _factory.GetDaoCorporativo <tb_depope>();

            string where = $" emp_cod = {emp_cod} and oper_cod = {oper_cod} and depend_cod = {dep_cod} ";

            var entityBanco = dao.Obter(where);

            if (entityBanco == null || !entityBanco.Any())
            {
                throw new ApplicationException($"Dados informados não estão cadastrados - empresa: {emp_cod}, operador: {oper_cod} e dependencia: {dep_cod}");
            }

            var entity = entityBanco.FirstOrDefault();

            dao.Remover(entity, where);

            _log.TraceMethodEnd();
        }
        public void EditarOperadorDependencia(tb_depope entity, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            var dao = transacao == null?_factory.GetDaoCorporativo <tb_depope>() : _factory.GetDaoCorporativo <tb_depope>(transacao);

            if (entity.emp_cod == null || entity.emp_cod.Value <= 0)
            {
                throw new ApplicationException("Código da empresa inválido");
            }

            if (entity.oper_cod == null || entity.oper_cod.Value <= 0)
            {
                throw new ApplicationException("Código do operador inválido");
            }

            if (entity.depend_cod == null || entity.depend_cod.Value <= 0)
            {
                throw new ApplicationException("Código de dependencia inválido");
            }

            tb_empresa empresa = _empresaService.BuscarEmpresaPorCodigo(entity.emp_cod.Value, transacao);

            if (empresa == null)
            {
                throw new ApplicationException("Empresa informada não cadastrada");
            }

            tb_dependencia dependencia = _dependenciaService.BuscarDependenciaPorCodigo(entity.emp_cod.Value, entity.depend_cod.Value, transacao);

            if (dependencia == null)
            {
                throw new ApplicationException("Dependencia informada não cadastrada");
            }

            tb_operador operador = _operadorService.BuscarOperadorPorCodigo(entity.emp_cod.Value, entity.oper_cod.Value, transacao);

            if (dependencia == null)
            {
                throw new ApplicationException("Operador informado não cadastrado");
            }

            string where = $" emp_cod = {entity.emp_cod} and oper_cod = {entity.oper_cod} ";

            var entityBanco = dao.Obter(where);

            if (entityBanco == null || !entityBanco.Any())
            {
                throw new ApplicationException($"Dados informados não foram cadastrados - empresa: {entity.emp_cod} e operador dependencia: {entity.oper_cod} ");
            }

            dao.Atualizar(entity, where);

            _log.TraceMethodEnd();
        }
예제 #5
0
        public tb_operador BuscarOperadorGerentePorCodigo(int cod_empresa, int cod_oper, string tipoGerente, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            tb_operador operador = _serviceOperador.BuscarOperadorPorCodigo(cod_empresa, cod_oper, transacao);

            if (operador != null)
            {
                operador.tb_gerentes = _serviceGerente.BuscarGerente(cod_empresa, cod_oper, tipoGerente, transacao);
            }

            _log.TraceMethodEnd();
            return(operador);
        }
        public tb_operador GravarOperador(tb_operador entity, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            var dao = transacao == null?_factory.GetDaoCorporativo <tb_operador>() : _factory.GetDaoCorporativo <tb_operador>(transacao);

            if (entity.cod_empresa == null || entity.cod_empresa <= 0)
            {
                throw new ApplicationException("Código da empresa inválido");
            }

            if (entity.cod_oper == null || entity.cod_oper <= 0)
            {
                throw new ApplicationException("Código do operador inválido");
            }

            tb_empresa empresa = _empresaService.BuscarEmpresaPorCodigo(entity.cod_empresa.Value, transacao);

            if (empresa == null)
            {
                throw new ApplicationException("Empresa informada não cadastrada");
            }

            string where = $" cod_empresa = {entity.cod_empresa}  and cod_oper = {entity.cod_oper} ";

            var entityBanco = dao.Obter(where);

            if (entityBanco != null && entityBanco.Any())
            {
                throw new ApplicationException($"Dados informados já foram cadastrados - empresa: {entity.cod_empresa} e operador: {entity.cod_oper} ");
            }

            if (entity.dat_cad == null || entity.dat_cad == DateTime.MinValue)
            {
                entity.dat_cad = DateTime.Now;
            }

            if (entity.dat_atu == null || entity.dat_atu == DateTime.MinValue)
            {
                entity.dat_atu = DateTime.Now;
            }

            entity = dao.Inserir(entity);

            _log.TraceMethodEnd();
            return(entity);
        }
예제 #7
0
        public MsgRegistroOperador Adaptartb_operadorToMsgOperadorGerente(tb_operador tb_operador)
        {
            _log.TraceMethodStart();

            MsgRegistroOperador msg = new MsgRegistroOperador();

            msg = tb_operadorToMsgOperador(tb_operador);

            if (tb_operador.tb_gerentes != null && tb_operador.tb_gerentes.Any())
            {
                msg = _AdaptadorGerente.Adaptartb_depndenciaToMsgOperador(msg, tb_operador.tb_gerentes.First(g => g.sit_gerente.Equals(tb_gerente.sit_gerenteDefault)));
            }

            _log.TraceMethodEnd();

            return(msg);
        }
예제 #8
0
        public tb_operador AdaptarMsgOperadorGerenteTotb_operador(MsgRegistroOperador msg, string modo)
        {
            _log.TraceMethodStart();

            tb_operador tb_operador = new tb_operador();

            tb_operador = AdaptarMsgOperadorTotb_operador(msg, modo);

            var listatbgerente = new List <tb_gerente>();

            if (_AdaptadorGerente.OperadorEhUmGerente(msg))
            {
                listatbgerente.Add(_AdaptadorGerente.AdaptarMsgOperadorTotb_gerente(msg, modo));
            }

            tb_operador.tb_gerentes = listatbgerente;

            _log.TraceMethodEnd();

            return(tb_operador);
        }
예제 #9
0
        public MsgRegistroOperador tb_operadorToMsgOperador(tb_operador tb_operador)
        {
            _log.TraceMethodStart();

            MsgRegistroOperador msg = new MsgRegistroOperador();

            if (tb_operador.cod_empresa != null && tb_operador.cod_empresa.Value > 0)
            {
                msg.codigoSisbacen = tb_operador.cod_empresa;
            }

            if (tb_operador.cod_oper != null && tb_operador.cod_oper.Value > 0)
            {
                msg.codigoFuncionario = tb_operador.cod_oper;
            }

            if (tb_operador.cod_depend != null && tb_operador.cod_depend.Value > 0)
            {
                msg.codigoDependenciaSisbacen = tb_operador.cod_depend;
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.nom_oper))
            {
                msg.nomeFuncionario = tb_operador.nom_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.nom_abv_oper))
            {
                msg.nomeAbreviadoFuncionario = tb_operador.nom_abv_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.idt_oper))
            {
                msg.identificadorFuncionario = tb_operador.idt_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.log_oper))
            {
                msg.loginFuncionario = tb_operador.log_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.tip_oper))
            {
                msg.tipoFuncionario = tb_operador.tip_oper.TrimEnd();
            }

            if (tb_operador.dat_cad != null && tb_operador.dat_cad.Value != DateTime.MinValue)
            {
                msg.dataCadastro = tb_operador.dat_cad;
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.usu_atu))
            {
                msg.usuarioUltimaAtualizacao = tb_operador.usu_atu.TrimEnd();
            }

            if (tb_operador.dat_atu != null && tb_operador.dat_atu.Value != DateTime.MinValue)
            {
                msg.dataUltimaAtualizacao = tb_operador.dat_atu;
            }

            if (tb_operador.dat_sit != null && tb_operador.dat_sit.Value != DateTime.MinValue)
            {
                msg.dataSituacao = tb_operador.dat_sit;
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.idc_sit))
            {
                msg.indicadorSituacao = tb_operador.idc_sit.TrimEnd();
            }

            if (tb_operador.cod_cargo != null && tb_operador.cod_cargo.Value > 0)
            {
                msg.codigoCargoFuncionario = tb_operador.cod_cargo;
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.cpf_oper))
            {
                msg.cpfOperador = tb_operador.cpf_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.dig_oper))
            {
                msg.digitoOperador = tb_operador.dig_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.sex_oper))
            {
                msg.sexoOperador = tb_operador.sex_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.ddd_oper))
            {
                msg.dddOperador = tb_operador.ddd_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.tel_oper))
            {
                msg.telefoneOperador = tb_operador.tel_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.ram_oper))
            {
                msg.ramalOperador = tb_operador.ram_oper.TrimEnd();
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.eml_oper))
            {
                msg.emailOperador = tb_operador.eml_oper.TrimEnd();
            }

            if (tb_operador.cod_ger_origem != null && tb_operador.cod_ger_origem.Value > 0)
            {
                msg.codigoGerenteOrigem = tb_operador.cod_ger_origem;
            }

            if (!string.IsNullOrWhiteSpace(tb_operador.OPECODCRK))
            {
                msg.codigoCRK = tb_operador.OPECODCRK.TrimEnd();
            }

            _log.TraceMethodEnd();

            return(msg);
        }
예제 #10
0
        public tb_operador AdaptarMsgOperadorTotb_operador(MsgRegistroOperador msg, string modo)
        {
            _log.TraceMethodStart();

            tb_operador tb_operador = new tb_operador();

            if (msg.codigoSisbacen != null && msg.codigoSisbacen.Value > 0)
            {
                tb_operador.cod_empresa = msg.codigoSisbacen;
            }

            if (msg.codigoFuncionario != null && msg.codigoFuncionario.Value > 0)
            {
                tb_operador.cod_oper = msg.codigoFuncionario;
            }

            if (msg.codigoDependenciaSisbacen != null && msg.codigoDependenciaSisbacen.Value > 0)
            {
                tb_operador.cod_depend = msg.codigoDependenciaSisbacen;
            }

            if (!string.IsNullOrWhiteSpace(msg.nomeFuncionario))
            {
                tb_operador.nom_oper = msg.nomeFuncionario;
            }

            if (!string.IsNullOrWhiteSpace(msg.nomeAbreviadoFuncionario))
            {
                tb_operador.nom_abv_oper = msg.nomeAbreviadoFuncionario;
            }

            if (!string.IsNullOrWhiteSpace(msg.identificadorFuncionario))
            {
                tb_operador.idt_oper = msg.identificadorFuncionario;
            }

            if (!string.IsNullOrWhiteSpace(msg.loginFuncionario))
            {
                tb_operador.log_oper = msg.loginFuncionario;
            }

            if (!string.IsNullOrWhiteSpace(msg.tipoFuncionario))
            {
                tb_operador.tip_oper = msg.tipoFuncionario;
            }

            if (msg.dataCadastro != null && msg.dataCadastro.Value != DateTime.MinValue)
            {
                tb_operador.dat_cad = msg.dataCadastro;
            }

            if (!string.IsNullOrWhiteSpace(msg.usuarioUltimaAtualizacao))
            {
                tb_operador.usu_atu = msg.usuarioUltimaAtualizacao;
            }

            if (msg.dataUltimaAtualizacao != null && msg.dataUltimaAtualizacao.Value != DateTime.MinValue)
            {
                tb_operador.dat_atu = msg.dataUltimaAtualizacao;
            }

            if (msg.dataSituacao != null && msg.dataSituacao.Value != DateTime.MinValue)
            {
                tb_operador.dat_sit = msg.dataSituacao;
            }

            if (!string.IsNullOrWhiteSpace(msg.indicadorSituacao))
            {
                tb_operador.idc_sit = msg.indicadorSituacao;
            }

            if (msg.codigoCargoFuncionario != null && msg.codigoCargoFuncionario.Value > 0)
            {
                tb_operador.cod_cargo = msg.codigoCargoFuncionario;
            }

            if (!string.IsNullOrWhiteSpace(msg.cpfOperador))
            {
                tb_operador.cpf_oper = msg.cpfOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.digitoOperador))
            {
                tb_operador.dig_oper = msg.digitoOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.sexoOperador))
            {
                tb_operador.sex_oper = msg.sexoOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.dddOperador))
            {
                tb_operador.ddd_oper = msg.dddOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.telefoneOperador))
            {
                tb_operador.tel_oper = msg.telefoneOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.ramalOperador))
            {
                tb_operador.ram_oper = msg.ramalOperador;
            }

            if (!string.IsNullOrWhiteSpace(msg.emailOperador))
            {
                tb_operador.eml_oper = msg.emailOperador;
            }

            if (msg.codigoGerenteOrigem != null && msg.codigoGerenteOrigem.Value > 0)
            {
                tb_operador.cod_ger_origem = msg.codigoGerenteOrigem;
            }

            if (!string.IsNullOrWhiteSpace(msg.codigoCRK))
            {
                tb_operador.OPECODCRK = msg.codigoCRK;
            }

            _log.TraceMethodEnd();

            return(tb_operador);
        }
예제 #11
0
        public ActionResult postOperador([FromBody] MsgOperador msg)
        {
            List <string> listaErros = new List <string>();
            MsgRetorno    retorno;

            try
            {
                _log.TraceMethodStart();

                if (msg == null)
                {
                    throw new ApplicationException("Mensagem inválida");
                }
                if (msg.header == null)
                {
                    throw new ApplicationException("Mensagem inválida - chave header não informada");
                }
                if (msg.body == null)
                {
                    throw new ApplicationException("Mensagem inválida - chave body não informada");
                }
                if (msg.body.RegistroOperador == null)
                {
                    throw new ApplicationException("Mensagem inválida - corpo da mensagem não informado");
                }

                if (string.IsNullOrWhiteSpace(msg.header.identificadorEnvio))
                {
                    msg.header.identificadorEnvio = Util.GerarIdentificadorUnico();
                }

                _log.Information($"Iniciando o processamento da mensagem [post] com o identificador {msg.header.identificadorEnvio}");
                _log.SetIdentificador(msg.header.identificadorEnvio);

                if (!Util.ValidarApiKey(Request, _configuracaoBaseAPI))
                {
                    return(StatusCode((int)HttpStatusCode.Unauthorized));
                }

                listaErros = Util.ValidarModel(ModelState);
                if (listaErros.Any())
                {
                    retorno = _adaptador.AdaptarMsgRetorno(msg, listaErros);

                    _log.TraceMethodEnd();
                    return(StatusCode((int)HttpStatusCode.BadRequest, retorno));
                }

                tb_operador tb_operador = _adaptador.AdaptarMsgOperadorGerenteTotb_operador(msg.body.RegistroOperador, ConstantesIntegracao.ModoIntegracao.ModoInclusao);

                _operadorGerenteService.GravarOperadorGerente(tb_operador);

                retorno = _adaptador.AdaptarMsgRetorno(msg, listaErros);

                _log.TraceMethodEnd();
                return(StatusCode((int)HttpStatusCode.OK, retorno));
            }
            catch (LogErrorException LogEx)
            {
                listaErros.Add(LogEx.Message);
                retorno = _adaptador.AdaptarMsgRetorno(msg, listaErros);
                return(StatusCode((int)HttpStatusCode.InternalServerError, retorno));
            }
            catch (ApplicationException appEx)
            {
                listaErros.Add(appEx.Message);
                retorno = _adaptador.AdaptarMsgRetorno(msg, listaErros);

                _log.Error(appEx);
                _log.TraceMethodEnd();
                return(StatusCode((int)HttpStatusCode.BadRequest, retorno));
            }
            catch (Exception ex)
            {
                listaErros.Add(ex.Message);
                retorno = _adaptador.AdaptarMsgRetorno(msg, listaErros);

                _log.Error(ex);
                _log.TraceMethodEnd();
                return(StatusCode((int)HttpStatusCode.InternalServerError, retorno));
            }
        }
예제 #12
0
        public ActionResult getOperador([FromRoute] int?codOperador, [FromQuery] int?codEmpresa, [FromQuery] string tipoGerente)
        {
            List <string>           listaErros = new List <string>();
            MsgRetorno              retorno;
            string                  identificador = string.Empty;
            MsgRegistroOperadorBody body          = new MsgRegistroOperadorBody();

            try
            {
                _log.TraceMethodStart();

                identificador = Util.GerarIdentificadorUnico();
                _log.Information($"Iniciando processamento [delete] com o identificador {identificador}");
                _log.SetIdentificador(identificador);

                if (codOperador == null)
                {
                    throw new ApplicationException("Parâmetro codOperador obrigatório");
                }

                if (!Util.ValidarApiKey(Request, _configuracaoBaseAPI))
                {
                    return(StatusCode((int)HttpStatusCode.Unauthorized));
                }


                if (codOperador == null || codOperador.Value == 0)
                {
                    throw new ApplicationException("Parâmetro codEmpresa - obrigatório");
                }
                if (codEmpresa == null || codEmpresa.Value == 0)
                {
                    throw new ApplicationException("Parâmetro codEmpresa - obrigatório");
                }
                if (string.IsNullOrWhiteSpace(tipoGerente))
                {
                    tipoGerente = tb_gerente.tip_gerenteDefault;
                }

                tb_operador operador = _operadorGerenteService.BuscarOperadorGerentePorCodigo(codEmpresa.Value, codOperador.Value, tipoGerente);

                if (operador != null)
                {
                    body.RegistroOperador = _adaptador.Adaptartb_operadorToMsgOperadorGerente(operador);
                }

                retorno = _adaptador.AdaptarMsgRetornoGet(body, listaErros, identificador);

                _log.TraceMethodEnd();

                return(StatusCode((int)HttpStatusCode.OK, retorno));
            }
            catch (LogErrorException LogEx)
            {
                listaErros.Add(LogEx.Message);
                retorno = _adaptador.AdaptarMsgRetornoGet(listaErros, identificador);
                return(StatusCode((int)HttpStatusCode.InternalServerError, retorno));
            }
            catch (ApplicationException appEx)
            {
                listaErros.Add(appEx.Message);
                retorno = _adaptador.AdaptarMsgRetornoGet(listaErros, identificador);

                _log.Error(appEx);
                _log.TraceMethodEnd();
                return(StatusCode((int)HttpStatusCode.BadRequest, retorno));
            }
            catch (Exception ex)
            {
                listaErros.Add(ex.Message);
                retorno = _adaptador.AdaptarMsgRetornoGet(listaErros, identificador);

                _log.Error(ex);
                _log.TraceMethodEnd();
                return(StatusCode((int)HttpStatusCode.InternalServerError, retorno));
            }
        }
        public void EditarOperador(tb_operador entity, IDaoTransacao transacao = null)
        {
            _log.TraceMethodStart();

            var dao = transacao == null?_factory.GetDaoCorporativo <tb_operador>() : _factory.GetDaoCorporativo <tb_operador>(transacao);

            if (entity.cod_empresa == null || entity.cod_empresa <= 0)
            {
                throw new ApplicationException("Código da empresa inválido");
            }

            if (entity.cod_oper == null || entity.cod_oper <= 0)
            {
                throw new ApplicationException("Código do operador inválido");
            }

            tb_empresa empresa = _empresaService.BuscarEmpresaPorCodigo(entity.cod_empresa.Value, transacao);

            if (empresa == null)
            {
                throw new ApplicationException("Empresa informada não cadastrada");
            }

            string where = $" cod_empresa = {entity.cod_empresa} and cod_oper = {entity.cod_oper} ";

            var listaEntityBanco = dao.Obter(where);

            if (listaEntityBanco == null || !listaEntityBanco.Any())
            {
                throw new ApplicationException($"Dados informados não foram cadastrados - empresa: {entity.cod_empresa} e operador: {entity.cod_oper} ");
            }

            var entityBanco = listaEntityBanco.First();

            entityBanco.cod_depend   = entity.cod_depend;
            entityBanco.nom_oper     = entity.nom_oper;
            entityBanco.nom_abv_oper = entity.nom_abv_oper;
            entityBanco.idt_oper     = entity.idt_oper;
            entityBanco.log_oper     = entity.log_oper;
            entityBanco.tip_oper     = entity.tip_oper;
            entityBanco.usu_atu      = entity.usu_atu;

            if (entity.dat_atu == null || entity.dat_atu == DateTime.MinValue)
            {
                entity.dat_atu = DateTime.Now;
            }

            entityBanco.dat_sit        = entity.dat_sit;
            entityBanco.idc_sit        = entity.idc_sit;
            entityBanco.cod_cargo      = entity.cod_cargo;
            entityBanco.cpf_oper       = entity.cpf_oper;
            entityBanco.dig_oper       = entity.dig_oper;
            entityBanco.sex_oper       = entity.sex_oper;
            entityBanco.ddd_oper       = entity.ddd_oper;
            entityBanco.tel_oper       = entity.tel_oper;
            entityBanco.ram_oper       = entity.ram_oper;
            entityBanco.eml_oper       = entity.eml_oper;
            entityBanco.cod_ger_origem = entity.cod_ger_origem;
            entityBanco.OPECODCRK      = entity.OPECODCRK;

            dao.Atualizar(entityBanco, where);

            _log.TraceMethodEnd();
        }