/// <summary>
        ///
        /// </summary>
        /// <param name="Indice"></param>
        /// <returns></returns>
        public bool EliminarIndicador(long Indice, bool EsHistorico)
        {
            if (EsHistorico)
            {
                Indicador indicadorBD = db.Indicador.Find(Indice);

                if (indicadorBD == null)
                {
                    return(false);
                }

                db.Indicador.Remove(indicadorBD);
                db.SaveChanges();
            }
            else
            {
                Indicador_V2 indicadorBD = db.Indicador_V2.Find(Indice);

                if (indicadorBD == null)
                {
                    return(false);
                }

                db.Indicador_V2.Remove(indicadorBD);
                db.SaveChanges();
            }

            return(true);
        }
        ///// <summary>
        /////
        ///// </summary>
        ///// <param name="DatosIndicador"></param>
        ///// <returns></returns>
        //public bool InsertarIndicador(IndicadorModel DatosIndicador)
        //{
        //    bool Estado = false;

        //    try
        //    {
        //        Indicador_V2 IndicadorBD = new Indicador_V2()
        //        {
        //            Fecha = DatosIndicador.Fecha,
        //            Orden = DatosIndicador.Orden,
        //            Lote = DatosIndicador.Lote,
        //            Maquina = DatosIndicador.Piezas.ToString(),
        //            Reales = DatosIndicador.Reales,
        //            Ciclo = DatosIndicador.Ciclo.ToString(),
        //            Turno = string.IsNullOrEmpty(DatosIndicador.Turno) ? null : DatosIndicador.Turno,
        //            Material = string.IsNullOrEmpty(DatosIndicador.Material) ? null : DatosIndicador.Material,
        //            Descripcion = string.IsNullOrEmpty(DatosIndicador.DescripcionMaterial) ? null : DatosIndicador.DescripcionMaterial,
        //            IndiceVelocidad = DatosIndicador.IndiceVelocidad > 0 ? (long?)null : DatosIndicador.IndiceVelocidad,
        //            IndiceProceso = DatosIndicador.IndiceProceso
        //        };

        //        foreach (RechazoModel Rechazo in DatosIndicador.Rechazos)
        //        {
        //            IndicadorRechazo_V2 IndicadorRechazo = new IndicadorRechazo_V2()
        //            {
        //                IndiceRechazo = Rechazo.Indice,
        //                Cantidad = Rechazo.Cantidad
        //            };

        //            IndicadorBD.IndicadorRechazo_V2.Add(IndicadorRechazo);
        //        }

        //        foreach (ParoModel Paro in DatosIndicador.Paros)
        //        {
        //            IndicadorParo_V2 IndicadorParo = new IndicadorParo_V2()
        //            {
        //                IndiceParo = Paro.Indice,
        //                Cantidad = Paro.Cantidad,
        //                Folio = Paro.Folio,
        //                EsParoPlanificado = Paro.EsParoPlanificado
        //            };

        //            IndicadorBD.IndicadorParo_V2.Add(IndicadorParo);
        //        }

        //        db.Indicador_V2.Add(IndicadorBD);
        //        db.SaveChanges();

        //        Estado = true;

        //        bool EstadoIndicadorTiempo = IndicadorTiempoBusiness.ActualizarIndicadorTiempo(DatosIndicador.IndiceProceso, DatosIndicador.Fecha);
        //    }
        //    catch (Exception)
        //    {

        //    }

        //    return Estado;
        //}

        /// <summary>
        ///
        /// </summary>
        /// <param name="Indice"></param>
        /// <param name="DatosIndicador"></param>
        /// <returns></returns>
        public bool EditarIndicador(long Indice, IndicadorModel DatosIndicador)
        {
            Indicador_V2 indicadorBD = db.Indicador_V2.Find(Indice);

            if (indicadorBD == null)
            {
                return(false);
            }

            indicadorBD.Fecha           = DatosIndicador.Fecha;
            indicadorBD.Orden           = DatosIndicador.Orden;
            indicadorBD.Lote            = DatosIndicador.Lote;
            indicadorBD.Maquina         = DatosIndicador.Piezas.ToString();
            indicadorBD.Reales          = DatosIndicador.Reales;
            indicadorBD.Ciclo           = DatosIndicador.Ciclo.ToString();
            indicadorBD.Turno           = string.IsNullOrEmpty(DatosIndicador.Turno) ? null : DatosIndicador.Turno;
            indicadorBD.Material        = string.IsNullOrEmpty(DatosIndicador.Material) ? null : DatosIndicador.Material;
            indicadorBD.Descripcion     = string.IsNullOrEmpty(DatosIndicador.DescripcionMaterial) ? null : DatosIndicador.DescripcionMaterial;
            indicadorBD.IndiceVelocidad = DatosIndicador.IndiceVelocidad > 0 ? (long?)null : DatosIndicador.IndiceVelocidad;
            indicadorBD.IndiceProceso   = DatosIndicador.IndiceProceso;

            db.Entry(indicadorBD).State = EntityState.Modified;
            db.SaveChanges();

            return(true);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="Indice"></param>
        /// <returns></returns>
        public IndicadorModel ObtenerIndicador(long Indice, bool EsHistorico)
        {
            IndicadorModel DatosIndicador = null;

            if (EsHistorico)
            {
                Indicador IndicadorV1 = db.Indicador.Find(Indice);

                if (IndicadorV1 != null)
                {
                    DatosIndicador = Util.ConvertirObjetoIndicadorAModeloHistorico(IndicadorV1, 0, 0, 0, 0);
                }
                else
                {
                    return(null);
                }
            }
            else
            {
                Indicador_V2 IndicadorV2 = db.Indicador_V2.Find(Indice);

                if (IndicadorV2 != null)
                {
                    DatosIndicador = Util.ConvertirObjetoIndicadorAModelo(IndicadorV2, 0, 0, 0, 0);
                }
                else
                {
                    return(null);
                }
            }

            return(DatosIndicador);
        }
Ejemplo n.º 4
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="indicadorBD"></param>
        /// <param name="IndiceCentro"></param>
        /// <param name="IndiceDepartamento"></param>
        /// <param name="IndiceLinea"></param>
        /// <param name="IndiceProceso"></param>
        /// <returns></returns>
        public static IndicadorModel ConvertirObjetoIndicadorAModelo(Indicador_V2 indicadorBD, long IndiceCentro, long IndiceDepartamento, long IndiceLinea, long IndiceProceso)
        {
            IndicadorModel Indicador = new IndicadorModel()
            {
                Indice             = indicadorBD.Indice,
                IndiceCentro       = IndiceCentro,
                IndiceDepartamento = IndiceDepartamento,
                IndiceLinea        = IndiceLinea,
                IndiceProceso      = indicadorBD.IndiceProceso.GetValueOrDefault(),
                Orden               = indicadorBD.Orden,
                Lote                = indicadorBD.Lote,
                Material            = indicadorBD.Material,
                DescripcionMaterial = indicadorBD.Descripcion,
                IndiceVelocidad     = indicadorBD.IndiceVelocidad.GetValueOrDefault(),
                Reales              = indicadorBD.Reales,
                Piezas              = int.Parse(string.IsNullOrEmpty(indicadorBD.Maquina) ? "0" : indicadorBD.Maquina),
                Fecha               = indicadorBD.Fecha.GetValueOrDefault(),
                Hora                = indicadorBD.Fecha.GetValueOrDefault().Hour,
                Minuto              = indicadorBD.Fecha.GetValueOrDefault().Minute,
                Turno               = indicadorBD.Turno,
                Ciclo               = int.Parse(string.IsNullOrEmpty(indicadorBD.Ciclo) ? "0" : indicadorBD.Ciclo),
                ListaParos          = indicadorBD.IndicadorParo_V2.ToList().Select(c => new ParoModel {
                    Indice = c.IndiceParo, Cantidad = c.Cantidad, Folio = c.Folio, EsParoPlanificado = c.EsParoPlanificado
                }).ToList(),
                ListaRechazos = indicadorBD.IndicadorRechazo_V2.ToList().Select(c => new RechazoModel {
                    Indice = c.IndiceRechazo, Cantidad = c.Cantidad
                }).ToList(),
            };

            return(Indicador);
        }
        public long CrearIndicador(IndicadorModel modelo)
        {
            long IndiceIndicador = 0;

            var FechaInicial = modelo.Fecha;
            var FechaFinal   = FechaInicial.AddMinutes(modelo.Ciclo);

            bool ExisteIndicadorPeriodoTiempo = BusquedaIndicadoresPeriodo(modelo.IndiceProceso, FechaInicial, FechaFinal);

            if (ExisteIndicadorPeriodoTiempo)
            {
                IndiceIndicador = -1;
            }
            else
            {
                Indicador_V2 Indicador = new Indicador_V2
                {
                    IndiceVelocidad = modelo.IndiceVelocidad,
                    IndiceProceso   = modelo.IndiceProceso,
                    Orden           = modelo.Orden,
                    Lote            = modelo.Lote,
                    Maquina         = "" + modelo.Piezas,
                    Material        = modelo.Material,
                    Descripcion     = modelo.DescripcionMaterial,
                    Reales          = modelo.Reales,
                    Fecha           = modelo.Fecha,
                    Turno           = modelo.Turno,
                    Ciclo           = "" + modelo.Ciclo
                };

                db.Indicador_V2.Add(Indicador);
                db.SaveChanges();

                IndiceIndicador = Indicador.Indice;
            }

            return(IndiceIndicador);
        }
        public IndicadorModel ObtenerIndicadorPorProceso(long IndiceProceso)
        {
            IndicadorModel indicador = null;

            Indicador_V2 IndicadorV2 = null;
            Indicador    IndicadorV1 = null;

            IndicadorV2 = db.Indicador_V2
                          .Where(columna => columna.IndiceProceso == IndiceProceso)
                          .OrderByDescending(columna => columna.Fecha)
                          .FirstOrDefault();

            if (IndicadorV2 == null)
            {
                IndicadorV1 = db.Indicador
                              .Where(columna => columna.id_proceso == IndiceProceso)
                              .OrderByDescending(columna => columna.fecha_hora)
                              .FirstOrDefault();

                if (IndicadorV1 != null)
                {
                    indicador = new IndicadorModel()
                    {
                        Indice              = IndicadorV1.id_indicador,
                        Orden               = IndicadorV1.orden,
                        Lote                = IndicadorV1.lote,
                        Material            = IndicadorV1.material,
                        DescripcionMaterial = IndicadorV1.descripcion,
                        IndiceVelocidad     = 0,
                        Velocidad           = string.Empty,
                        Dia    = IndicadorV1.fecha_hora.GetValueOrDefault().Day,
                        Mes    = IndicadorV1.fecha_hora.GetValueOrDefault().Month,
                        Año    = IndicadorV1.fecha_hora.GetValueOrDefault().Year,
                        Hora   = IndicadorV1.fecha_hora.GetValueOrDefault().Hour,
                        Minuto = IndicadorV1.fecha_hora.GetValueOrDefault().Minute,
                        Turno  = IndicadorV1.turno,
                        Ciclo  = Convert.ToInt32(IndicadorV1.ciclo)
                    };
                }
                else
                {
                    DateTime Fecha = DateTime.Now;
                    indicador = new IndicadorModel()
                    {
                        Indice              = 0,
                        Orden               = string.Empty,
                        Lote                = string.Empty,
                        Material            = string.Empty,
                        DescripcionMaterial = string.Empty,
                        IndiceVelocidad     = 0,
                        Velocidad           = string.Empty,
                        Dia    = Fecha.Day,
                        Mes    = Fecha.Month,
                        Año    = Fecha.Year,
                        Hora   = 0,
                        Minuto = 0,
                        Turno  = string.Empty,
                        Ciclo  = 0
                    };
                }
            }
            else
            {
                indicador = new IndicadorModel()
                {
                    Indice              = IndicadorV2.Indice,
                    Orden               = IndicadorV2.Orden,
                    Lote                = IndicadorV2.Lote,
                    Material            = IndicadorV2.Material,
                    DescripcionMaterial = IndicadorV2.Descripcion,
                    IndiceVelocidad     = IndicadorV2.IndiceVelocidad.GetValueOrDefault(),
                    Velocidad           = string.Empty,
                    Dia    = IndicadorV2.Fecha.GetValueOrDefault().Day,
                    Mes    = IndicadorV2.Fecha.GetValueOrDefault().Month,
                    Año    = IndicadorV2.Fecha.GetValueOrDefault().Year,
                    Hora   = IndicadorV2.Fecha.GetValueOrDefault().Hour,
                    Minuto = IndicadorV2.Fecha.GetValueOrDefault().Minute,
                    Turno  = IndicadorV2.Turno,
                    Ciclo  = Convert.ToInt32(IndicadorV2.Ciclo)
                };
            }

            return(indicador);
        }