public aRepositoryInternalWithTwoDLOs()
{
MapperStore store = new MapperStore();
this._DLOMapper1 = (DapperMapper <DLO>)store.GetMapper(typeof(DLO));
this._DLOMapper2 = (DapperMapper <DLO2>)store.GetMapper(typeof(DLO2));
}
public AsientoRepository()
{
MapperStore store = new MapperStore();
this._Mapper = (DapperMapper <Asiento>)store.GetMapper(GetObjModelType());
this.Transactions = new ConcurrentDictionary <aVMTabBase, List <Tuple <QueryBuilder, IConditionToCommit> > >();
}
public PersonaRepository()
{
MapperStore store = new MapperStore();
this._Mapper = (DapperMapper <Persona>)store.GetMapper(typeof(Persona));
this.Transactions = new ConcurrentDictionary <aVMTabBase, List <Tuple <QueryBuilder, IConditionToCommit> > >();
}
public aRepositoryInternalWithDLO()
{
MapperStore store = new MapperStore();
this._DLOMapper = (DapperMapper <DLO>)store.GetMapper(typeof(DLO));
}
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();
}