コード例 #1
0
        /// <summary>
        /// Validar campos en blanco
        /// </summary>
        /// <returns></returns>
        private ResultadoValidacion ValidarCamposBlanco()
        {
            var resultado = new ResultadoValidacion();

            if (String.IsNullOrEmpty(skAyudaCosto.Clave.Trim()) && String.IsNullOrEmpty(skAyudaCosto.Descripcion.Trim()))
            {
                skAyudaCosto.AsignarFoco();
                resultado.Mensaje   = Properties.Resources.CostosdeFletes_CostoRequerido;
                resultado.Resultado = false;
                return(resultado);
            }
            if (String.IsNullOrEmpty(txtTarifa.Text.Trim()))
            {
                txtTarifa.Focus();
                resultado.Mensaje   = Properties.Resources.CostosdeFletes_TarifaRequerido;
                resultado.Resultado = false;
                return(resultado);
            }
            resultado.Resultado = true;
            return(resultado);
        }
コード例 #2
0
        /// <summary>
        /// Valida que los datos del archivo correspondan a la fecha
        /// </summary>
        /// <param name="validacion"></param>
        /// <returns></returns>
        internal ResultadoValidacion ValidarDatosArchivo(ValidacionDataLink validacion)
        {
            var resultado = new ResultadoValidacion {
                Resultado = true
            };

            try
            {
                Logger.Info();
                if (validacion.ListaDataLink.Count > 0)
                {
                    var listaValidos = new List <DataLinkInfo>();
                    listaValidos.AddRange(validacion.ListaDataLink.Where(dataLink => dataLink.FechaReparto == validacion.Fecha && dataLink.TipoServicio == (int)validacion.TipoServicio));
                    validacion.ListaDataLink = listaValidos;
                    if (listaValidos.Count == 0)
                    {
                        resultado.Resultado = false;
                        resultado.TipoResultadoValidacion = TipoResultadoValidacion.RepartoFechaNoValida;
                        resultado.Mensaje = ResourceServices.DescargarDataLink_FechaNoValida;
                    }
                }
                else
                {
                    resultado.Resultado = false;
                    resultado.TipoResultadoValidacion = TipoResultadoValidacion.RepartoArchivoSinDatos;
                    resultado.Mensaje = ResourceServices.DescargarDataLink_ArchivoSinDatos;
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
コード例 #3
0
        /// <summary>
        /// Se guardan las respuesta a las solicitudes de materia prima
        /// </summary>
        /// <param name="respuestaSolicitudes"></param>
        /// <returns></returns>
        public ResultadoValidacion GuardarRespuestasSolicitudes(List <AutorizacionMovimientosInfo> respuestaSolicitudes, int organizacionID, int tipoAutorizacionID, int usuarioID)
        {
            var result = new ResultadoValidacion();

            try
            {
                Logger.Info();
                var solicitudBL = new SolicitudAutorizacionBL();
                result = solicitudBL.GuardarRespuestasSolicitudes(respuestaSolicitudes, organizacionID, tipoAutorizacionID, usuarioID);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(result);
        }
コード例 #4
0
ファイル: ClientePL.cs プロジェクト: vijaydairyf/Prueba
        public ResultadoValidacion validarLimiteCredito(ParametrosValidacionLimiteCredito datosValidacion)
        {
            ResultadoValidacion resultado = new ResultadoValidacion();
            ClienteBL           clienteBL = new ClienteBL();

            try
            {
                Logger.Info();
                resultado = clienteBL.validarLimiteCredito(datosValidacion);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(resultado);
        }
コード例 #5
0
        private bool CanGuardarContrato(object parameters)
        {
            ResultadoValidacion resultadoValidacionCampos =
                ValidacionesContrato.CamposObligatorios(this.Contrato);

            if (resultadoValidacionCampos.Exito == false)
            {
                MessageBox.Show(resultadoValidacionCampos.MensajeError, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }

            ResultadoValidacion resultadoValidacionFechas =
                ValidacionesContrato.Fechas(this.Contrato.InicioEvento, this.Contrato.TerminoEvento, this.Contrato.Creacion);

            if (resultadoValidacionFechas.Exito == false)
            {
                MessageBox.Show(resultadoValidacionFechas.MensajeError, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
                return(false);
            }

            return(true);
        }
        /// <summary>
        /// Valida si se puede agregar el costo
        /// </summary>
        private ResultadoValidacion ValidarAgregar(bool actualizar)
        {
            var resultado = new ResultadoValidacion();

            if (String.IsNullOrEmpty(skAyudaCostos.Clave.Trim()) && String.IsNullOrEmpty(skAyudaCostos.Descripcion.Trim()))
            {
                skAyudaCostos.AsignarFoco();
                resultado.Mensaje   = Properties.Resources.RegistrarProgramacionFletesInterna_MensajeValidacionOtrosCostosIngresarCosto;
                resultado.Resultado = false;
                return(resultado);
            }

            if (TxtTarifa.Text == string.Empty || Convert.ToDecimal(TxtTarifa.Value) == 0)
            {
                TxtTarifa.Focus();
                resultado.Mensaje   = Properties.Resources.RegistrarProgramacionFletesInterna_MensajeValidacionOtrosCostosIngresarTarifa;
                resultado.Resultado = false;
                return(resultado);
            }

            if (!actualizar)
            {
                if (ListadoFleteInternoCostoFiltrado != null)
                {
                    if ((from fleteInternoDetalle in ListadoFleteInternoCostoFiltrado
                         where fleteInternoDetalle.Costo.CostoID == Convert.ToInt32(skAyudaCostos.Clave)
                         select fleteInternoDetalle).Any())
                    {
                        skAyudaCostos.AsignarFoco();
                        resultado.Resultado = false;
                        resultado.Mensaje   = Properties.Resources.RegistrarProgramacionFletesInterna_MensajeValidacionOtrosCostosCostoAgregado;
                        return(resultado);
                    }
                }
            }

            resultado.Resultado = true;
            return(resultado);
        }
コード例 #7
0
        public static ResultadoValidacion ValidarArete(string codigoArete)
        {
            try
            {
                var seguridad = (SeguridadInfo)ObtenerSeguridad();

                var revisionImplantePl = new RevisionImplantesPL();
                var animal             =
                    new AnimalInfo
                {
                    Arete = codigoArete,
                    OrganizacionIDEntrada = seguridad.Usuario.OrganizacionID
                };
                ResultadoValidacion resultado = revisionImplantePl.ValidarArete(animal, CorralSeleccionado);
                AreteSeleccionado = (AnimalInfo)resultado.Control;
                return(resultado);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw;
            }
        }
コード例 #8
0
        /// <summary>
        /// Valida los campos toneladas e importe
        /// </summary>
        /// <returns></returns>
        private ResultadoValidacion ValidarCampos()
        {
            var resultado = new ResultadoValidacion();

            if ((String.IsNullOrEmpty(TxtToneladas.Text) || !TxtToneladas.Value.HasValue))
            {
                TxtToneladas.Focus();
                resultado.Resultado = false;
                resultado.Mensaje   = Properties.Resources.RegistrarCompraParcial_ValidacionToneladas;
                return(resultado);
            }

            if (String.IsNullOrEmpty(TxtImporte.Text) || !TxtImporte.Value.HasValue)
            {
                TxtImporte.Focus();
                resultado.Resultado = false;
                resultado.Mensaje   = Properties.Resources.RegistrarCompraParcial_ValidacionImporte;
                return(resultado);
            }

            //Validar toneladas contrato
            var toneladasIngresadas = TxtToneladas.Value.Value;
            var toneladasAgregadas  = listaContratoParcial.Sum(contratoParcialInfo => contratoParcialInfo.Cantidad);
            var toneladasTotales    = toneladasIngresadas + toneladasAgregadas;
            var toneladasPermitidas = toneladasContrato + ((toneladasContrato / 100) * toleranciaContrato);

            if (toneladasPermitidas < toneladasTotales)
            {
                TxtToneladas.Focus();
                resultado.Resultado = false;
                resultado.Mensaje   = Properties.Resources.CrearContrato_CapturarValidacionToneladasContrato;
                return(resultado);
            }

            resultado.Resultado = true;
            return(resultado);
        }
コード例 #9
0
        public static Response <ResultadoValidacion> ObtenerDatosArchivo(string fecha, string tipoServicio)
        {
            var resultado = new ResultadoValidacion {
                Resultado = true
            };
            var fechaReparto = DateTime.Parse(fecha);

            try
            {
                var validarDataLink = new ValidacionDataLink
                {
                    Fecha         = fechaReparto,
                    RutaArchivo   = rutaArchivoDataLink,
                    NombreArchivo = nombreArchivoDataLink,
                    TipoServicio  = (TipoServicioEnum)Enum.Parse(typeof(TipoServicioEnum), tipoServicio)
                };

                var descargaArchivoDatalinPl = new DescargaArchivoDataLinkPL();

                resultado = descargaArchivoDatalinPl.ObtenerDatosArchivo(validarDataLink);

                if (resultado.Resultado)
                {
                    resultado = descargaArchivoDatalinPl.ValidarDatosArchivo(validarDataLink);

                    listaDatalink = validarDataLink.ListaDataLink;
                }

                return(Response <ResultadoValidacion> .CrearResponse(true, resultado));
            }
            catch (Exception)
            {
                resultado.Resultado = false;
                resultado.TipoResultadoValidacion = TipoResultadoValidacion.RepartoErrorInesperado;
                return(Response <ResultadoValidacion> .CrearResponse(false, resultado));
            }
        }
コード例 #10
0
        public static ResultadoValidacion ObtenerGradoPorcentual()
        {
            var resultado = new ResultadoValidacion();

            try
            {
                var parametroPl = new ParametroGeneralPL();

                var seguridad = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;

                if (seguridad != null)
                {
                    ParametroGeneralInfo parametro = parametroPl.ObtenerPorClaveParametro(ParametrosEnum.GradoPorcentualPerdidaHumedad.ToString());
                    resultado.Resultado = true;
                    resultado.Control   = parametro;
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(resultado);
        }
コード例 #11
0
        public static ResultadoValidacion AgregarArete(RevisionImplanteInfo revision)
        {
            try
            {
                var resultado = new ResultadoValidacion();
                revision.Fecha = DateTime.Now;
                var revisionImplantePl = new RevisionImplantesPL();

                if (Revisiones == null)
                {
                    Revisiones = new List <RevisionImplanteInfo>();
                }

                resultado = ValidarCorral(revision.Corral.Codigo);
                if (!resultado.Resultado)
                {
                    return(resultado);
                }

                var revisionTemporal = (RevisionImplanteInfo)resultado.Control;
                revision.Corral = revisionTemporal.Corral;
                revision.Lote   = revisionTemporal.Lote;

                resultado = ValidarArete(revision.Animal.Arete);
                if (!resultado.Resultado)
                {
                    return(resultado);
                }

                revision.Animal = (AnimalInfo)resultado.Control;

                resultado = revisionImplantePl.ValidarAgregarArete(revision, Revisiones);

                if (!resultado.Resultado)
                {
                    return(resultado);
                }

                foreach (var lugar in Lugares.Lista.Where(lugar => lugar.AreaRevisionId == revision.LugarValidacion.AreaRevisionId))
                {
                    revision.LugarValidacion = lugar;
                    break;
                }

                foreach (var causa in Causas.Lista.Where(lugar => lugar.CausaId == revision.Causa.CausaId))
                {
                    revision.Causa = causa;
                    break;
                }

                Revisiones.Add(revision);

                resultado.Control = Revisiones;

                //ResultadoValidacion resultado = new ResultadoValidacion();// = revisionImplantePl.ValidarAgregarArete(animal, CorralSeleccionado);
                //AreteSeleccionado = (AnimalInfo)resultado.Control;
                return(resultado);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw;
            }
        }
コード例 #12
0
        public virtual ResultadoValidacion ValidarParaPresentacion(DatosValidacion pDatosValidacion)
        {
            ResultadoValidacion result = new ResultadoValidacion();
            bool   registroValido      = true;
            string mensaje             = "";

            if (!ValidarCI(pDatosValidacion.Ci))
            {
                mensaje       += "CI invalida";
                registroValido = false;
            }

            if (!ValidarNombreYApellido(pDatosValidacion.Nombre, pDatosValidacion.Apellido))
            {
                if (registroValido)
                {
                    mensaje += "Nombre y/o Apellido invalidos";
                }
                else
                {
                    mensaje += ", nombre y/o Apellido invalidos";
                }
                registroValido = false;
            }

            if (!ValidarEmail(pDatosValidacion.Email))
            {
                if (registroValido)
                {
                    mensaje += "Email invalido";
                }
                else
                {
                    mensaje += ", email invalido";
                }
                registroValido = false;
            }

            if (!ValidarCelular(pDatosValidacion.Cell))
            {
                if (registroValido)
                {
                    mensaje += "Celular invalido";
                }
                else
                {
                    mensaje += ", celular invalido";
                }
                registroValido = false;
            }

            if (!ValidarEdad(pDatosValidacion.FechaDeNacimiento))
            {
                if (registroValido)
                {
                    mensaje += "Edad invalida";
                }
                else
                {
                    mensaje += ", edad invalida";
                }
                registroValido = false;
            }


            if (!ValidarContrasenia(pDatosValidacion.Pass))
            {
                if (registroValido)
                {
                    mensaje += "Contraseña invalida";
                }
                else
                {
                    mensaje += ", contraseña invalida";
                }
                registroValido = false;
            }


            result.Mensaje   = mensaje;
            result.Resultado = registroValido;

            return(result);
        }
コード例 #13
0
        /// <summary>
        /// Realiza la validacion de limite de credito de un cliente
        /// </summary>
        /// <param name="datosValidacion"></param>
        /// <returns>Objeto con el resultado de la validacion</returns>
        public ResultadoValidacion validarLimiteCredito(ParametrosValidacionLimiteCredito datosValidacion)
        {
            ResultadoValidacion  resultado    = new ResultadoValidacion();
            ParametroGeneralBL   parametroGen = new ParametroGeneralBL();
            ParametroGeneralInfo parametroGeneral;
            SI_OS_SBX_to_ECC_ValidaCreditoClientesRequest  request;
            SI_OS_SBX_to_ECC_ValidaCreditoClientesResponse response;

            SI_OS_SBX_to_ECC_ValidaCreditoClientesClient servicio;

            try
            {
                parametroGeneral = parametroGen.ObtenerPorClaveParametro(ParametrosEnum.FlagValidarLimiteCredito.ToString());
                if (parametroGeneral.Valor.Trim().CompareTo("1") == 0)
                {
                    servicio = obtenerInstanciaClienteValidaCredito();
                    request  = new SI_OS_SBX_to_ECC_ValidaCreditoClientesRequest();
                    response = new SI_OS_SBX_to_ECC_ValidaCreditoClientesResponse();

                    request.MT_SBK_ValidaCreditoClientes_Request = new DT_SBK_ValidaCreditoClientes_Request
                    {
                        Cliente  = datosValidacion.CodigoSAP,
                        Importe  = datosValidacion.Importe.ToString(),
                        Sociedad = datosValidacion.Sociedad,
                        Moneda   = datosValidacion.Moneda
                    };

                    response.MT_SBK_ValidaCreditoClientes_Response = servicio.SI_OS_SBX_to_ECC_ValidaCreditoClientes(request.MT_SBK_ValidaCreditoClientes_Request);
                    servicio.Close();

                    if (response.MT_SBK_ValidaCreditoClientes_Response != null)
                    {
                        resultado.TipoResultadoValidacion = TipoResultadoValidacion.Default;
                        if (response.MT_SBK_ValidaCreditoClientes_Response.Resultado.Trim().CompareTo("0") == 0)
                        {
                            resultado.Resultado = false;
                            resultado.Mensaje   = response.MT_SBK_ValidaCreditoClientes_Response.Mensaje;
                        }
                        else if (response.MT_SBK_ValidaCreditoClientes_Response.Resultado.Trim().CompareTo("1") == 0)
                        {
                            resultado.Resultado = true;
                            resultado.Mensaje   = response.MT_SBK_ValidaCreditoClientes_Response.Mensaje;
                        }
                        else
                        {
                            resultado.Resultado = false;
                            resultado.Mensaje   = Properties.ResourceServices.validarLimiteCredito_RespuestaServicioDesconocida.ToString().Trim();
                        }
                    }
                    else
                    {
                        resultado.Resultado = false;
                        resultado.Mensaje   = Properties.ResourceServices.validarLimiteCredito_SinRespuestaServicio.ToString().Trim();
                    }
                    GC.SuppressFinalize(servicio);
                    GC.SuppressFinalize(request);
                    GC.SuppressFinalize(response);
                }
                else
                {
                    resultado.Resultado = true;
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                resultado.Resultado = false;
                resultado.Mensaje   = Properties.ResourceServices.validarLimiteCredito_ErrorConsumoServicio.ToString().Trim();
                //throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
コード例 #14
0
        /// <summary>
        /// Se guardan las respuesta a las solicitudes de materia prima
        /// </summary>
        /// <param name="respuestaSolicitudes"></param>
        /// <param name="organizacionID"></param>
        /// <param name="tipoAutorizacionID"></param>
        /// <param name="usuarioID"></param>
        /// <returns></returns>
        public ResultadoValidacion GuardarRespuestasSolicitudes(List <AutorizacionMovimientosInfo> respuestaSolicitudes, int organizacionID, int tipoAutorizacionID, int usuarioID)
        {
            var result  = new ResultadoValidacion();
            var mensaje = new StringBuilder();

            try
            {
                Logger.Info();
                var solicitudDAL        = new SolicitudAutorizacionDAL();
                var almacenMovimientoBl = new AlmacenMovimientoBL();

                using (var transaction = new TransactionScope())
                {
                    List <DiferenciasDeInventariosInfo> listaMovimientosPendientes =
                        solicitudDAL.ObtenerMovimientosAutorizacion(respuestaSolicitudes);

                    if (listaMovimientosPendientes != null && listaMovimientosPendientes.Any())
                    {
                        foreach (var movimiento in listaMovimientosPendientes)
                        {
                            if (movimiento.AlmacenMovimiento.TipoMovimientoID == TipoMovimiento.SalidaPorAjuste.GetHashCode())
                            {
                                if (movimiento.AlmacenMovimientoDetalle.Cantidad >
                                    movimiento.AlmacenInventarioLote.Cantidad)
                                {
                                    AutorizacionMovimientosInfo autorizacionCancelar =
                                        respuestaSolicitudes.FirstOrDefault(
                                            aut =>
                                            aut.AlmacenMovimientoID == movimiento.AlmacenMovimiento.AlmacenMovimientoID);

                                    if (autorizacionCancelar != null)
                                    {
                                        autorizacionCancelar.EstatusID     = Estatus.AMPRechaza.GetHashCode();
                                        autorizacionCancelar.Observaciones =
                                            ResourceServices.SolicitudAutorizacionBL_RechazoAutomatico;
                                        mensaje.Append(string.Format(", {0}:{1}",
                                                                     movimiento.Producto.ProductoDescripcion,
                                                                     movimiento.AlmacenMovimientoDetalle.Cantidad));
                                    }
                                }
                            }
                        }
                    }

                    bool guardado = solicitudDAL.GuardarRespuestasSolicitudes(respuestaSolicitudes, organizacionID, tipoAutorizacionID, usuarioID);

                    if (guardado && tipoAutorizacionID == (int)TipoAutorizacionEnum.AjustedeInventario)
                    {
                        for (int i = 0; i < respuestaSolicitudes.Count; i++)
                        {
                            if (respuestaSolicitudes[i].EstatusID == (int)Estatus.AMPAutoriz)
                            {
                                respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvAutorizado;
                            }
                            else
                            {
                                respuestaSolicitudes[i].EstatusInventarioID = (int)Estatus.DifInvRechazado;
                            }
                        }
                        // Se realiza el proceso de afectar el inventario para los movimientos autorizados
                        List <DiferenciasDeInventariosInfo> listaAjustesPendientes;
                        var diferenciasDeInventarioBl = new DiferenciasDeInventarioBL();

                        listaAjustesPendientes = solicitudDAL.GuardarAjusteInventario(respuestaSolicitudes, organizacionID);

                        if (listaAjustesPendientes != null)
                        {
                            foreach (var diferenciasDeInventariosInfoPar in listaAjustesPendientes)
                            {
                                diferenciasDeInventariosInfoPar.DescripcionAjuste =
                                    diferenciasDeInventariosInfoPar.AlmacenMovimiento.TipoMovimientoID ==
                                    TipoMovimiento.SalidaPorAjuste.GetHashCode()
                                        ? TipoAjusteEnum.Merma.ToString()
                                        : TipoAjusteEnum.Superávit.ToString();
                                diferenciasDeInventariosInfoPar.DiferenciaInventario =
                                    diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.Cantidad;

                                diferenciasDeInventariosInfoPar.AlmacenMovimiento.UsuarioModificacionID        = usuarioID;
                                diferenciasDeInventariosInfoPar.AlmacenMovimientoDetalle.UsuarioModificacionID = usuarioID;
                                diferenciasDeInventariosInfoPar.AlmacenInventarioLote.UsuarioModificacionId    = usuarioID;

                                diferenciasDeInventariosInfoPar.AlmacenMovimiento.Status =
                                    Estatus.DifInvAplicado.GetHashCode();
                                diferenciasDeInventariosInfoPar.TieneConfiguracion = true;

                                //Se cambia el status por aplicado
                                almacenMovimientoBl.ActualizarEstatus(diferenciasDeInventariosInfoPar.AlmacenMovimiento);
                                //Actualiza inventario y lote
                                diferenciasDeInventarioBl.ActualizarInventarioYLote(diferenciasDeInventariosInfoPar, usuarioID);
                            }

                            #region POLIZA

                            List <PolizaEntradaSalidaPorAjusteModel> salidasPorAjuste =
                                listaAjustesPendientes.Where(dif => !dif.DescripcionAjuste.Trim().Equals(TipoAjusteEnum.CerrarLote.ToString().Trim(), StringComparison.InvariantCultureIgnoreCase)).Select(ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                Importe =
                                    ajuste.DiferenciaInventario *
                                    ajuste.AlmacenInventarioLote.
                                    PrecioPromedio,
                                Cantidad   = ajuste.DiferenciaInventario,
                                TipoAjuste =
                                    ajuste.DescripcionAjuste.Equals(
                                        TipoAjusteEnum.Merma.ToString(),
                                        StringComparison.
                                        CurrentCultureIgnoreCase)
                                            ? TipoAjusteEnum.Merma
                                            : TipoAjusteEnum.Superávit,
                                Precio = ajuste.AlmacenInventarioLote.
                                         PrecioPromedio,
                                AlmacenInventarioID =
                                    ajuste.AlmacenInventarioLote.
                                    AlmacenInventario.AlmacenInventarioID,
                                AlmacenMovimientoDetalleID =
                                    ajuste.AlmacenMovimientoDetalle.
                                    AlmacenMovimientoDetalleID,
                                ProductoID = ajuste.Producto.ProductoId,
                                CantidadInventarioFisico =
                                    ajuste.KilogramosFisicos,
                                CantidadInventarioTeorico =
                                    ajuste.KilogramosTeoricos,
                                Observaciones =
                                    ajuste.AlmacenMovimiento.Observaciones
                            }).ToList();
                            var agrupado =
                                salidasPorAjuste.GroupBy(tipo => new { tipo.TipoAjuste, tipo.AlmacenMovimientoDetalleID }).Select(
                                    ajuste => new PolizaEntradaSalidaPorAjusteModel
                            {
                                TipoAjuste                 = ajuste.Key.TipoAjuste,
                                AlmacenInventarioID        = ajuste.First().AlmacenInventarioID,
                                AlmacenMovimientoDetalleID = ajuste.Key.AlmacenMovimientoDetalleID,
                                Cantidad = ajuste.First().Cantidad,
                                CantidadInventarioFisico  = ajuste.First().CantidadInventarioFisico,
                                CantidadInventarioTeorico = ajuste.First().CantidadInventarioTeorico,
                                Importe                 = ajuste.First().Importe,
                                Observaciones           = ajuste.First().Observaciones,
                                Precio                  = ajuste.First().Precio,
                                PrecioInventarioFisico  = ajuste.First().PrecioInventarioFisico,
                                PrecioInventarioTeorico = ajuste.First().PrecioInventarioTeorico,
                                ProductoID              = ajuste.First().ProductoID
                            }).ToList();
                            if (agrupado != null && agrupado.Any())
                            {
                                var streams = new List <MemoryStream>();
                                for (int indexAjustes = 0; indexAjustes < agrupado.Count; indexAjustes++)
                                {
                                    var tipoPoliza = TipoPoliza.SalidaAjuste;
                                    switch (agrupado[indexAjustes].TipoAjuste)
                                    {
                                    case TipoAjusteEnum.Superávit:
                                        tipoPoliza = TipoPoliza.EntradaAjuste;
                                        break;
                                    }
                                    var poliza = FabricaPoliza.ObtenerInstancia().ObtenerTipoPoliza(tipoPoliza);
                                    var grupo  = new List <PolizaEntradaSalidaPorAjusteModel>
                                    {
                                        agrupado[indexAjustes]
                                    };
                                    var polizas = poliza.GeneraPoliza(grupo);
                                    if (polizas != null && polizas.Any())
                                    {
                                        MemoryStream stream = poliza.ImprimePoliza(grupo, polizas);
                                        if (stream != null)
                                        {
                                            streams.Add(stream);
                                        }
                                        var polizaBL = new PolizaBL();
                                        polizas.ToList().ForEach(datos =>
                                        {
                                            datos.OrganizacionID         = organizacionID;
                                            datos.UsuarioCreacionID      = usuarioID;
                                            datos.ArchivoEnviadoServidor = 1;
                                        });
                                        polizaBL.GuardarServicioPI(polizas, tipoPoliza);
                                    }
                                }
                            }

                            #endregion POLIZA
                        }
                    }
                    transaction.Complete();
                }
            }
            catch (ExcepcionServicio ex)
            {
                result.Mensaje       = ex.Message;
                result.Resultado     = false;
                result.CodigoMensaje = 2;
                return(result);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            if (mensaje.Length == 0)
            {
                result.Resultado = true;
            }
            else
            {
                result.Mensaje       = String.Format(ResourceServices.SolicitudAutorizacionBL_AutorizacionRechazadas, mensaje);
                result.Resultado     = false;
                result.CodigoMensaje = 1;
            }
            return(result);
        }
コード例 #15
0
        public ResultadoValidacion ValidacionesLista(List <ProcesarArchivoInfo> listaprocesarlo)
        {
            var    seguridad           = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;
            string mensajeOK           = string.Empty;
            var    localResourceObject = GetLocalResourceObject("OK");

            if (localResourceObject != null)
            {
                mensajeOK = localResourceObject.ToString();
            }

            string nombrerotomix = "";

            var resultado = new ResultadoValidacion
            {
                Mensaje = mensajeOK
            };

            var listaFormulaDetalle         = new List <ProduccionFormulaDetalleInfo>();
            var listaFormulaProduccionBatch = new List <ProduccionFormulaBatchInfo>();

            try
            {
                List <ProcesarArchivoInfo> listaparadetalle = listaprocesarlo;
                //sacamos las distintas formulas del archivo de texto
                List <ProcesarArchivoInfo> formulas = listaprocesarlo.GroupBy(p => p.Formula).Select(g => g.First()).ToList();

                foreach (var renglon in formulas) //recorremos por formulas
                {
                    ProcesarArchivoInfo elemento = renglon;
                    //sacamos los batchs
                    var batches = from w in listaprocesarlo
                                  where w.Formula == elemento.Formula
                                  group w by w.batch into g
                                  select new
                    {
                        FirstLetter = g.Key,
                        Words       = g
                    };

                    resultado.Mensaje = ValidarCodigoFormula(elemento);
                    if (resultado.Mensaje != mensajeOK)
                    {
                        return(resultado);
                    }

                    int sumatoriameta = 0; int sumatoriareal = 0;
                    listaFormulaProduccionBatch = new List <ProduccionFormulaBatchInfo>();
                    foreach (var batch in batches)
                    {
                        List <ProcesarArchivoInfo> lista = listaprocesarlo.Where(k => k.Formula == elemento.Formula && k.batch == batch.FirstLetter).ToList();
                        var detallesBatchs     = new DetalleBatchInfo();
                        int sumatoriarealbatch = 0;

                        foreach (ProcesarArchivoInfo elmentoArchivo in lista)
                        {
                            if (elmentoArchivo.Marca == "2")
                            {
                                resultado.Mensaje = ValidarColumnaCodigoLista(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }
                            }
                            else
                            {
                                resultado.Mensaje = ValidarFechaYHora(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }

                                //valido que exista el codigo del producto
                                resultado.Mensaje = ValidarCodigoProducto(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }

                                resultado.Mensaje = ValidarCodigoRotomix(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }
                                resultado.Mensaje = ValidarCodigoFormula(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }
                                resultado.Mensaje = ValidarProduccionFormula(elmentoArchivo);
                                if (resultado.Mensaje != mensajeOK)
                                {
                                    return(resultado);
                                }
                                //var elementosDuplicados =
                                //    lista.Where(det => det.Codigo.Equals(elmentoArchivo.Codigo)
                                //                         && det.Formula.ToUpper().Trim().Equals(elmentoArchivo.Formula.ToUpper().Trim())
                                //                         && det.Rotomix.ToUpper().Trim().Equals(elmentoArchivo.Rotomix.ToUpper().Trim())
                                //                         && det.Hora.Equals(elmentoArchivo.Hora)).ToList();

                                //if(elementosDuplicados.Count > 1)
                                //{
                                //    resultado.Mensaje = string.Format("El renglon se encuentra duplicado, Batch: {0}, Producto: {1}, RotoMix: {2}, Hora: {3}", elmentoArchivo.batch, elmentoArchivo.Codigo, elmentoArchivo.Rotomix, elmentoArchivo.Hora);
                                //    return resultado;
                                //}

                                sumatoriameta      = sumatoriameta + elmentoArchivo.Meta;
                                sumatoriareal      = sumatoriareal + elmentoArchivo.Real;
                                sumatoriarealbatch = sumatoriarealbatch + elmentoArchivo.Real;
                                nombrerotomix      = elmentoArchivo.Rotomix;
                            }
                        }

                        detallesBatchs.Batch           = batch.FirstLetter;
                        detallesBatchs.KilosProducidos = sumatoriarealbatch;
                        detallesBatchs.Rotomix         = nombrerotomix;
                        detallesBatchs.Formula         = renglon.Formula;
                        ListaGlobalDetalleBatch.Add(detallesBatchs);

                        //creamos el detalle de la tabla Produccion Formula Detalle
                        listaFormulaDetalle = CrearListaProduccionFormulaDetalle(listaparadetalle, renglon.Formula);

                        if (listaFormulaDetalle == null)
                        {
                            resultado.Mensaje = "ingrediente";
                            return(resultado);
                        }

                        //creamos el detalle de la tabla Produccion Formula Batch
                        listaFormulaProduccionBatch.AddRange(CrearListaProduccionFormulaBatch(listaparadetalle, renglon.Formula, batch.FirstLetter, nombrerotomix));
                    }//aqui termina por batch

                    //aqui llenara la lista

                    var produccionFormula = new ProduccionFormulaInfo();
                    produccionFormula.Organizacion = new OrganizacionInfo
                    {
                        OrganizacionID = seguridad.Usuario.Organizacion.OrganizacionID
                    };

                    var formulaPL = new FormulaPL();

                    var todasFormulas = formulaPL.ObtenerTodos(EstatusEnum.Activo);

                    FormulaInfo formula =
                        todasFormulas.FirstOrDefault(
                            fo =>
                            fo.Descripcion.ToUpper().Trim().Equals(renglon.Formula.ToUpper().Trim(),
                                                                   StringComparison.InvariantCultureIgnoreCase));

                    produccionFormula.Formula                  = formula;
                    produccionFormula.CantidadReparto          = sumatoriameta; //cantidad programada
                    produccionFormula.CantidadProducida        = sumatoriareal; //cantidad real
                    produccionFormula.FechaProduccion          = DateTime.Parse(txtFecha.Text);
                    produccionFormula.Activo                   = EstatusEnum.Activo;
                    produccionFormula.ProduccionFormulaDetalle = listaFormulaDetalle;
                    //produccionFormula.ProduccionFormulaBatch = ListaGlobalDetalleBatch.Where(batch => batch.Formula.ToUpper().Trim().Equals(produccionFormula.Formula.Descripcion.ToUpper().Trim())).ToList();
                    produccionFormula.ProduccionFormulaBatch = listaFormulaProduccionBatch;
                    produccionFormula.UsuarioCreacionId      = seguridad.Usuario.UsuarioID;

                    ListaGlobal.Add(produccionFormula);
                }
            }
            catch (Exception er)
            {
                Logger.Error(er);
                return(null);
            }

            return(resultado);
        }
コード例 #16
0
        /// <summary>
        /// Lectura del archivo datalink
        /// </summary>
        /// <param name="validacion"></param>
        /// <returns></returns>
        internal ResultadoValidacion LeerArchivo(ValidacionDataLink validacion)
        {
            var resultado = new ResultadoValidacion {
                Resultado = true
            };

            validacion.ListaDataLink = new List <DataLinkInfo>();
            try
            {
                Logger.Info();
                var archivo = validacion.RutaArchivo + validacion.NombreArchivo;
                if (Directory.Exists(validacion.RutaArchivo))
                {
                    var linea = string.Empty;

                    if (File.Exists(archivo))
                    {
                        var readerArchivo = new StreamReader(archivo);
                        while (linea != null)
                        {
                            linea = readerArchivo.ReadLine();
                            if (linea != null)
                            {
                                var dataLink = ObtenerDatalink(linea);
                                if (dataLink != null)
                                {
                                    if (!dataLink.CodigoCorral.Contains(Guion))
                                    {
                                        if (dataLink.CodigoCorral.Substring(0, 1).ToUpper() != PeMayuscula)
                                        {
                                            validacion.ListaDataLink.Add(dataLink);
                                        }
                                    }
                                }
                            }
                        }
                        readerArchivo.Close();
                    }
                    else
                    {
                        resultado.Resultado = false;
                        resultado.Mensaje   = ResourceServices.DescargarDataLink_ArchivoNoExiste;
                    }
                }
                else
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.DescargarDataLink_RutaNoExiste;
                }
            }
            catch (ExcepcionGenerica)
            {
                resultado.Resultado = false;
                resultado.Mensaje   = ResourceServices.DescargarDataLink_ErrorInesperado;
                throw;
            }
            catch (Exception ex)
            {
                resultado.Resultado = false;
                resultado.Mensaje   = ResourceServices.DescargarDataLink_ErrorInesperado;
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }
コード例 #17
0
        /// <summary>
        /// Valida el arete al cual se revisara el reimplante
        /// </summary>
        /// <param name="corral">
        /// The corral.
        /// </param>
        /// <returns>
        /// The <see cref="ResultadoValidacion"/>.
        /// </returns>
        /// <exception cref="ExcepcionDesconocida">
        /// </exception>
        internal ResultadoValidacion ValidarArete(AnimalInfo animal, CorralInfo corral)
        {
            try
            {
                var resultado = new ResultadoValidacion();
                var animalBl  = new AnimalBL();

                if (corral == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgFaltaCorral;
                    return(resultado);
                }

                AnimalInfo animalResultado = animalBl.ObtenerAnimalPorArete(animal.Arete, animal.OrganizacionIDEntrada);

                if (animalResultado == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgAreteInvalido;
                    return(resultado);
                }

                AnimalMovimientoInfo movimientos = animalBl.ObtenerUltimoMovimientoAnimal(animalResultado);

                if (movimientos == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgSinMovimientos;
                    return(resultado);
                }

                if (movimientos.CorralID != corral.CorralID)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgCorralDiferente;
                    return(resultado);
                }

                RevisionImplanteInfo revision = ObtenerRevisionDelDia(animalResultado);

                if (revision != null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgYaRevisado.Replace("(ARETE)", animal.Arete);
                    return(resultado);
                }

                resultado.Resultado = true;
                resultado.Control   = animalResultado;
                return(resultado);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #18
0
        /// <summary>
        /// Valida el corral que se le validara el reimplante
        /// </summary>
        /// <param name="corral">
        /// The corral.
        /// </param>
        /// <returns>
        /// The <see cref="ResultadoValidacion"/>.
        /// </returns>
        /// <exception cref="ExcepcionDesconocida">
        /// </exception>
        internal ResultadoValidacion ValidarCorral(CorralInfo corral)
        {
            try
            {
                var        resultado       = new ResultadoValidacion();
                var        corralBl        = new CorralBL();
                CorralInfo corralResultado = corralBl.ObtenerCorralPorCodigo(corral.OrganizacionId, corral.Codigo);
                var        revisionActual  = new RevisionImplanteInfo();
                if (corralResultado == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgCorralNoExiste;
                    return(resultado);
                }

                revisionActual.Corral = corralResultado;
                var loteBl   = new LoteBL();
                var loteInfo = new LoteInfo
                {
                    OrganizacionID = corral.OrganizacionId,
                    CorralID       = corralResultado.CorralID
                };

                var loteResultado = loteBl.ObtenerPorCorralID(loteInfo);
                if (loteResultado == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgLoteInactivo;
                    return(resultado);
                }
                revisionActual.Lote = loteResultado;

                if (loteResultado.TipoCorralID != (int)TipoCorral.Produccion)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgCorralNoProductivo;
                    return(resultado);
                }

                var animalBl = new AnimalBL();
                List <AnimalInfo> animales = animalBl.ObtenerAnimalesPorLote(corral.OrganizacionId, loteResultado.LoteID);

                if (animales == null)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgCorralSinMovimientos;
                    return(resultado);
                }

                if (animales.Count == 0)
                {
                    resultado.Resultado = false;
                    resultado.Mensaje   = ResourceServices.RevisionImplante_msgCorralSinMovimientos;
                    return(resultado);
                }

                resultado.Resultado = true;
                resultado.Control   = revisionActual;
                return(resultado);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
コード例 #19
0
        public static ResultadoValidacion GuardarEntradaProducto(EntradaProductoInfo entradaProducto, int Bandera)
        {
            try
            {
                var productoPl        = new ProductoPL();
                var resultado         = new ResultadoValidacion();
                var boletaRecepcionPl = new BoletaRecepcionForrajePL();
                var seguridad         = HttpContext.Current.Session["Seguridad"] as SeguridadInfo;
                if (seguridad != null)
                {
                    var entradaProductoPl = new EntradaProductoPL();
                    if (entradaProducto.Justificacion == null)
                    {
                        entradaProducto.Organizacion = new OrganizacionInfo {
                            OrganizacionID = seguridad.Usuario.Organizacion.OrganizacionID
                        };

                        entradaProducto.Producto = productoPl.ObtenerPorID(entradaProducto.Producto);
                        var tmpRegistro = new RegistroVigilanciaInfo
                        {
                            Producto     = entradaProducto.Producto,
                            Organizacion = entradaProducto.Organizacion
                        };

                        foreach (EntradaProductoDetalleInfo tmpDetalle in entradaProducto.ProductoDetalle)
                        {
                            var enumIndicador = (IndicadoresEnum)tmpDetalle.Indicador.IndicadorId;

                            foreach (var tmpIndicador in tmpDetalle.ProductoMuestras.Where(mue => mue.EsOrigen == EsOrigenEnum.Destino))
                            {
                                RegistroVigilanciaInfo registroVigelancia = boletaRecepcionPl.ObtenerRangos(tmpRegistro, enumIndicador);
                                if (registroVigelancia == null)
                                {
                                    resultado.Resultado = false;
                                    resultado.Mensaje   = boletaRecepcionPl.ObtenerMensajeRango() + " " + entradaProducto.Producto.ProductoDescripcion;

                                    return(resultado);
                                }
                                if (registroVigelancia.porcentajePromedioMin > tmpIndicador.Porcentaje || registroVigelancia.porcentajePromedioMax < tmpIndicador.Porcentaje)
                                {
                                    Bandera = 2;
                                }
                            }
                        }

                        //Bandera = 1.- Aprobada:2.- Pendiente por Autorizar;3.- Autorizado:
                        entradaProducto.Estatus = new EstatusInfo();

                        if (Bandera == 1)
                        {
                            entradaProducto.Estatus.EstatusId = (int)Estatus.Aprobado;
                        }
                        else
                        {
                            entradaProducto.Estatus.EstatusId = (int)Estatus.PendienteAutorizar;
                        }
                        entradaProducto.PesoBonificacion = 0;
                        var registroVigilanciaPl = new RegistroVigilanciaPL();
                        var registroVigilancia   = new RegistroVigilanciaInfo
                        {
                            FolioTurno   = entradaProducto.RegistroVigilancia.FolioTurno,
                            Organizacion =
                                new OrganizacionInfo {
                                OrganizacionID = seguridad.Usuario.Organizacion.OrganizacionID
                            }
                        };
                        entradaProducto.RegistroVigilancia = registroVigilanciaPl.ObtenerRegistroVigilanciaPorFolioTurno(registroVigilancia);
                        entradaProducto.UsuarioCreacionID  = seguridad.Usuario.UsuarioID;
                        entradaProducto.OperadorAnalista   = new OperadorInfo {
                            OperadorID = seguridad.Usuario.Operador.OperadorID
                        };
                        entradaProducto = entradaProductoPl.GuardarEntradaProducto(entradaProducto, (int)TipoFolio.EntradaProducto);

                        resultado.Resultado = true;
                        resultado.Control   = entradaProducto;
                        return(resultado);
                    }
                    entradaProducto.Organizacion = new OrganizacionInfo {
                        OrganizacionID = seguridad.Usuario.Organizacion.OrganizacionID
                    };
                    entradaProducto.Estatus = new EstatusInfo {
                        EstatusId = (int)Estatus.Autorizado
                    };
                    entradaProducto.UsuarioModificacionID = seguridad.Usuario.UsuarioID;
                    entradaProducto.OperadorAutoriza      = new OperadorInfo {
                        OperadorID = seguridad.Usuario.Operador.OperadorID
                    };
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(null);
        }