Esempio n. 1
0
        public aRepositoryInternalWithTwoDLOs()
        {
            MapperStore store = new MapperStore();

            this._DLOMapper1 = (DapperMapper <DLO>)store.GetMapper(typeof(DLO));
            this._DLOMapper2 = (DapperMapper <DLO2>)store.GetMapper(typeof(DLO2));
        }
Esempio n. 2
0
        public AsientoRepository()
        {
            MapperStore store = new MapperStore();

            this._Mapper      = (DapperMapper <Asiento>)store.GetMapper(GetObjModelType());
            this.Transactions = new ConcurrentDictionary <aVMTabBase, List <Tuple <QueryBuilder, IConditionToCommit> > >();
        }
Esempio n. 3
0
        public PersonaRepository()
        {
            MapperStore store = new MapperStore();

            this._Mapper      = (DapperMapper <Persona>)store.GetMapper(typeof(Persona));
            this.Transactions = new ConcurrentDictionary <aVMTabBase, List <Tuple <QueryBuilder, IConditionToCommit> > >();
        }
        public void Test_StoreMapping()
        {
            // arrange
            MapperStore mapperStore = new MapperStore();
            var         sut         = new DBStore();

            sut.STORE = STORES.NEWYORK;

            // act
            var sut2   = mapperStore.Map(sut);
            var actual = sut2;

            // assert
            Assert.True(actual.STORE == STORES.NEWYORK);
        }
Esempio n. 5
0
        public aRepositoryInternalWithDLO()
        {
            MapperStore store = new MapperStore();

            this._DLOMapper = (DapperMapper <DLO>)store.GetMapper(typeof(DLO));
        }
Esempio n. 6
0
        private async Task ConfigMappersContabilidad(MapperConfig mConfig)
        {
            //ObservableApuntesList
            //mConfig
            //    .AddConstructor<ObservableApuntesList>(x =>
            //    {
            //        var store = new MapperStore();
            //        DapperMapper<Apunte> mapper = (DapperMapper<Apunte>)store.GetMapper(typeof(Apunte));
            //        List<Apunte> lista = mapper.Map(x, "Id", false); //Obtiene lista de apuntes con sobrecarga de Map()

            //        return new ObservableApuntesList(lista.First().Asiento, lista); //crea objeto a partir de esa lista
            //    })
            //    .MapOnlyConstructor<ObservableApuntesList>()
            //    .EndConfig<ObservableApuntesList>();

            //Apunte
            mConfig
            //.AddNestedProperty<Apunte>(true, "_Asiento")
            .AddMemberCreator <Apunte>("_Asiento", x =>
            {
                Asiento asiento = AsientoRepo.AsientoMapperGetFromDictionary((int)x.Asiento);
                return(asiento);
            })
            .AddMemberCreator <Apunte>("_DebeHaber", x => (DebitCredit)x.DebeHaber)
            .AddIgnoreProperty <Apunte, decimal>(x => x.ImporteAlDebe)
            .AddIgnoreProperty <Apunte, decimal>(x => x.ImporteAlHaber)
            .AddIgnoreProperty <Apunte, bool>(x => x.IsBeingModifiedFromView)
            .AddIgnoreProperty <Apunte, bool>(x => x.HasBeenModifiedFromView)
            .AddIgnoreProperty <Apunte, List <string> >(x => x.DirtyMembers)
            .AddPrefixes <Apunte>(new string[] { "apu" })
            .EndConfig <Apunte>();
            mConfig
            .AddConstructor <ApunteDLO>(x => new ApunteDLO(x.Id, x.IdOwnerComunidad, x.OrdenEnAsiento, x.Asiento, x.Concepto, x.DebeHaber,
                                                           x.Importe, x.IdCuenta, x.Punteo, x.Factura))
            .MapOnlyConstructor <ApunteDLO>()
            .EndConfig <ApunteDLO>();
            //Asiento
            mConfig
            .AddConstructor <Asiento>(x =>
            {
                var store = new MapperStore();
                DapperMapper <Apunte> mapper = (DapperMapper <Apunte>)store.GetMapper(typeof(Apunte));
                Apunte[] apuntes             = mapper.Map(x, "Id", false); //Obtiene lista de apuntes con sobrecarga de Map()

                return(new Asiento(x.Id, x.IdOwnerComunidad, x.IdOwnerEjercicio, x.Codigo, this.ACData, x.FechaValor, apuntes));
            })
            //.AddNestedProperty<Asiento, ObservableApuntesList>(false, x => x.Apuntes)
            .AddIgnoreProperty <Asiento>("Apuntes")
            .AddIgnoreProperty <Asiento>("Item")
            .AddPrefixes <Asiento>(new string[] { "asi" })
            .EndConfig <Asiento>();
            //Gasto-Pago-GastosPagosBase
            mConfig
            .AddPrefixes <GastosPagosBase.sImporteCuenta>(new string[] { "acreedora_", "deudora_" })
            .EndConfig <GastosPagosBase.sImporteCuenta>();
            mConfig
            .AddConstructor <GastosPagosBase>(x => new GastosPagosBase(x.Id, x.IdOwnerComunidad, x.IdProveedor, x.IdOwnerFactura, x.Fecha))
            .AddMemberCreator <GastosPagosBase>("_CuentasAcreedoras", x =>
            {
                MapperStore store = new MapperStore();
                DapperMapper <GastosPagosBase.sImporteCuenta> mapper =
                    (DapperMapper <GastosPagosBase.sImporteCuenta>)store.GetMapper(typeof(GastosPagosBase.sImporteCuenta));
                IEnumerable <dynamic> distinctAcreedX = mapper.GetDistinctDapperResult(x, false);
                distinctAcreedX = distinctAcreedX.Select(dyn =>
                {
                    IDictionary <string, object> dict = dyn as IDictionary <string, object>;
                    var result = new System.Dynamic.ExpandoObject() as IDictionary <string, object>;
                    foreach (KeyValuePair <string, object> kvp in dict)
                    {
                        if (kvp.Key.Contains("acreedora_"))
                        {
                            result.Add(kvp.Key, kvp.Value);
                        }
                    }

                    return(result);
                });

                return(mapper.Map <List <GastosPagosBase.sImporteCuenta> >(distinctAcreedX, "Id", false));
            })
            .AddMemberCreator <GastosPagosBase>("_CuentasDeudoras", x =>
            {
                MapperStore store = new MapperStore();
                DapperMapper <GastosPagosBase.sImporteCuenta> mapper =
                    (DapperMapper <GastosPagosBase.sImporteCuenta>)store.GetMapper(typeof(GastosPagosBase.sImporteCuenta));
                IEnumerable <dynamic> distinctDeudX = mapper.GetDistinctDapperResult(x, false);
                distinctDeudX = distinctDeudX.Select(dyn =>
                {
                    IDictionary <string, object> dict = dyn as IDictionary <string, object>;
                    var result = new System.Dynamic.ExpandoObject() as IDictionary <string, object>;
                    foreach (KeyValuePair <string, object> kvp in dict)
                    {
                        if (kvp.Key.Contains("deudora_"))
                        {
                            result.Add(kvp.Key, kvp.Value);
                        }
                    }

                    return(result);
                });

                return(mapper.Map <List <GastosPagosBase.sImporteCuenta> >(distinctDeudX, "Id", false));
            })
            //.AddIgnoreProperty<GastosPagosBase>("_CuentasAcreedoras")
            //.AddIgnoreProperty<GastosPagosBase>("_CuentasDeudoras")
            //.AddIgnoreProperty<GastosPagosBase, System.Collections.ObjectModel.ReadOnlyCollection<GastosPagosBase.sImporteCuenta>>(
            //    x => x.CuentasAcreedoras)
            //.AddIgnoreProperty<GastosPagosBase, System.Collections.ObjectModel.ReadOnlyCollection<GastosPagosBase.sImporteCuenta>>(
            //    x => x.CuentasDeudoras)
            .EndConfig <GastosPagosBase>();
            mConfig
            .AddConstructor <Gasto>(x => new Gasto(x.Id, x.IdOwnerComunidad, x.IdProveedor, x.IdOwnerFactura, x.Fecha))
            .EndConfig <Gasto>();
            mConfig
            .AddConstructor <Pago>(x => new Pago(x.Id, x.IdOwnerComunidad, x.IdProveedor, x.IdOwnerFactura, x.Fecha))
            .EndConfig <Pago>();
            //GastosPagosList-ReadOnly
            mConfig
            .AddConstructor <GastosPagosList <Gasto> >(x =>
            {
                MapperStore store           = new MapperStore();
                DapperMapper <Gasto> mapper = (DapperMapper <Gasto>)store.GetMapper(typeof(Gasto));
                List <Gasto> lista          = mapper.Map <List <Gasto> >(x, "Id", false);

                return(new GastosPagosList <Gasto>(lista));
            })
            .MapOnlyConstructor <GastosPagosList <Gasto> >()
            .EndConfig <GastosPagosList <Gasto> >();
            mConfig
            .AddConstructor <GastosPagosList <Pago> >(x =>
            {
                MapperStore store          = new MapperStore();
                DapperMapper <Pago> mapper = (DapperMapper <Pago>)store.GetMapper(typeof(Pago));
                List <Pago> lista          = mapper.Map <List <Pago> >(x, "Id", false);

                return(new GastosPagosList <Pago>(lista));
            })
            .MapOnlyConstructor <GastosPagosList <Pago> >()
            .EndConfig <GastosPagosList <Pago> >();
            mConfig
            .AddConstructor <ReadOnlyGastosPagosList <Gasto> >(x =>
            {
                MapperStore store           = new MapperStore();
                DapperMapper <Gasto> mapper = (DapperMapper <Gasto>)store.GetMapper(typeof(Gasto));
                List <Gasto> lista          = mapper.Map <List <Gasto> >(x, "Id", false);

                return(new ReadOnlyGastosPagosList <Gasto>(lista));
            })
            .MapOnlyConstructor <ReadOnlyGastosPagosList <Gasto> >()
            .EndConfig <ReadOnlyGastosPagosList <Gasto> >();
            mConfig
            .AddConstructor <ReadOnlyGastosPagosList <Pago> >(x =>
            {
                MapperStore store          = new MapperStore();
                DapperMapper <Pago> mapper = (DapperMapper <Pago>)store.GetMapper(typeof(Pago));
                List <Pago> lista          = mapper.Map <List <Pago> >(x, "Id", false);

                return(new ReadOnlyGastosPagosList <Pago>(lista));
            })
            .MapOnlyConstructor <ReadOnlyGastosPagosList <Pago> >()
            .EndConfig <ReadOnlyGastosPagosList <Pago> >();
            //Factura
            mConfig
            .AddNestedProperty <Factura>(false, "_GastosFra")
            .AddIgnoreProperty <Factura, ReadOnlyGastosPagosList <Gasto> >(x => x.GastosFra)
            .AddNestedProperty <Factura>(false, "_PagosFra")
            .AddIgnoreProperty <Factura, ReadOnlyGastosPagosList <Pago> >(x => x.PagosFra)
            .AddMemberCreator <Factura, int?>(x => x.IdOwnerProveedor, x => x.IdProveedor)
            .AddMemberCreator <Factura, TipoPagoFacturas>(x => x.TipoPago, x => (TipoPagoFacturas)x.TipoPago)
            .AddIgnoreProperty <Factura, decimal>(x => x.TotalImpuestos)
            .EndConfig <Factura>();
            mConfig
            .AddConstructor <FacturaDLO>(x => new FacturaDLO(x.Id, x.IdProveedor, x.IdOwnerComunidad, x.NFactura, x.Fecha, x.Concepto, x.Total,
                                                             x.Pendiente, (TipoPagoFacturas)x.TipoPago))
            .MapOnlyConstructor <FacturaDLO>()
            .EndConfig <FacturaDLO>();
            //CuentaMayor
            mConfig
            .AddConstructor <CuentaMayor>(x => new CuentaMayor(x.Codigo, x.Id, x.IdOwnerComunidad, x.IdOwnerEjercicio, x.Nombre))
            .MapOnlyConstructor <CuentaMayor>()
            .EndConfig <CuentaMayor>();
            mConfig
            .AddConstructor <CuentaMayorDLO>(x => new CuentaMayorDLO(int.Parse(x.Codigo), x.Id, x.IdOwnerComunidad, x.IdOwnerEjercicio, x.Nombre))
            .MapOnlyConstructor <CuentaMayorDLO>()
            .EndConfig <CuentaMayorDLO>();
            //Proveedor
            mConfig
            .AddConstructor <Proveedor>(x => new Proveedor(x.Id, x.IdPersona, x.NIF, x.Nombre, true))
            .AddNestedProperty <Proveedor>(false, "_CuentaContableGasto")
            .AddNestedProperty <Proveedor>(false, "_CuentaContablePago")
            .AddNestedProperty <Proveedor>(false, "_CuentaContableProveedor")
            .AddMemberCreator <Proveedor, TipoPagoFacturas>(x => x.DefaultTipoPagoFacturas, x => (TipoPagoFacturas)x.DefaultTipoPagoFacturas)
            .EndConfig <Proveedor>();
            mConfig
            .AddConstructor <ProveedorDLO>(x => new ProveedorDLO(x.Id, x.Nombre, x.NIF, string.Concat(x.TipoVia, " ",
                                                                                                      x.Direccion), x.CuentaBancaria, x.Telefono, x.Email, x.RazonSocial, x.CuentaContableGasto, x.CuentaContablePago,
                                                                 x.CuentaContableProveedor))
            .MapOnlyConstructor <ProveedorDLO>()
            .EndConfig <ProveedorDLO>();
            //Cobros-EntACta-iIngresoPropietario
            mConfig
            .AddInterfaceToObjectCondition <iIngresoPropietario>(x =>
            {
                var dict = x as IDictionary <string, object>;
                return(dict.ContainsKey("IdOwnerCuota"));
            },
                                                                 typeof(Cobro))
            .AddInterfaceToObjectCondition <iIngresoPropietario>(x =>
            {
                var dict = x as IDictionary <string, object>;
                return(dict.ContainsKey("IdOwnerFinca"));
            },
                                                                 typeof(EntACta))
            .EndConfig <iIngresoPropietario>();
            mConfig
            .AddConstructor <Cobro>(x => new Cobro(
                                        x.Id, x.IdOwnerRecibo, x.IdOwnerCuota, x.Importe, x.Fecha, x.IdOwnerPersona, x.Total, (SituacionReciboCobroEntaCta)x.Situacion))
            .AddPrefixes <Cobro>(new string[1] {
                "cobro"
            })
            .MapOnlyConstructor <Cobro>()
            .EndConfig <Cobro>();
            mConfig
            .AddConstructor <EntACta>(x => new EntACta(
                                          x.Id, x.IdOwnerRecibo, x.IdOwnerFinca, x.Importe, x.Fecha, x.IdOwnerPersona, (SituacionReciboCobroEntaCta)x.Situacion))
            .AddPrefixes <EntACtaDict>(new string[1] {
                "eacta"
            })
            .MapOnlyConstructor <Cobro>()
            .EndConfig <EntACta>();
            //Cobros/EntACta - List/Dict
            mConfig
            .AddConstructor <CobrosList>(x =>
            {
                MapperStore store           = new MapperStore();
                DapperMapper <Cobro> mapper = (DapperMapper <Cobro>)store.GetMapper(typeof(Cobro));
                List <Cobro> lista          = mapper.Map <List <Cobro> >(x, "Id", false);

                return(new CobrosList(lista));
            })
            .MapOnlyConstructor <CobrosList>()
            .EndConfig <EntACtaList>();
            mConfig
            .AddConstructor <CobrosDict>(x =>
            {
                MapperStore store           = new MapperStore();
                DapperMapper <Cobro> mapper = (DapperMapper <Cobro>)store.GetMapper(typeof(Cobro));
                IEnumerable <Cobro> lista   = mapper.Map <IEnumerable <Cobro> >(x);

                return(new CobrosDict(lista.ToDictionary(c => (int)c.Id, c => c)));
            })
            .MapOnlyConstructor <CobrosDict>()
            .EndConfig <CobrosDict>();
            mConfig
            .AddConstructor <EntACtaList>(x =>
            {
                MapperStore store             = new MapperStore();
                DapperMapper <EntACta> mapper = (DapperMapper <EntACta>)store.GetMapper(typeof(EntACta));
                List <EntACta> lista          = mapper.Map <List <EntACta> >(x, "Id", false);

                return(new EntACtaList(lista));
            })
            .MapOnlyConstructor <EntACtaList>()
            .EndConfig <EntACtaList>();
            mConfig
            .AddConstructor <EntACtaDict>(x =>
            {
                MapperStore store             = new MapperStore();
                DapperMapper <EntACta> mapper = (DapperMapper <EntACta>)store.GetMapper(typeof(EntACta));
                IEnumerable <EntACta> lista   = mapper.Map <IEnumerable <EntACta> >(x);

                return(new EntACtaDict(lista.ToDictionary(c => (int)c.Id, c => c)));
            })
            .MapOnlyConstructor <EntACtaDict>()
            .EndConfig <EntACtaDict>();
            //IngresoDevuelto
            mConfig
            .AddConstructor <IngresoDevuelto>(x =>
            {
                MapperStore store = new MapperStore();
                DapperMapper <iIngresoPropietario> mapper = (DapperMapper <iIngresoPropietario>)store.GetMapper(typeof(iIngresoPropietario));
                var ingreso = mapper.Map(x);
                return(new IngresoDevuelto(x.Id, x.IdOwnerDevolucion, x.Fecha, ingreso, x.Total, x.Importe, x.Gastos));
            })
            .MapOnlyConstructor <IngresoDevuelto>()
            .EndConfig <IngresoDevuelto>();
            //Devolucion-List
            mConfig
            .AddConstructor <Devolucion>(x =>
            {
                MapperStore store = new MapperStore();
                DapperMapper <IngresoDevuelto> mapper = (DapperMapper <IngresoDevuelto>)store.GetMapper(typeof(IngresoDevuelto));
                List <IngresoDevuelto> lista          = mapper.Map <List <IngresoDevuelto> >(x);

                return(new Devolucion(x.Id, x.IdOwnerComunidad, x.Fecha, lista));
            })
            .MapOnlyConstructor <Devolucion>()
            .EndConfig <Devolucion>();
            mConfig
            .AddConstructor <DevolucionesList>(x =>
            {
                MapperStore store = new MapperStore();
                DapperMapper <Devolucion> mapper = (DapperMapper <Devolucion>)store.GetMapper(typeof(Devolucion));
                IEnumerable <Devolucion> lista   = mapper.Map <IEnumerable <Devolucion> >(x);

                return(new DevolucionesList(lista.ToList()));
            })
            .MapOnlyConstructor <DevolucionesList>()
            .EndConfig <DevolucionesList>();
        }
        public void MapperTest <T>(int testsTotal, int from, int every, int idAlias = 0, bool deleteFirst = true)
        {
            //if (deleteFirst)
            //{
            //    using (SqlConnection con = new SqlConnection(conString))//(MySqlConnection con = new MySqlConnection(conString))
            //    {
            //        con.Open();
            //        var result = con.Query("DELETE FROM MapperResults");
            //        con.Close();
            //    }
            //}
            Type   t        = typeof(T);
            string filepath = @"E:\TESTMAPPER." + t.Name + ".xlsx";

            if (deleteFirst && File.Exists(filepath))
            {
                File.Delete(filepath);
            }

            var            file    = new FileInfo(filepath);
            var            package = new ExcelPackage(file);
            ExcelWorksheet wSheet  = package.Workbook.Worksheets.Add("prueba1");

            wSheet.Cells[1, 1].Value = $"MAPPERTEST:  MAP {t.Name} ; Tests: { testsTotal.ToString()}. Desde: { from.ToString()}. Cada: { every.ToString()}.";
            wSheet.Cells[2, 1].Value = "ID";
            wSheet.Cells[2, 2].Value = "TYPE";
            wSheet.Cells[2, 3].Value = "OBJECTS CREATED";
            wSheet.Cells[2, 4].Value = "SECONDS";
            wSheet.Cells[2, 5].Value = "MILISECONDS";
            wSheet.Cells[2, 6].Value = "SECONDS/OBJECTS";

            Console.WriteLine("MAPPERTEST:");
            Console.WriteLine($@"    1.- MAP {t.Name}
        tests: {testsTotal.ToString()}.
        desde: {from.ToString()}.
        cada: {every.ToString()}.");
            Console.WriteLine();
            Console.WriteLine("    -WAITING-");
            Console.ReadLine();
            Console.WriteLine("------------------");
            Console.WriteLine();

            for (int j = from, x = 0; j < (testsTotal * every); j += every, x++)
            {
                Console.WriteLine("...");
                Console.WriteLine($"    Test Nº {x.ToString()}.");
                Console.WriteLine($"    Nº objetos a crear: {j.ToString()}");
                Console.WriteLine();
                Console.WriteLine("...");

                using (SqlConnection con = new SqlConnection(conString))//(MySqlConnection con = new MySqlConnection(conString))
                {
                    con.Open();
                    var result = con.Query(@"SELECT p.Id,p.Nombre,pif.pruebaI,pif.otro,a.Id aId,a.Acc aAcc,a.Persona aPersona 
FROM Persons p 
RIGHT JOIN Acc a ON p.Id=a.Persona 
RIGHT JOIN pruebaif pif ON p.Id=pif.Persona
WHERE p.Id=1");

                    Stopwatch watch = new Stopwatch();
                    watch.Reset();
                    watch.Start();

                    for (int i = 0; i < j; i++)
                    {
                        T                p;
                        MapperStore      store  = new MapperStore();
                        DapperMapper <T> mapper = (DapperMapper <T>)store.GetMapper(t);
                        p = mapper.Map(result);
                    }

                    watch.Stop();
                    Console.WriteLine($"    +++++++++TEST {t.Name} - {x.ToString()} DONE+++++++++");
                    Console.WriteLine();
                    Console.WriteLine($"    TIME WATCH: {watch.Elapsed.ToString()}");
                    Console.WriteLine($"    TIME WATCH SECONDS: {watch.Elapsed.Seconds.ToString()}");
                    Console.WriteLine($"    TIME WATCH MILISECONDS: {watch.ElapsedMilliseconds.ToString()}");
                    Console.WriteLine();

                    wSheet.Cells[x + 3, 1].Value   = x + idAlias;
                    wSheet.Cells[x + 3, 2].Value   = t.Name;
                    wSheet.Cells[x + 3, 3].Value   = j;
                    wSheet.Cells[x + 3, 4].Value   = watch.Elapsed.Seconds;
                    wSheet.Cells[x + 3, 5].Value   = watch.ElapsedMilliseconds;
                    wSheet.Cells[x + 3, 6].Formula = "D3/C3";

                    //result = con.Query("INSERT INTO MapperResults VALUES (@Id, @TYPE, @N, @SECONDS, @MILISECONDS)",
                    //    new { Id = x + idAlias, TYPE = t.Name, N = j, SECONDS = watch.Elapsed.Seconds, MILISECONDS = watch.ElapsedMilliseconds });
                    con.Close();

                    /*
                     * [TYPE] VARCHAR(MAX) NOT NULL,
                     * [N] BIGINT NOT NULL,
                     * [SECONDS] BIGINT NOT NULL,
                     * [MILISECONDS] BIGINT NOT NULL
                     */
                }
                Console.WriteLine("------------------");
                Console.WriteLine("DB OK");
                Console.WriteLine();
                //Console.WriteLine("    RESULTS:");
                //Console.ReadLine();
                //Console.WriteLine(SQLResults.FlattenStringsList());
            }

            package.Save();
            Console.WriteLine("    +++++++++ALL TESTS DONE+++++++++");
            Console.WriteLine();
            Console.ReadLine();
        }