Пример #1
0
        /// <summary>
        /// Obtiene una lista de folios de entrada por compra para cancelar
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <EntradaProductoInfo> ObtenerFoliosPorPaginaParaCancelacionEntradaTraspaso(PaginacionInfo pagina, EntradaProductoInfo filtro)
        {
            ResultadoInfo <EntradaProductoInfo> foliosLista = null;

            try
            {
                Dictionary <string, object> parameters =
                    AuxEntradaProductoDAL.ObtenerFoliosPorPaginaParaCancelacionEntradaTraspaso(pagina, filtro);
                DataSet ds = Retrieve("EntradaProducto_ObtenerCancelacionPorDescripcionProducto", parameters);
                if (ValidateDataSet(ds))
                {
                    foliosLista = MapEntradaProductoDAL.ObtenerFoliosPorPaginaParaCancelacionEntradaCompra(ds);
                }
            }
            catch (System.Data.SqlClient.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(foliosLista);
        }
Пример #2
0
        /// <summary>
        /// Obtiene la entrada de materia prima por folio
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal EntradaProductoInfo ObtenerPorFolioEntradaCancelacion(EntradaProductoInfo filtro)
        {
            EntradaProductoInfo folio = null;

            try
            {
                Dictionary <string, object> parameters = AuxEntradaProductoDAL.ObtenerParametroPorFolioEntradaMateriaPrima(filtro);
                DataSet ds = Retrieve("EntradaProducto_ObtenerPorFolioCancelacion", parameters);
                if (ValidateDataSet(ds))
                {
                    folio = MapEntradaProductoDAL.ObtenerPorFolioEntradaMateriaPrima(ds);
                }
            }
            catch (System.Data.SqlClient.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(folio);
        }
Пример #3
0
        /// <summary>
        /// Guarda una entrada producto
        /// </summary>
        /// <param name="entradaProducto"></param>
        /// <param name="tipoFolio"></param>
        /// <returns></returns>
        internal EntradaProductoInfo GuardarEntradaProducto(EntradaProductoInfo entradaProducto, int tipoFolio)
        {
            EntradaProductoInfo entrada = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters =
                    AuxEntradaProductoDAL.ObtenerParametrosGuardarEntradaProducto(entradaProducto, tipoFolio);
                DataSet ds = Retrieve("BoletaRecepcion_EntradaProducto_Crear", parameters);
                if (ValidateDataSet(ds))
                {
                    entrada = MapEntradaProductoDAL.ObtenerPorFolioEntradaMateriaPrima(ds);
                }
                return(entrada);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(entrada);
        }
Пример #4
0
        public decimal ObtenerHumedadOrigen(EntradaProductoInfo entradaProducto)
        {
            decimal result = 0;

            try
            {
                Dictionary <string, object> parameters =
                    AuxEntradaProductoDAL.ObtenerHumedadOrigen(entradaProducto);
                DataSet ds = Retrieve("EntradaProducto_ObtenerHumedadOrigenPorEntradaProductoID", parameters);
                if (ValidateDataSet(ds))
                {
                    result = MapEntradaProductoDAL.ObtenerHumedadOrigen(ds);
                }
            }
            catch (System.Data.SqlClient.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);
        }
Пример #5
0
 /// <summary>
 /// Obtiene una lista con las entradas de producto
 /// </summary>
 /// <param name="movimientosEntrada"></param>
 /// <returns></returns>
 internal IEnumerable <EntradaProductoInfo> ObtenerEntradasPorAlmacenMovimientoXML(List <AlmacenMovimientoInfo> movimientosEntrada)
 {
     try
     {
         Dictionary <string, object> parametros =
             AuxEntradaProductoDAL.ObtenerParametrosEntradasPorAlmacenMovimientoXML(movimientosEntrada);
         IMapBuilderContext <EntradaProductoInfo> mapeo = MapEntradaProductoDAL.ObtenerMapeoEntradaProducto();
         IEnumerable <EntradaProductoInfo>        listaEntradaProductos = GetDatabase().ExecuteSprocAccessor
                                                                          <EntradaProductoInfo>(
             "EntradaProducto_ObtenerConciliacionAlmacenMovimientoXML", mapeo.Build(),
             new [] { parametros["@AlmacenMovimientoXML"] });
         return(listaEntradaProductos);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #6
0
        /// <summary>
        /// Obtiene todos las entrada de producto
        /// </summary>
        /// <param name="estatusId"></param>
        /// <param name="organizacionId"></param>
        /// <returns></returns>
        internal List <EntradaProductoInfo> ObtenerEntradaProductosTodosPorEstatusId(int estatusId, int organizacionId)
        {
            List <EntradaProductoInfo> listaEntradaProductos = null;

            try
            {
                Dictionary <string, object> parametros = AuxEntradaProductoDAL.ObtenerParametrosObtenerListaPorEstatusId(estatusId, organizacionId);
                DataSet ds = Retrieve("EntradaProducto_ObtenerEntradaEstatus", parametros);
                if (ValidateDataSet(ds))
                {
                    listaEntradaProductos = MapEntradaProductoDAL.ObtenerTodosAyuda(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(listaEntradaProductos);
        }
Пример #7
0
        /// <summary>
        /// Obtiene las entradas producto por organizacion y folio para el filtro de la ayuda
        /// </summary>
        /// <param name="entrada"></param>
        /// <returns></returns>
        internal List <EntradaProductoInfo> ObtenerEntradaProductoValidoAyuda(EntradaProductoInfo entrada)
        {
            List <EntradaProductoInfo> listaEntradaProductos = null;

            try
            {
                Dictionary <string, object> parametros = AuxEntradaProductoDAL.ObtenerParametrosObtenerEntradaProductoValidoAyuda(entrada);
                DataSet ds = Retrieve("EntradaProducto_ObtenerEntradaProductoAyuda", parametros);
                if (ValidateDataSet(ds))
                {
                    listaEntradaProductos = MapEntradaProductoDAL.ObtenerEntradaProductoAyuda(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(listaEntradaProductos);
        }
Пример #8
0
        /// <summary>
        /// Obtiene una lista de entradas de producto por contrato
        /// Esta funcion solo consulta EntradaProducto
        /// </summary>
        /// <param name="contratoInfo"></param>
        /// <returns></returns>
        internal List <EntradaProductoInfo> ObtenerEntradaProductoPorContrato(ContratoInfo contratoInfo)
        {
            List <EntradaProductoInfo> resultado = null;

            try
            {
                Dictionary <string, object> parametros =
                    AuxEntradaProductoDAL.ObtenerEntradaProductoPorContrato(contratoInfo);
                DataSet ds = Retrieve("EntradaProducto_ObtenerPorContratoID", parametros);
                if (ValidateDataSet(ds))
                {
                    resultado = MapEntradaProductoDAL.ObtenerEntradaProductoPorContrato(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Пример #9
0
        internal List <DiferenciasIndicadoresMuestraContrato> ObtenerDiferenciasIndicadoresMuestraContratoPorEntradaID(int entradaProductoId)
        {
            List <DiferenciasIndicadoresMuestraContrato> resultado = null;

            try
            {
                Dictionary <string, object> parametros =
                    AuxEntradaProductoDAL.ObtenerParametrosObtenerEntradaProductoPorId(entradaProductoId);
                DataSet ds = Retrieve("EntradaProductoDetalle_ObtenerDiferenciasIndicadoresPorEntradaId", parametros);
                if (ValidateDataSet(ds))
                {
                    resultado = MapEntradaProductoDAL.ObtenerDiferenciasIndicadoresMuestraContratoPorEntradaID(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Пример #10
0
        /// <summary>
        /// Obtiene un contenedor de Entrada de Materia Prima
        /// </summary>
        /// <param name="folioEntrada"></param>
        /// <param name="contratoId"></param>
        /// <param name="organizacionID"></param>
        /// <returns></returns>
        internal ContenedorEntradaMateriaPrimaInfo ObtenerPorFolioEntradaContrato(int folioEntrada, int contratoId, int organizacionID)
        {
            ContenedorEntradaMateriaPrimaInfo resultado = null;

            try
            {
                Dictionary <string, object> parametros =
                    AuxEntradaProductoDAL.ObtenerParametrosFolioEntradaContrato(folioEntrada, contratoId, organizacionID);
                DataSet ds = Retrieve("EntradaProducto_ObtenerFolioEntradaContrato", parametros);
                if (ValidateDataSet(ds))
                {
                    resultado = MapEntradaProductoDAL.ObtenerPorFolioEntradaContrato(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Пример #11
0
        /// <summary>
        /// Obtiene la entrada producto por su identificador
        /// </summary>
        /// <param name="entradaProductoId"></param>
        /// <returns></returns>
        internal EntradaProductoInfo ObtenerEntradaProductoPorId(int entradaProductoId)
        {
            EntradaProductoInfo entradaProducto = null;

            try
            {
                Dictionary <string, object> parametros = AuxEntradaProductoDAL.ObtenerParametrosObtenerEntradaProductoPorId(entradaProductoId);
                DataSet ds = Retrieve("EntradaProducto_ObtenerEntradaProductoPorId", parametros);
                if (ValidateDataSet(ds))
                {
                    entradaProducto = MapEntradaProductoDAL.ObtenerEntradaProductoPorFolio(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(entradaProducto);
        }
Пример #12
0
        /// <summary>
        /// Obtiene las notificaciones autorizadas
        /// </summary>
        /// <returns></returns>
        internal List <EntradaProductoInfo> ObtenerNotificacionesAutorizadas(int organizacionID)
        {
            List <EntradaProductoInfo> resultado = null;

            try
            {
                var parametros = new Dictionary <string, object> {
                    { "OrganizacionID", organizacionID }
                };
                using (IDataReader reader = RetrieveReader("EntradaProducto_ObtenerNotificacionesAutorizadas", parametros))
                {
                    if (ValidateDataReader(reader))
                    {
                        resultado = MapEntradaProductoDAL.ObtenerNotificacionesAutorizadas(reader);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
Пример #13
0
        /// <summary>
        /// Guarda una entrada producto sin detalle
        /// </summary>
        /// <param name="entradaProducto"></param>
        /// <param name="tipoFolio"></param>
        /// <returns></returns>
        internal EntradaProductoInfo GuardarEntradaProductoSinDetalle(EntradaProductoInfo entradaProducto, int tipoFolio)
        {
            EntradaProductoInfo entradaProductoNuevo = null;

            try
            {
                Logger.Info();
                Dictionary <string, object> parameters =
                    AuxEntradaProductoDAL.ObtenerParametrosGuardarEntradaProductoSinDetalle(entradaProducto, tipoFolio);

                DataSet ds = Retrieve("EntradaProducto_Crear", parameters);
                if (ValidateDataSet(ds))
                {
                    entradaProductoNuevo = MapEntradaProductoDAL.ObtenerPorFolioEntradaMateriaPrima(ds);
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(entradaProductoNuevo);
        }