/// <summary>
/// Metodo para obtener el producto por pedido
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static ProductoInfo ObtenerPorPedidoID(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
ProductoInfo entidad =
(from info in dt.AsEnumerable()
select
new ProductoInfo
{
ProductoId = info.Field <int>("ProductoID"),
ProductoDescripcion = info.Field <string>("Producto"),
Descripcion = info.Field <string>("Producto"),
SubFamilia = new SubFamiliaInfo
{
Descripcion = info.Field <string>("SubFamilia"),
},
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene los datos de muestreo de tipo producto
/// </summary>
/// <param name="ingredienteInfo"></param>
/// <returns></returns>
private MuestreoFibraProductoInfo ObtenerMuestreoProducto(ProductoInfo productoInfo)
{
MuestreoFibraProductoInfo muestraProductoInfo = new MuestreoFibraProductoInfo()
{
Organizacion = new OrganizacionInfo()
{
OrganizacionID = organizacionID
},
Producto = productoInfo,
PesoMuestra = (decimal)txtProductoPesoMuestra.Value,
Grueso = chkProductoGruesos.IsChecked.Value,
PesoGranoGrueso = (decimal)txtProductoPesoGranoGrueso.Value,
Mediano = chkProductoMedianos.IsChecked.Value,
PesoGranoMediano = (decimal)txtProductoPesoGranoMediano.Value,
Fino = chkProductoFinos.IsChecked.Value,
PesoGranoFino = (decimal)txtProductoPesoGranoFino.Value,
CribaEntrada = (int)txtProductoPesoCribaEntrada.Value,
CribaSalida = (int)txtProductoPesoCribaSalida.Value,
Observaciones = txtProductoObservaciones.Text,
Activo = true,
UsuarioCreacion = new UsuarioInfo()
{
UsuarioID = usuarioID
}
};
muestraProductoInfo.PesoNeto = 0;
muestraProductoInfo.PesoNeto += muestraProductoInfo.PesoGranoFino;
muestraProductoInfo.PesoNeto += muestraProductoInfo.PesoGranoGrueso;
muestraProductoInfo.PesoNeto += muestraProductoInfo.PesoGranoMediano;
return(muestraProductoInfo);
}
private void GenerarLineasDetalle(List <PolizaEntradaSalidaPorAjusteModel> ajustesDeInventario)
{
IList <ProductoInfo> productos = ObtenerProductos();
IList <UnidadMedicionInfo> unidades = ObtenerUnidadesMedicion();
PolizaModel.Detalle = new List <PolizaDetalleModel>();
PolizaDetalleModel polizaModel;
for (int indexInventario = 0; indexInventario < ajustesDeInventario.Count; indexInventario++)
{
ProductoInfo producto =
productos.FirstOrDefault(prod => prod.ProductoId == ajustesDeInventario[indexInventario].ProductoID);
if (producto == null)
{
producto = new ProductoInfo();
}
polizaModel = new PolizaDetalleModel
{
CantidadCabezas = producto.ProductoId.ToString(),
TipoGanado = producto.ProductoDescripcion,
Lote = ajustesDeInventario[indexInventario].Lote == 0 ? string.Empty : ajustesDeInventario[indexInventario].Lote.ToString(),
PesoOrigen = Math.Abs(ajustesDeInventario[indexInventario].Cantidad).ToString("N0"),
PesoLlegada = Math.Abs(ajustesDeInventario[indexInventario].Cantidad).ToString("N0"),
Corral = unidades.Where(clave => clave.UnidadID == producto.UnidadId).Select(uni => uni.ClaveUnidad).FirstOrDefault(),
PrecioPromedio = ajustesDeInventario[indexInventario].Precio.ToString("N2"),
ImportePromedio = Math.Abs(Math.Round(ajustesDeInventario[indexInventario].Cantidad * ajustesDeInventario[indexInventario].Precio, 2)).ToString("N2"),
};
PolizaModel.Detalle.Add(polizaModel);
}
}
/// <summary>
/// Metodo para Guardar/Modificar una entidad Producto
/// </summary>
/// <param name="info"></param>
internal int Guardar(ProductoInfo info)
{
try
{
Logger.Info();
var productoDAL = new ProductoDAL();
int result = info.ProductoId;
if (info.UsuarioModificacionID != null && info.UsuarioModificacionID != 0)
{
productoDAL.Actualizar(info);
}
else
{
result = productoDAL.Crear(info);
}
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
///
/// </summary>
/// <param name="productoInfo"></param>
/// <param name="estatus"></param>
/// <returns></returns>
internal List <IndicadorProductoInfo> ObtenerPorProductoId(ProductoInfo productoInfo, EstatusEnum estatus)
{
try
{
Logger.Info();
var indicadorProductoDAL = new IndicadorProductoDAL();
List <IndicadorProductoInfo> result = indicadorProductoDAL.ObtenerPorProductoId(productoInfo, estatus);
if (result != null)
{
foreach (var indicadorProductoInfo in result)
{
if (indicadorProductoInfo.IndicadorInfo.IndicadorId > 0)
{
var indicadorBl = new IndicadorBL();
indicadorProductoInfo.IndicadorInfo = indicadorBl.ObtenerPorId(indicadorProductoInfo.IndicadorInfo);
}
indicadorProductoInfo.IsEditable = true;
}
}
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Metodo que obtiene un listado de indicadoresproducto por producto id
/// </summary>
/// <returns></returns>
internal List <IndicadorProductoInfo> ObtenerPorProductoId(ProductoInfo productoInfo, EstatusEnum estatus)
{
try
{
Logger.Info();
var parameters = AuxIndicadorProductoDAL.ObtenerParametrosObtenerPorProductoId(productoInfo, estatus);
var ds = Retrieve("IndicadorProducto_ObtenerPorProductoId", parameters);
List <IndicadorProductoInfo> result = null;
if (ValidateDataSet(ds))
{
result = MapIndicadorProductoDAL.ObtenerPorProductoId(ds);
}
return(result);
}
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>
/// Metodo para Guardar/Modificar una entidad Producto
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public int Guardar(ProductoInfo info)
{
try
{
Logger.Info();
var id = 0;
if (info.ProductoId > 0)
{
info.FechaModificacion = da.FechaServidor();
id = da.Actualizar <ProductoInfo>(info);
}
else
{
id = da.Insertar <ProductoInfo>(info);
}
return(id);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Obtiene un listado de productos por almacen y obtiene los datos del producto
/// </summary>
/// <param name="almacenInfo"></param>
/// <returns></returns>
internal List <AlmacenInventarioInfo> ObtienePorAlmacenIdLlenaProductoInfo(AlmacenInfo almacenInfo)
{
List <AlmacenInventarioInfo> almacen = null;
try
{
var productoBl = new ProductoBL();
var almacenDal = new AlmacenInventarioDAL();
almacen = almacenDal.ObtenerPorAlmacenId(almacenInfo);
if (almacen != null)
{
foreach (var almacenInventarioInfo in almacen)
{
var productoInfo = new ProductoInfo()
{
ProductoId = almacenInventarioInfo.ProductoID
};
almacenInventarioInfo.Producto = productoBl.ObtenerPorID(productoInfo);
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(almacen);
}
/// <summary>
/// Resttaura los datos de muestreo de tipo producto
/// </summary>
/// <param name="muestreoIngredienteInfo"></param>
private void RestaurarMuestreoProducto(MuestreoFibraProductoInfo muestreoProductoInfo)
{
LimpiarProductoDatosMuestreos();
productoInfoSeleccionado = new ProductoInfo()
{
ProductoId = muestreoProductoInfo.Producto.ProductoId,
Descripcion = muestreoProductoInfo.Producto.Descripcion
};
skAyudaProducto.Info = productoInfoSeleccionado;
skAyudaProducto.Clave = muestreoProductoInfo.Producto.ProductoId.ToString();
skAyudaProducto.Descripcion = muestreoProductoInfo.Producto.Descripcion;
chkProductoFinos.IsChecked = muestreoProductoInfo.Fino;
txtProductoPesoGranoFino.IsEnabled = muestreoProductoInfo.Fino;
chkProductoMedianos.IsChecked = muestreoProductoInfo.Mediano;
txtProductoPesoGranoMediano.IsEnabled = muestreoProductoInfo.Mediano;
chkProductoGruesos.IsChecked = muestreoProductoInfo.Grueso;
txtProductoPesoGranoGrueso.IsEnabled = muestreoProductoInfo.Grueso;
txtProductoPesoMuestra.Value = muestreoProductoInfo.PesoMuestra;
txtProductoPesoGranoFino.Value = muestreoProductoInfo.PesoGranoFino;
txtProductoPesoGranoMediano.Value = muestreoProductoInfo.PesoGranoMediano;
txtProductoPesoGranoGrueso.Value = muestreoProductoInfo.PesoGranoGrueso;
txtProductoPesoCribaEntrada.Value = muestreoProductoInfo.CribaEntrada;
txtProductoPesoCribaSalida.Value = muestreoProductoInfo.CribaSalida;
txtProductoObservaciones.Text = muestreoProductoInfo.Observaciones;
}
public ProductoInfo ObtenerIngredientesPorIDFamilias(ProductoInfo filtro)
{
try
{
Logger.Info();
var productoBl = new ProductoBL();
if (filtro.Familias == null)
{
filtro.Familias = new List <FamiliaInfo>
{
new FamiliaInfo {
FamiliaID = FamiliasEnum.MateriaPrimas.GetHashCode()
},
new FamiliaInfo {
FamiliaID = FamiliasEnum.Premezclas.GetHashCode()
},
new FamiliaInfo {
FamiliaID = FamiliasEnum.Alimento.GetHashCode()
},
};
}
ProductoInfo result = productoBl.ObtenerPorProductoIDFamilias(filtro);
return(result);
}
catch (ExcepcionGenerica)
{
throw;
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
protected override void SelectProductoAction()
{
PartidaList lista;
lista = PartidaList.GetListBySerie(_serie.Oid, false, true);
PartidaSelectForm form = new PartidaSelectForm(this, _serie, lista);
form.ShowDialog(this);
if (form.DialogResult == DialogResult.OK)
{
_partida = form.Selected as PartidaInfo;
_producto = ProductoInfo.Get(_partida.OidProducto, false);
_pci = _cliente.Productos.GetItemByProperty("OidProducto", _producto.Oid);
Datos_Partida.DataSource = _partida;
EnableKilos();
if (_entity.FacturacionBulto)
{
Bultos_NTB.Focus();
}
else
{
Kilos_NTB.Focus();
}
}
}
/// <summary>
/// Metodo para valdiar si el producto existe como codigo parte
/// </summary>
/// <param name="producto"></param>
/// <returns></returns>
public ProductoCodigoParteInfo ObtenerCodigoParteDeProducto(ProductoInfo producto)
{
ProductoCodigoParteInfo result = null;
try
{
Logger.Info();
var parametros = new Dictionary <string, object> {
{ "@ProductoID", producto.ProductoId }
};
var ds = Retrieve("SolicitudProducto_ExisteCodigoParteDeproducto", parametros);
if (ValidateDataSet(ds))
{
result = MapSolicitudProductoDAL.ObtenerCodigoParteDeProducto(ds);
}
}
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);
}
return(result);
}
/// <summary>
/// Obtiene parametros para crear
/// </summary>
/// <param name="info">Valores de la entidad</param>
/// <returns></returns>
internal static Dictionary <string, object> ObtenerParametrosCrear(ProductoInfo info)
{
try
{
Logger.Info();
var parametros =
new Dictionary <string, object>
{
{ "@ProductoID", info.ProductoId },
{ "@Descripcion", info.ProductoDescripcion },
{ "@SubFamiliaID", info.SubfamiliaId },
{ "@UnidadID", info.UnidadId },
{ "@ManejaLote", info.ManejaLote },
{ "@MaterialSAP", info.MaterialSAP },
{ "@Activo", info.Activo },
{ "@UsuarioCreacionID", info.UsuarioCreacionID },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Cargar ayuda premezclas
/// </summary>
private void CargarAyudaPremezclas()
{
var productoInfo = new ProductoInfo
{
FamiliaId = FamiliasEnum.Premezclas.GetHashCode(),
SubfamiliaId = SubFamiliasEnum.MicroIngredientes.GetHashCode(),
SubFamilia = new SubFamiliaInfo()
{
SubFamiliaID = SubFamiliasEnum.MicroIngredientes.GetHashCode()
},
Activo = EstatusEnum.Activo
};
skAyudaPremezcla = new SKAyuda <ProductoInfo>(200, false, productoInfo
, "PropiedadClaveConfiguracionPremezclas"
, "PropiedadDescripcionConfiguracionPremezclas",
"", false, 80, 9, true)
{
AyudaPL = new ProductoPL(),
MensajeClaveInexistente = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaPremezclaInvalida,
MensajeBusquedaCerrar = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaPremezclaSalirSinSeleccionar,
MensajeBusqueda = Properties.Resources.Proveedor_Busqueda,
MensajeAgregar = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaPremezclaSeleccionar,
TituloEtiqueta = Properties.Resources.LeyendaAyudaBusquedaPremezcla,
TituloPantalla = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaPremezclaTitulo,
};
skAyudaPremezcla.LlamadaMetodosNoExistenDatos += LimpiaParcial;
skAyudaPremezcla.ObtenerDatos += ObtenerDatosPremezcla;
skAyudaPremezcla.AsignaTabIndex(0);
SplAyudaPremezcla.Children.Clear();
SplAyudaPremezcla.Children.Add(skAyudaPremezcla);
}
/// <summary>
/// Carga los datos de la entidad Organización
/// </summary>
private void CargaComboIndicadorProducto(int indicadorID)
{
var indicadorProductoCalidaBL = new IndicadorProductoCalidadBL();
var indicadorProductoCalidadDefault = new ProductoInfo
{
ProductoId = 0,
ProductoDescripcion = Properties.Resources.cbo_Seleccione,
};
IList <ProductoInfo> listaIndicador = indicadorProductoCalidaBL.ObtenerProductosPorIndicador(indicadorID);
if (listaIndicador == null)
{
return;
}
listaIndicador.Insert(0, indicadorProductoCalidadDefault);
cmbProductoIndicador.ItemsSource = listaIndicador;
if (Contexto.IndicadorProductoCalidad.Producto == null || Contexto.IndicadorProductoCalidad.Producto.ProductoId == 0)
{
cmbProductoIndicador.SelectedIndex = 0;
}
else
{
cmbProductoIndicador.SelectedValue = Contexto.IndicadorProductoCalidad.Producto.ProductoId;
cmbProductoIndicador.SelectedItem = Contexto.IndicadorProductoCalidad.Producto;
}
}
public static ProductoInfo ObtenerProducto(int pedidoID, int productoID)
{
var productoPL = new ProductoPL();
ProductoInfo producto = productoPL.ObtenerPorPedidoID(pedidoID, productoID);
return(producto);
}
/// <summary>
/// Manda llamar la pantalla para
/// Generar un Nuevo Producto
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnNuevo_OnClick(object sender, RoutedEventArgs e)
{
try
{
var productoInfo = new ProductoInfo
{
Familias = Familia,
SubFamilias = SubFamilia,
UnidadesMedidcion = Unidad
};
var productoEdicion = new ProductoEdicion(productoInfo)
{
ucTitulo = { TextoTitulo = Properties.Resources.Producto_Nuevo_Titulo }
};
MostrarCentrado(productoEdicion);
ReiniciarValoresPaginador();
CambiarLeyendaCombo();
Buscar();
}
catch (Exception ex)
{
Logger.Error(ex);
SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
Properties.Resources.Producto_ErrorNuevo, MessageBoxButton.OK, MessageImage.Error);
}
}
/// <summary>
/// Obtiene un producto por su ID
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static ProductoInfo ObtenerPorProductoIDLoteExistencia(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
ProductoInfo entidad =
(from info in dt.AsEnumerable()
select
new ProductoInfo
{
ProductoId = info.Field <int>("ProductoID"),
Descripcion = info.Field <string>("Descripcion"),
ProductoDescripcion = info.Field <string>("Descripcion"),
UnidadMedicion = new UnidadMedicionInfo
{
UnidadID = info.Field <int>("UnidadID")
}
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Método que obtiene un registro
/// </summary>
/// <param name="ds"></param>
/// <returns></returns>
internal static ProductoInfo ObtenerPorMaterialSAP(DataSet ds)
{
try
{
Logger.Info();
DataTable dt = ds.Tables[ConstantesDAL.DtDatos];
ProductoInfo entidad =
(from info in dt.AsEnumerable()
select
new ProductoInfo
{
ProductoId = info.Field <int>("ProductoID"),
ProductoDescripcion = info.Field <string>("Descripcion"),
SubfamiliaId = info.Field <int>("SubFamiliaID"),
UnidadId = info.Field <int>("UnidadID"),
Activo = info.Field <bool>("Activo").BoolAEnum(),
EsPremezcla = info.Field <int>("SubFamiliaID") == (int)SubFamiliasEnum.MicroIngredientes,
MaterialSAP = info.Field <string>("MaterialSAP")
}).First();
return(entidad);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
/// <summary>
/// Carga ayudas de productos
/// </summary>
private void CargarAyudaProductos()
{
var productoInfo = new ProductoInfo
{
FamiliaId = FamiliasEnum.Premezclas.GetHashCode(),
SubfamiliaId = SubFamiliasEnum.SubProductos.GetHashCode(),
SubFamilia = new SubFamiliaInfo()
{
SubFamiliaID = SubFamiliasEnum.SubProductos.GetHashCode()
},
Activo = EstatusEnum.Activo
};
skAyudaProducto = new SKAyuda <ProductoInfo>(200, false, productoInfo
, "PropiedadClaveConfiguracionPremezclas"
, "PropiedadDescripcionConfiguracionPremezclas",
"", false, 80, 9, true)
{
AyudaPL = new ProductoPL(),
MensajeClaveInexistente = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaProductoInvalida,
MensajeBusquedaCerrar = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaProductoSalirSinSeleccionar,
MensajeBusqueda = Properties.Resources.Proveedor_Busqueda,
MensajeAgregar = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaProductoSeleccionar,
TituloEtiqueta = Properties.Resources.LeyendaAyudaBusquedaProducto,
TituloPantalla = Properties.Resources.ConfiguracionPremezclaAgregarProducto_AyudaProductoTitulo,
};
skAyudaProducto.ObtenerDatos += ObtenerDatosProducto;
SplAyudaProducto.Children.Clear();
SplAyudaProducto.Children.Add(skAyudaProducto);
}
/// <summary>
/// Obtiene una entidad por su ID
/// </summary>
/// <param name="producto"></param>
/// <returns></returns>
internal ProductoInfo ObtenerProductoPorID(ProductoInfo producto)
{
try
{
Logger.Info();
Dictionary <string, object> parameters =
AuxProductoVigilanciaDAL.ObtenerParametrosProductosPorID(producto);
DataSet ds = Retrieve("Producto_ObtenerProductoVigilanciaPorProductoID", parameters);
ProductoInfo result = null;
if (ValidateDataSet(ds))
{
result = MapProductoDAL.ObtenerPorProductoID(ds);
}
return(result);
}
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>
/// Agrega un producto al grid principal
/// </summary>
private void AgregarProducto()
{
//Falta try catch
try
{
var random = new Random();
var productoPl = new ProductoPL();
var productoInfo = new ProductoInfo()
{
ProductoId = Convert.ToInt32(skAyudaProducto.Clave)
};
productoInfo = productoPl.ObtenerPorID(productoInfo);
var premezclaDetalleInfo = new PremezclaDetalleInfo()
{
PremezclaDetalleID = random.Next(999999999),
Producto = productoInfo,
Porcentaje = Convert.ToDecimal(TxtPorcentajeAjuste.Value.ToString()),
UsuarioCreacionId = usuario
};
listaPremezclaDetalle.Add(premezclaDetalleInfo);
GridPremezclaDetalle.ItemsSource = null;
GridPremezclaDetalle.ItemsSource = listaPremezclaDetalle;
skAyudaProducto.LimpiarCampos();
TxtPorcentajeAjuste.Value = 0;
skAyudaProducto.AsignarFoco();
}
catch (Exception exg)
{
Logger.Error(exg);
}
}
/// <summary>
/// Carga ayudas de productos
/// </summary>
private void CargarAyudaProductos()
{
var productoInfo = new ProductoInfo
{
ProductoId = 0,
Activo = EstatusEnum.Activo
};
skAyudaProductos = new SKAyuda <ProductoInfo>(200, false, productoInfo
, "PropiedadClaveProgramacionMateriaPrima"
, "PropiedadDescripcionProgramacionMateriaPrima",
"", false, 80, 9, true)
{
AyudaPL = new ProductoPL(),
MensajeClaveInexistente = Properties.Resources.RegistrarProgramacionFletesInterna_AyudaProductoInvalido,
MensajeBusquedaCerrar = Properties.Resources.RegistrarProgramacionFletesInterna_AyudaProductoSalirSinSeleccionar,
MensajeBusqueda = Properties.Resources.Proveedor_Busqueda,
MensajeAgregar = Properties.Resources.RegistrarProgramacionFletesInterna_AyudaProductoSeleccionar,
TituloEtiqueta = Properties.Resources.RegistrarProgramacionFletesInterna_AyudaLeyendaProducto,
TituloPantalla = Properties.Resources.RegistrarProgramacionFletesInterna_AyudaProductoTitulo,
};
skAyudaProductos.ObtenerDatos += ObtenerDatosProducto;
SplAyudaProducto.Children.Clear();
SplAyudaProducto.Children.Add(skAyudaProductos);
}
internal static Dictionary <string, object> ObtenerPorProductoIDFamilias(ProductoInfo filtro)
{
try
{
Logger.Info();
var xml = new XElement("ROOT",
from familia in filtro.Familias
select
new XElement("Familias",
new XElement("FamiliaID",
familia.FamiliaID)));
var parametros =
new Dictionary <string, object>
{
{ "@XMLFamilias", xml.ToString() },
{ "@ProductoID", filtro.ProductoId },
{ "@Activo", filtro.Activo },
};
return(parametros);
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
}
public ProductoEdicion(ProductoInfo productoInfo)
{
InitializeComponent();
Contexto = productoInfo;
InicializaContexto(productoInfo.ProductoId == 0);
CambiarLeyendaCombo();
ValidarExistenciaProductosAlmacen();
}
public ActionResult _viewProduct(int id)
{
ProductoInfo prod = BuissnesSrc.ProductInfo(id, "%%").FirstOrDefault();
List <Imagen> imagenes = BuissnesSrc.GetImagenes(id);
var data = new Tuple <ProductoInfo, List <Imagen> >(prod, imagenes);
return(View(data));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="pedidoInfo"></param>
/// <param name="detalleInfo"></param>
public CrearProgramacionMateriaPrimaDialogo(PedidoInfo pedidoInfo, PedidoDetalleInfo detalleInfo)
{
organizacionID = AuxConfiguracion.ObtenerOrganizacionUsuario();
Autorizado = false;
pedido = pedidoInfo;
detallePedido = detalleInfo;
producto = detallePedido.Producto;
InitializeComponent();
}
/// <summary>
/// Agrega un elemento a lista de producto
/// en la posicion cero
/// </summary>
private void AgregarElementoInicialProducto(IList <ProductoInfo> productos)
{
var productoInicial = new ProductoInfo {
ProductoId = 0, ProductoDescripcion = Properties.Resources.cbo_Seleccionar
};
if (!productos.Contains(productoInicial))
{
productos.Insert(0, productoInicial);
}
}
internal static List <ProductoInfo> ObtenerProductosEstado(IDataReader reader)
{
var lista = new List <ProductoInfo>();
try
{
Logger.Info();
ProductoInfo elemento;
while (reader.Read())
{
elemento = new ProductoInfo
{
ProductoId = Convert.ToInt32(reader["ProductoID"]),
ProductoDescripcion = Convert.ToString(reader["ProductoDescripcion"]).Trim(),
SubfamiliaId = Convert.ToInt32(reader["SubFamiliaID"]),
FamiliaId = Convert.ToInt32(reader["FamiliaID"]),
DescripcionFamilia = Convert.ToString(reader["FamiliaDescripcion"]),
UnidadId = Convert.ToInt32(reader["UnidadID"]),
DescripcionUnidad = Convert.ToString(reader["UnidadDescripcion"]),
ManejaLote = Convert.ToBoolean(reader["ManejaLote"]),
Activo = Convert.ToBoolean(reader["Activo"]).BoolAEnum(),
EsPremezcla =
Convert.ToInt32(reader["SubFamiliaID"]) ==
(int)SubFamiliasEnum.MicroIngredientes,
SubFamilia = new SubFamiliaInfo
{
SubFamiliaID = Convert.ToInt32(reader["SubFamiliaID"]),
Descripcion = Convert.ToString(reader["SubFamilia"]),
Familia = new FamiliaInfo
{
Descripcion =
Convert.ToString(
reader["FamiliaDescripcion"]),
FamiliaID =
Convert.ToInt32(reader["FamiliaID"]),
}
},
Familia = new FamiliaInfo
{
Descripcion = Convert.ToString(reader["FamiliaDescripcion"]),
FamiliaID = Convert.ToInt32(reader["FamiliaID"]),
}
};
lista.Add(elemento);
}
}
catch (Exception ex)
{
Logger.Error(ex);
throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
}
return(lista);
}
/// <summary>
/// Obtiene la informacion que retorna la ayuda para la formula
/// </summary>
/// <param name="filtro"></param>
private void ObtenerDatosAyudaProductoFormula(string filtro)
{
if (rbFormula.IsChecked.Value)
{
formulaInfoSeleccionado = skAyudaFormula.Info;
}
else
{
productoInfoSeleccionado = skAyudaProducto.Info;
}
InicializarAyuda();
}
