public void Salvar(IConexao conexao, TObjeto model)
        {
            if ((model == null) || (model.EstadoEntidade == EstadosEntidade.NaoModificado))
            {
                return;
            }

            var tabela   = (conexao as ContextoFake).ConsultarTabelaDoBancoDeDadosVirtual(typeof(TObjeto));
            var registro = DataTableBuilder.ConverterItemEmDataRow(tabela, model, novoRegistro: model.EstadoEntidade == EstadosEntidade.Novo);

            switch (model.EstadoEntidade)
            {
            case EstadosEntidade.Novo:
                tabela.Rows.Add(registro);
                if (_dicionario.AutoIncremento == OpcoesAutoIncremento.Identity)
                {
                    var autoIncremento = Convert.ToInt32(registro[ConsultarColunaIdentity(tabela)]);
                    AtribuirValorAutoIncremento(Incremento.Identity, item => item.Propriedade.SetValue(model, autoIncremento, null));
                }
                break;

            case EstadosEntidade.Modificado:
                AtualizarRegistro(tabela, registro);
                break;

            case EstadosEntidade.Excluido:
                ExcluirRegistro(tabela, registro);
                break;
            }
        }
        public void DefinirResultadoProcedure <TObjeto>(string nomeProcedure, IList <TObjeto> registros) where TObjeto : IEntidade
        {
            if (string.IsNullOrEmpty(nomeProcedure))
            {
                throw new ArgumentNullException("nomeProcedure");
            }
            var nomeRepositorio = "__proc__" + nomeProcedure;
            var tabela          = ConsultarTabelaDoBancoDeDadosVirtual(typeof(TObjeto), nomeRepositorio);

            tabela.Rows.Clear();
            foreach (var registro in registros)
            {
                tabela.Rows.Add(DataTableBuilder.ConverterItemEmDataRow(tabela, registro));
            }
        }
 public void Inserir(TObjeto model)
 {
     if (_validarAoSalvar)
     {
         Validar(model);
     }
     model.EstadoEntidade = EstadosEntidade.Novo;
     _persistencia.Dados.Add(model);
     _contexto.Transacoes.AdicionarTransacao(_persistencia, model);
     _bancoDeDadosVirtual.Rows.Add(DataTableBuilder.ConverterItemEmDataRow(_bancoDeDadosVirtual, model));
     if (SalvarFilhos && FilhosRepositorio != null)
     {
         var chave = _persistencia.Dicionario.ConsultarValoresDaChave(model);
         FilhosRepositorio.InserirFilhos(model, chave);
     }
 }
 private void AdicionarRegistro(Dicionario dicionario, DataTable tabela, object registro)
 {
     tabela.Rows.Add(DataTableBuilder.ConverterItemEmDataRow(tabela, registro));
     if (dicionario.PossuiCamposFilho)
     {
         var chave = dicionario.ConsultarValoresDaChave(registro);
         foreach (var item in dicionario.ConsultarCamposFilho())
         {
             var valores = item.Propriedade.GetValue(registro, null);
             if (valores == null)
             {
                 continue;
             }
             AdicionarRegistros(item.Ligacao.Dicionario.Tipo, (IEnumerable)valores,
                                (r) => item.Ligacao.AplicarChaveAscendente(chave, r));
         }
     }
 }
Example #5
0
        public void SeConverterItemEmDataRowDeveGerarUmDataRowEsperado()
        {
            var dicionario = new Dicionario(typeof(ObjetoDeTestes));
            var tabela     = DataTableBuilder.CriarDataTable(dicionario);
            var agora      = DateTime.Now;

            var objeto = new ObjetoDeTestes()
            {
                Codigo       = 1,
                CodigoNulo   = 2,
                Nome         = "ABC",
                Duplo        = 123.56,
                DuploNulo    = 123.5,
                Decimal      = 234.67M,
                DecimalNulo  = 234.6M,
                Logico       = true,
                DataHora     = agora,
                DataHoraNulo = agora.AddDays(1)
            };

            var registro = DataTableBuilder.ConverterItemEmDataRow(tabela, objeto);

            registro.RowState
            .Should()
            .Be(DataRowState.Detached);

            registro["Codigo"]
            .Should()
            .Be(1);

            registro["CodigoNulo"]
            .Should()
            .Be(2);

            registro["Nome"]
            .Should()
            .Be("ABC");

            registro["Duplo"]
            .Should()
            .Be(123.56);

            registro["DuploNulo"]
            .Should()
            .Be(123.5);

            registro["Decimal"]
            .Should()
            .Be(234.67M);

            registro["DecimalNulo"]
            .Should()
            .Be(234.6M);

            registro["Logico"]
            .Should()
            .Be(true);

            registro["DataHora"]
            .Should()
            .Be(agora);

            registro["DataHoraNulo"]
            .Should()
            .Be(agora.AddDays(1));
        }