/// <summary>
/// Obtiene una coleccion de gastos por inventario
/// </summary>
/// <param name="organizacionID"></param>
/// <param name="fechaInicial"></param>
/// <param name="fechaFinal"></param>
/// <returns></returns>
internal IEnumerable <GastoInventarioInfo> ObtenerGastosInventarioPorFechaConciliacion(int organizacionID, DateTime fechaInicial, DateTime fechaFinal)
{
try
{
Logger.Info();
IMapBuilderContext <GastoInventarioInfo> mapeo = MapGastoInventarioDAL.ObtenerGastosInventarioConciliacion();
IEnumerable <GastoInventarioInfo> foliosFaltantes = GetDatabase().ExecuteSprocAccessor
<GastoInventarioInfo>(
"GastoInventario_ObtenerPorFechaConciliacion", mapeo.Build(),
new object[] { organizacionID, fechaInicial, fechaFinal });
return(foliosFaltantes);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private void MapEnum(IMapBuilderContext <T> aux, Type type, PropertyInfo property)
{
aux.Map(property).WithFunc(
rec => rec.IsDBNull(rec.GetOrdinal(property.Name)) ? null : Enum.ToObject(type, rec.GetInt32(rec.GetOrdinal(property.Name)))
)
;
}
public void Fails_On_MisMatch_Column_Auto_Map()
{
string connectionString = TestHelpers.ConnectionString;
string tableName = BulkWriter.AutoDiscover.TableName <MyTestClass>(false);
TestHelpers.ExecuteNonQuery(connectionString,
"CREATE TABLE [dbo].[" + tableName + "](" +
"[Id] [int] IDENTITY(1,1) NOT NULL," +
"[MisMatchedColumn] [nvarchar](50) NULL," +
"CONSTRAINT [PK_" + tableName + "] PRIMARY KEY CLUSTERED ([Id] ASC)" +
")");
IMapBuilderContext <MyTestClass> mapping = MapBuilder.MapAllProperties <MyTestClass>();
IEnumerable <BulkWriter.PropertyMapping> propertyMappings = ((BulkWriter.MapBuilderContext <MyTestClass>)mapping).GetPropertyMappings();
try
{
Assert.Throws <InvalidOperationException>(() => AutoDiscover.Mappings(connectionString, tableName, propertyMappings));
}
finally
{
TestHelpers.ExecuteNonQuery(connectionString, "DROP TABLE " + tableName);
}
}
public void Can_Find_All_Columns_Auto_Map()
{
string connectionString = TestHelpers.ConnectionString;
string tableName = BulkWriter.AutoDiscover.TableName <MyTestClass>(false);
TestHelpers.ExecuteNonQuery(connectionString,
"CREATE TABLE [dbo].[" + tableName + "](" +
"[Id] [int] IDENTITY(1,1) NOT NULL," +
"[Name] [nvarchar](50) NULL," +
"CONSTRAINT [PK_" + tableName + "] PRIMARY KEY CLUSTERED ([Id] ASC)" +
")");
IMapBuilderContext <MyTestClass> mapping = MapBuilder.MapAllProperties <MyTestClass>();
IEnumerable <BulkWriter.PropertyMapping> propertyMappings = ((BulkWriter.MapBuilderContext <MyTestClass>)mapping).GetPropertyMappings();
BulkWriter.AutoDiscover.Mappings(connectionString, tableName, propertyMappings);
TestHelpers.ExecuteNonQuery(connectionString, "DROP TABLE " + tableName);
foreach (BulkWriter.PropertyMapping propertyMapping in propertyMappings)
{
Assert.True(propertyMapping.ShouldMap);
if (propertyMapping.ShouldMap)
{
for (int i = 0; i < BulkWriter.MappingDestination.PropertyIndexCount; i++)
{
Assert.True(propertyMapping.Destination.IsPropertySet((BulkWriter.MappingProperty)i));
}
}
}
}
/// <summary>
/// Obtiene los movimientos de los subproductos de premezcla
/// </summary>
/// <param name="productosPremezcla"></param>
/// <returns></returns>
internal IEnumerable <AlmacenMovimientoSubProductosModel> ObtenerMovimientosSubProductos(IEnumerable <AlmacenMovimientoSubProductosModel> productosPremezcla)
{
try
{
Logger.Info();
IMapBuilderContext <AlmacenMovimientoSubProductosModel> mapeo =
MapAlmacenMovimientoDAL.ObtenerMapeoAlmacenMovimientoSubProductos();
string parameters = AuxAlmacenMovimientoDAL.ObtenerParametrosMovimientosSubProductos(productosPremezcla);
IEnumerable <AlmacenMovimientoSubProductosModel> movimientosSubProductos = GetDatabase().ExecuteSprocAccessor
<AlmacenMovimientoSubProductosModel>(
"AlmacenMoviento_ObtenerSubProductos", mapeo.Build(),
new object[] { parameters });
return(movimientosSubProductos);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private static IMapBuilderContext <GastoInventarioInfo> MapeoBasico()
{
try
{
Logger.Info();
IMapBuilderContext <GastoInventarioInfo> mapGastosInventario =
MapBuilder <GastoInventarioInfo> .MapNoProperties();
mapGastosInventario.Map(x => x.GastoInventarioID).ToColumn("GastoInventarioID");
mapGastosInventario.Map(x => x.TipoGasto).WithFunc(x => Convert.ToString(x["TipoGasto"]).TipoGastoAEnum());
mapGastosInventario.Map(x => x.FolioGasto).ToColumn("FolioGasto");
mapGastosInventario.Map(x => x.FechaGasto).ToColumn("FechaGasto");
mapGastosInventario.Map(x => x.TieneCuenta).ToColumn("TieneCuenta");
mapGastosInventario.Map(x => x.Factura).ToColumn("Factura");
mapGastosInventario.Map(x => x.Importe).ToColumn("Importe");
mapGastosInventario.Map(x => x.IVA).ToColumn("IVA");
mapGastosInventario.Map(x => x.Observaciones).ToColumn("Observaciones");
mapGastosInventario.Map(x => x.Retencion).ToColumn("Retencion");
mapGastosInventario.Map(x => x.CentroCosto).ToColumn("CentroCosto");
mapGastosInventario.Map(x => x.CuentaGasto).ToColumn("CuentaGasto");
mapGastosInventario.Map(x => x.TotalCorrales).ToColumn("TotalCorrales");
return(mapGastosInventario);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void Fails_On_MisMatch_Column_Auto_Map()
{
const string connectionString = "Data Source=(local);Initial Catalog=BulkWriterTest;Integrated Security=SSPI";
string tableName = AutoDiscover.TableName <MyTestClass>(false);
TestHelpers.ExecuteNonQuery(connectionString,
"CREATE TABLE [dbo].[" + tableName + "](" +
"[Id] [int] IDENTITY(1,1) NOT NULL," +
"[MisMatchedColumn] [nvarchar](50) NULL," +
"CONSTRAINT [PK_" + tableName + "] PRIMARY KEY CLUSTERED ([Id] ASC)" +
")");
IMapBuilderContext <MyTestClass> mapping = MapBuilder.MapAllProperties <MyTestClass>();
IEnumerable <PropertyMapping> propertyMappings = ((MapBuilderContext <MyTestClass>)mapping).GetPropertyMappings();
try
{
AutoDiscover.Mappings(connectionString, tableName, propertyMappings);
}
finally
{
TestHelpers.ExecuteNonQuery(connectionString, "DROP TABLE " + tableName);
}
}
/// <summary>
/// Obtiene los movimientos para su conciliacion
/// </summary>
/// <param name="organizacionID"></param>
/// <param name="fechaInicio"></param>
/// <param name="fechaFin"></param>
/// <param name="claseDocumento"> </param>
/// <returns></returns>
internal IEnumerable <PolizaInfo> ObtenerPolizasConciliacion(int organizacionID, DateTime fechaInicio, DateTime fechaFin
, string claseDocumento)
{
try
{
Logger.Info();
IMapBuilderContext <PolizaInfo> mapeo = MapPolizaDAL.ObtenerPolizasConciliacion();
IEnumerable <PolizaInfo> foliosFaltantes = GetDatabase().ExecuteSprocAccessor(
"Poliza_ObtenerConciliacionPorFechas", mapeo.Build(),
new object[] { organizacionID, fechaInicio, fechaFin, claseDocumento });
return(foliosFaltantes);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void Maps_Only_Appropriate_Properties()
{
const string connectionString = "Data Source=(local);Initial Catalog=BulkWriterTest;Integrated Security=SSPI";
string tableName = AutoDiscover.TableName <MyTestClass>(false);
TestHelpers.ExecuteNonQuery(connectionString,
"CREATE TABLE [dbo].[" + tableName + "](" +
"[Id] [int] IDENTITY(1,1) NOT NULL," +
"[Name] [nvarchar](50) NULL," +
"CONSTRAINT [PK_" + tableName + "] PRIMARY KEY CLUSTERED ([Id] ASC)" +
")");
IMapBuilderContext <MyTestClass> mapping = MapBuilder
.MapAllProperties <MyTestClass>()
.MapProperty(x => x.Id, x => x.DoNotMap()); // Do not map this property
IEnumerable <PropertyMapping> propertyMappings = ((MapBuilderContext <MyTestClass>)mapping).GetPropertyMappings();
AutoDiscover.Mappings(connectionString, tableName, propertyMappings);
TestHelpers.ExecuteNonQuery(connectionString, "DROP TABLE " + tableName);
foreach (PropertyMapping propertyMapping in propertyMappings)
{
if (propertyMapping.ShouldMap)
{
for (int i = 0; i < MappingDestination.PropertyIndexCount; i++)
{
Assert.IsTrue(propertyMapping.Destination.IsPropertySet((MappingProperty)i));
}
}
}
}
/// <summary>
/// Obtiene una lista de gastos de materia prima
/// por sus movimientos de almacen
/// </summary>
/// <param name="almacenesMovimiento"></param>
/// <returns></returns>
internal IEnumerable <GastoMateriaPrimaInfo> ObtenerGastosMateriaPrimaPorAlmacenMovimientoXML(List <AlmacenMovimientoInfo> almacenesMovimiento)
{
try
{
Logger.Info();
Dictionary <string, object> parameters =
AuxGastoMateriaPrimaDAL.ObtenerParametrosPorAlmacenMovimientoXML(almacenesMovimiento);
IMapBuilderContext <GastoMateriaPrimaInfo> mapeo = MapGastoMateriaPrimaDAL.ObtenerPolizasConciliacion();
IEnumerable <GastoMateriaPrimaInfo> foliosFaltantes = GetDatabase().ExecuteSprocAccessor
<GastoMateriaPrimaInfo>(
"GastoMateriaPrima_ObtenerConciliacionMovimientosSIAP", mapeo.Build(),
new[] { parameters["@XmlAlmacenMovimiento"] });
return(foliosFaltantes);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un enumerable de almacen movimiento costo
/// </summary>
/// <param name="movimientosAlmacen"></param>
/// <returns></returns>
internal IEnumerable <AlmacenMovimientoCostoInfo> ObtenerAlmacenMovimientoCostoPorAlmacenMovimientoXML(IEnumerable <AlmacenMovimientoInfo> movimientosAlmacen)
{
try
{
Logger.Info();
IMapBuilderContext <AlmacenMovimientoCostoInfo> mapeo =
MapAlmacenMovimientoCostoDAL.ObtenerMapeoAlmacenMovimientoCosto();
string parametro =
AuxAlmacenMovimientoCostoDAL.ObtenerParametrosObtenerAlmacenMovimientoXML(movimientosAlmacen);
IEnumerable <AlmacenMovimientoCostoInfo> corrales = GetDatabase().ExecuteSprocAccessor
<AlmacenMovimientoCostoInfo>(
"AlmacenMovimientoCosto_ObtenerPorAlmacenMovimientoXML", mapeo.Build(),
new object[] { parametro });
return(corrales);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private static IMapBuilderContext <PolizaSacrificioModel> MapeoBasico()
{
try
{
Logger.Info();
IMapBuilderContext <PolizaSacrificioModel> mapLotesSacrificio =
MapBuilder <PolizaSacrificioModel> .MapNoProperties();
mapLotesSacrificio.Map(x => x.Canales).ToColumn("Canales");
mapLotesSacrificio.Map(x => x.Fecha).ToColumn("Fecha");
mapLotesSacrificio.Map(x => x.Folio).ToColumn("Folio");
mapLotesSacrificio.Map(x => x.ImporteCanal).ToColumn("ImporteCanal");
mapLotesSacrificio.Map(x => x.ImportePiel).ToColumn("ImportePiel");
mapLotesSacrificio.Map(x => x.ImporteViscera).ToColumn("ImporteViscera");
mapLotesSacrificio.Map(x => x.Lote).ToColumn("Lote");
mapLotesSacrificio.Map(x => x.LoteID).ToColumn("LoteID");
mapLotesSacrificio.Map(x => x.OrganizacionID).ToColumn("OrganizacionID");
mapLotesSacrificio.Map(x => x.Serie).ToColumn("Serie");
mapLotesSacrificio.Map(x => x.Peso).ToColumn("Peso");
return(mapLotesSacrificio);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private static IMapBuilderContext <GastoMateriaPrimaInfo> MapeoBasico()
{
try
{
Logger.Info();
IMapBuilderContext <GastoMateriaPrimaInfo> mapGastoMateriaPrima =
MapBuilder <GastoMateriaPrimaInfo> .MapNoProperties();
mapGastoMateriaPrima.Map(x => x.GastoMateriaPrimaID).ToColumn("GastoMateriaPrimaID");
mapGastoMateriaPrima.Map(x => x.FolioGasto).ToColumn("FolioGasto");
mapGastoMateriaPrima.Map(x => x.Fecha).ToColumn("Fecha");
mapGastoMateriaPrima.Map(x => x.TieneCuenta).ToColumn("TieneCuenta");
mapGastoMateriaPrima.Map(x => x.Importe).ToColumn("Importe");
mapGastoMateriaPrima.Map(x => x.Iva).ToColumn("IVA");
mapGastoMateriaPrima.Map(x => x.Observaciones).ToColumn("Observaciones");
mapGastoMateriaPrima.Map(x => x.AlmacenMovimientoID).ToColumn("AlmacenMovimientoID");
mapGastoMateriaPrima.Map(x => x.AlmacenID).ToColumn("AlmacenID");
return(mapGastoMateriaPrima);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los movimientos de muerte
/// </summary>
/// <param name="fechaMuerte"></param>
/// <returns></returns>
internal IEnumerable <AnimalMovimientoInfo> ObtenerMovimientosMuertes(DateTime fechaMuerte)
{
try
{
Logger.Info();
IMapBuilderContext <AnimalMovimientoInfo> mapeoAnimal =
MapAnimalMovimientosHistoricoDAL.ObtenerMapeoAnimalHistorico();
IEnumerable <AnimalMovimientoInfo> movimientosMuerte = GetDatabase().ExecuteSprocAccessor
<AnimalMovimientoInfo>(
"AnimalMovimientoHistorico_ObtenerMuertesPorFecha", mapeoAnimal.Build(),
new object[] { fechaMuerte });
return(movimientosMuerte);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que obtiene el listado de pólizas de la organización en el rango de fechas indicado.
/// </summary>
/// <param name="conciliacionParametros"></param>
internal List <PolizaInfo> ObtenerPolizasConciliacionSapSiap(ConciliaciionParametros conciliacionParametros)
{
try
{
Logger.Info();
IMapBuilderContext <PolizaInfo> mapeo = MapPolizaDAL.ObtenerPolizasConciliacionSapSiap();
var xmlDivisiones = AuxPolizaDAL.ObtenerParametrosObtenerPolizasConciliacionSapSiap(conciliacionParametros.diviciones);
var foliosFaltantes = GetDatabase().ExecuteSprocAccessor(
"Poliza_ObtenerConciliacionSapSiapPorFechas", mapeo.Build(),
new object[] { conciliacionParametros.Organizacion.OrganizacionID, conciliacionParametros.fechaInicio, conciliacionParametros.fechaFin, xmlDivisiones, conciliacionParametros.Prefijo }).ToList();
return(foliosFaltantes);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un mapeo basico de la clase Almacen Movimiento Costo
/// </summary>
/// <returns></returns>
private static IMapBuilderContext <ContratoInfo> MapeoBasico()
{
try
{
Logger.Info();
IMapBuilderContext <ContratoInfo> mapContrato = MapBuilder <ContratoInfo> .MapNoProperties();
mapContrato.Map(x => x.ContratoId).ToColumn("ContratoID");
mapContrato.Map(x => x.Folio).ToColumn("Folio");
mapContrato.Map(x => x.Precio).ToColumn("Precio");
mapContrato.Map(x => x.Cantidad).ToColumn("Cantidad");
mapContrato.Map(x => x.Merma).ToColumn("Merma");
mapContrato.Map(x => x.PesoNegociar).ToColumn("PesoNegociar");
mapContrato.Map(x => x.Fecha).ToColumn("Fecha");
mapContrato.Map(x => x.FechaVigencia).ToColumn("FechaVigencia");
mapContrato.Map(x => x.Tolerancia).ToColumn("Tolerancia");
mapContrato.Map(x => x.Parcial).WithFunc(x => Convert.ToBoolean(x["Parcial"]).BoolCompraParcialAEnum());
return(mapContrato);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Ejecuta procedimiento almacenado con sus parametros
/// </summary>
/// <param name="procedimientoAlmacenado"></param>
/// <param name="parametros"></param>
/// <returns></returns>
private IEnumerable <CondicionJaulaInfo> ObtenerCondicionesJaula(string procedimientoAlmacenado, object[] parametros)
{
try
{
Logger.Info();
IMapBuilderContext <CondicionJaulaInfo> mapeo = MapCondicionJaulaDAL.ObtenerMapeoCondicionJaula();
IEnumerable <CondicionJaulaInfo> condicionesJaula = GetDatabase().ExecuteSprocAccessor
<CondicionJaulaInfo>(procedimientoAlmacenado, mapeo.Build(), parametros);
return(condicionesJaula);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una lista de CondicionJaula
/// </summary>
/// <returns></returns>
internal IEnumerable <CondicionJaulaInfo> ObtenerTodos()
{
try
{
Logger.Info();
IMapBuilderContext <CondicionJaulaInfo> mapeo = MapCondicionJaulaDAL.ObtenerMapeoCondicionJaula();
IEnumerable <CondicionJaulaInfo> condicionesJaula = GetDatabase().ExecuteSprocAccessor
<CondicionJaulaInfo>(
"CondicionJaula_ObtenerTodos", mapeo.Build());
return(condicionesJaula);
}
catch (SqlException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (DataException ex)
{
Logger.Error(ex);
throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private static IMapBuilderContext <PolizaSacrificioModel> MapeoServicio()
{
try
{
Logger.Info();
IMapBuilderContext <PolizaSacrificioModel> mapLotesSacrificio =
MapBuilder <PolizaSacrificioModel> .MapNoProperties();
mapLotesSacrificio.Map(x => x.Canales).ToColumn("Canales");
mapLotesSacrificio.Map(x => x.Fecha).ToColumn("Fecha");
mapLotesSacrificio.Map(x => x.ImporteCanal).ToColumn("ImporteCanal");
mapLotesSacrificio.Map(x => x.ImportePiel).ToColumn("ImportePiel");
mapLotesSacrificio.Map(x => x.ImporteViscera).ToColumn("ImporteViscera");
mapLotesSacrificio.Map(x => x.Lote).ToColumn("Lote");
mapLotesSacrificio.Map(x => x.LoteID).ToColumn("LoteID");
mapLotesSacrificio.Map(x => x.OrganizacionID).ToColumn("OrganizacionID");
mapLotesSacrificio.Map(x => x.Peso).ToColumn("Peso");
mapLotesSacrificio.Map(x => x.PesoPiel).ToColumn("PesoPiel");
mapLotesSacrificio.Map(x => x.Corral).ToColumn("Corral");
mapLotesSacrificio.Map(x => x.InterfaceSalidaTraspasoDetalleID).ToColumn(
"InterfaceSalidaTraspasoDetalleID");
mapLotesSacrificio.Map(x => x.Serie).WithFunc(fn =>
{
if (Convert.ToBoolean(fn["PolizaGenerada"]) &&
Convert.ToString(fn["SerieFolio"]).Length > 0)
{
return
(Convert.ToString(fn["SerieFolio"]).Split(
'-')[0]);
}
else
{
return(Convert.ToString(fn["Serie"]));
}
});
mapLotesSacrificio.Map(x => x.Folio).WithFunc(fn =>
{
if (Convert.ToBoolean(fn["PolizaGenerada"]) &&
Convert.ToString(fn["SerieFolio"]).Length > 0 &&
Convert.ToString(fn["SerieFolio"]).IndexOf('-') >= 0)
{
return
(Convert.ToString(fn["SerieFolio"]).Split(
'-')[1]);
}
else
{
return(Convert.ToString(fn["Folio"]));
}
});
return(mapLotesSacrificio);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void ThenDoNotMapRemovesPropertyMapping()
{
IMapBuilderContext <Customer> context = MapBuilder <Customer> .MapAllProperties()
.DoNotMap(x => x.CustomerName);
var mappings =
((IMapBuilderContextTest <Customer>)context).GetPropertyMappings().Where(pm => pm.Property == CustomerNameProperty);
Assert.AreEqual(0, mappings.Count());
}
public void ThenMapByNameMatchCreatesPropertyMappingWithAppropriateColumnName()
{
IMapBuilderContext <Customer> context = builder.MapByName(x => x.CustomerName);
var mappings = ((IMapBuilderContextTest <Customer>)builder).GetPropertyMappings().OfType <ColumnNameMapping>();
Assert.AreNotEqual(0, mappings.Count());
Assert.AreSame(CustomerNameProperty, mappings.First().Property);
Assert.AreEqual("CustomerName", mappings.First().ColumnName);
}
public static IMapBuilderContext <TResult> MapAllProperties()
{
IMapBuilderContext <TResult> mapBuilderContext = (IMapBuilderContext <TResult>) new MapBuilder <TResult> .MapBuilderContext();
foreach (PropertyInfo property in ((IEnumerable <PropertyInfo>) typeof(TResult).GetProperties(BindingFlags.Instance | BindingFlags.Public)).Where <PropertyInfo>((Func <PropertyInfo, bool>)(property => MapBuilder <TResult> .IsAutoMappableProperty(property))))
{
mapBuilderContext = mapBuilderContext.MapByName(property);
}
return(mapBuilderContext);
}
/// <summary>
/// Tạo mapper
/// </summary>
/// <typeparam name="T">Kiểu đối tượng</typeparam>
/// <param name="reader">Đối tượng IDataReader</param>
/// <param name="sqlName">Tên đầy đủ của câu sql. VD: Sql.BT0000.GetAll</param>
/// <returns></returns>
private static IRowMapper <T> GetRowMapper <T>(IDataReader reader, string sqlName = "") where T : new()
{
IRowMapper <T> result = null;
Type type = typeof(T);
bool cache = !string.IsNullOrEmpty(sqlName);
int hashCode = (type.FullName + sqlName).GetHashCode();
// Kiểm tra mapper đã được cache hay chưa
if (cache && RowMappers.ContainsKey(hashCode))
{
result = (IRowMapper <T>)RowMappers[hashCode];
}
// Nếu không được cache thì tạo mới
else
{
IMapBuilderContext <T> context = MapBuilder <T> .MapNoProperties();
PropertyInfo property = null;
string propertyName = string.Empty;
for (int i = reader.FieldCount - 1; i >= 0; i--)
{
propertyName = reader.GetName(i);
property = type.GetProperty(propertyName);
// Trường hợp không lấy đc property thì lấy theo column name
if (property == null)
{
// Lấy dữ liệu property theo column của Object
property = type.GetProperties().FirstOrDefault(prop =>
prop.GetCustomAttributes(false)
.OfType <ColumnAttribute>()
.Any(attribute => attribute.Name == propertyName));
}
// Chỉ map những field vừa có trong câu sql vừa có trong đối tượng
if (property != null && property.CanRead && property.CanWrite)
{
context.MapByName(property);
}
}
result = context.Build();
// Nếu có yêu cầu cache thì lưu vào cache
if (reader.FieldCount > 0 && cache)
{
RowMappers.Add(hashCode, result);
}
}
return(result);
}
public void ThenMapToColumnCreatesPropertyMappingWithColumnName()
{
IMapBuilderContext <Customer> context = MapBuilder <Customer> .MapNoProperties()
.Map(x => x.CustomerName).ToColumn("columnname");
var mappings = ((IMapBuilderContextTest <Customer>)context).GetPropertyMappings().OfType <ColumnNameMapping>();
Assert.AreNotEqual(0, mappings.Count());
var mapping = mappings.First();
Assert.AreSame(CustomerNameProperty, mapping.Property);
Assert.AreEqual("columnname", mapping.ColumnName);
}
/// <summary>
/// Obtiene una mapeo de lotes sacrificio
/// </summary>
/// <returns></returns>
internal static IMapBuilderContext <PolizaSacrificioModel> ObtenerMapeoPolizasSacrificioServicio()
{
try
{
Logger.Info();
IMapBuilderContext <PolizaSacrificioModel> mapPolizaSacrificioConciliacion = MapeoServicio();
return(mapPolizaSacrificioConciliacion);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene una mapeo de animal movimiento
/// </summary>
/// <returns></returns>
internal static IMapBuilderContext <AnimalMovimientoInfo> ObtenerAnimalMovimientoMuertos()
{
try
{
Logger.Info();
IMapBuilderContext <AnimalMovimientoInfo> mapAnimalMovimiento = MapeoBasico();
return(mapAnimalMovimiento);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public void ThenMapWithFuncCreatesPropertyMappingWithFunc()
{
IMapBuilderContext <Customer> context = MapBuilder <Customer> .MapNoProperties()
.Map(x => x.CustomerName).WithFunc(x => "value");
var mappings = ((IMapBuilderContextTest <Customer>)context).GetPropertyMappings().OfType <FuncMapping>();
Assert.AreNotEqual(0, mappings.Count());
var propertyMapping = mappings.First();
Assert.AreSame(CustomerNameProperty, propertyMapping.Property);
Assert.IsNotNull(propertyMapping.Func);
}
public void ThenSubsequentMappingOnSamePropertyReplacesOldMapping()
{
IMapBuilderContext <Customer> context = MapBuilder <Customer> .MapNoProperties()
.DoNotMap(x => x.CustomerName)
.MapByName(x => x.CustomerName);
var mappings = ((IMapBuilderContextTest <Customer>)context).GetPropertyMappings().OfType <ColumnNameMapping>();
Assert.AreNotEqual(0, mappings.Count());
var mapping = mappings.First();
Assert.AreSame(CustomerNameProperty, mapping.Property);
Assert.AreEqual("CustomerName", mapping.ColumnName);
}
private static void MapeoOrganizacion(IMapBuilderContext <GastoMateriaPrimaInfo> mapGastoMateriaPrima)
{
try
{
Logger.Info();
mapGastoMateriaPrima.Map(x => x.Organizacion).WithFunc(x => new OrganizacionInfo
{
OrganizacionID = Convert.ToInt32(x["OrganizacionID"]),
});
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
private static void MapeoAlmacenInventarioLote(IMapBuilderContext <GastoMateriaPrimaInfo> mapGastoMateriaPrima)
{
try
{
Logger.Info();
mapGastoMateriaPrima.Map(x => x.AlmacenInventarioLote).WithFunc(x => new AlmacenInventarioLoteInfo
{
AlmacenInventarioLoteId = Convert.ToInt32(x["AlmacenInventarioLoteID"])
});
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
