Пример #1
0
        /// <summary>
        /// Validar contenido del renglon leido y transformarlo a un objeto
        /// </summary>
        /// <param name="currentWorksheet"></param>
        /// <param name="renglon"></param>
        /// <returns></returns>
        private ConfiguracionFormulaInfo ValidarContenidoDeRenglon(ExcelWorksheet currentWorksheet, int renglon)
        {
            ConfiguracionFormulaInfo configuracionFormulaInfo = null;

            object formula              = currentWorksheet.Cells[renglon, 1].Value;
            object pesoInicioMinimo     = currentWorksheet.Cells[renglon, 2].Value;
            object pesoInicioMaximo     = currentWorksheet.Cells[renglon, 3].Value;
            object tipoGanado           = currentWorksheet.Cells[renglon, 4].Value;
            object pesoSalida           = currentWorksheet.Cells[renglon, 5].Value;
            object formulaSiguiente     = currentWorksheet.Cells[renglon, 6].Value;
            object diasEstanciaMinimo   = currentWorksheet.Cells[renglon, 7].Value;
            object diasEstanciaMaximo   = currentWorksheet.Cells[renglon, 8].Value;
            object diasTransicionMinimo = currentWorksheet.Cells[renglon, 9].Value;
            object diasTransicionMaximo = currentWorksheet.Cells[renglon, 10].Value;
            object disponibilidad       = currentWorksheet.Cells[renglon, 11].Value;

            if (
                (formula != null) && (pesoInicioMinimo != null) && (pesoInicioMaximo != null) &&
                (tipoGanado != null) && (pesoSalida != null) && (formulaSiguiente != null) &&
                (diasEstanciaMinimo != null) && (diasEstanciaMaximo != null) &&
                (diasTransicionMinimo != null) &&
                (diasTransicionMaximo != null) && (disponibilidad != null)
                )
            {
                var formulaBL = new FormulaBL();

                try
                {
                    configuracionFormulaInfo = new ConfiguracionFormulaInfo
                    {
                        Formula              = formulaBL.ObtenerPorDescripcion(formula.ToString()),
                        PesoInicioMinimo     = Convert.ToInt32(pesoInicioMinimo.ToString()),
                        PesoInicioMaximo     = Convert.ToInt32(pesoInicioMaximo.ToString()),
                        TipoGanado           = tipoGanado.ToString(),
                        PesoSalida           = Convert.ToInt32(pesoSalida.ToString()),
                        FormulaSiguiente     = formulaBL.ObtenerPorDescripcion(formulaSiguiente.ToString()),
                        DiasEstanciaMinimo   = Convert.ToInt32(diasEstanciaMinimo.ToString()),
                        DiasEstanciaMaximo   = Convert.ToInt32(diasEstanciaMaximo.ToString()),
                        DiasTransicionMinimo = Convert.ToInt32(diasTransicionMinimo.ToString()),
                        DiasTransicionMaximo = Convert.ToInt32(diasTransicionMaximo.ToString()),
                        Disponibilidad       = disponibilidad.ToString() == Disponibilidad.Si.ToString()
                            ? Disponibilidad.Si
                            : Disponibilidad.No
                    };
                }
                catch (Exception ex)
                {
                    Logger.Error(ex);
                    throw new ExcepcionDesconocida(ResourceServices.ConfigurarFormula_ValoresFormatoCorrecto);
                }
            }
            else
            {
                throw new ExcepcionDesconocida(ResourceServices.ConfigurarFormula_DatosEnBlanco);
            }
            return(configuracionFormulaInfo);
        }
Пример #2
0
        /// <summary>
        /// Metodo para exportar la configuracion de formulas de una organizacion
        /// </summary>
        /// <param name="configuracionFormulaExportar"></param>
        /// <returns></returns>
        public bool ExportarArchivo(ConfiguracionFormulaInfo configuracionFormulaExportar)
        {
            bool importarArchivo = false;

            try
            {
                Logger.Info();
                var configuracionFormulaDAL = new ConfiguracionFormulaDAL();
                var formulaBL = new FormulaBL();

                IList <ConfiguracionFormulaInfo> configuracionFormulaInfoLista =
                    configuracionFormulaDAL.ObtenerConfiguracionFormula(configuracionFormulaExportar.OrganizacionID);

                if (configuracionFormulaInfoLista != null)
                {
                    // Se inicia la transaccion
                    using (var transaction = new TransactionScope())
                    {
                        //Se obtiene info separada
                        foreach (var configuracion in configuracionFormulaInfoLista)
                        {
                            //Se obtienen las descripciones de las formulas
                            configuracion.Formula = formulaBL.ObtenerPorID(configuracion.Formula.FormulaId);
                            //Se obtienen las descripciones de las formulas
                            configuracion.FormulaSiguiente = formulaBL.ObtenerPorID(configuracion.FormulaSiguiente.FormulaId);
                        }
                        transaction.Complete();
                    }
                }

                //Se genera el archivo excel pero con solo los titulos
                importarArchivo = GenerarArchivo(configuracionFormulaInfoLista, configuracionFormulaExportar);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(importarArchivo);
        }
 /// <summary>
 /// Obtiene el listado de organizaciones que se han registrado del dia
 /// </summary>
 /// <returns></returns>
 internal List <InterfaceSalidaTraspasoInfo> ObtenerListaInterfaceSalidaTraspaso()
 {
     try
     {
         var interfaceSalidaTraspaspBl = new InterfaceSalidaTraspasoDAL();
         var listado = interfaceSalidaTraspaspBl.ObtenerListaInterfaceSalidaTraspaso();
         if (listado != null)
         {
             foreach (var interfaceSalidaTraspasoInfo in listado)
             {
                 if (interfaceSalidaTraspasoInfo.OrganizacionDestino != null)
                 {
                     var organizacionBl = new OrganizacionBL();
                     interfaceSalidaTraspasoInfo.OrganizacionDestino =
                         organizacionBl.ObtenerPorID(
                             interfaceSalidaTraspasoInfo.OrganizacionDestino.OrganizacionID);
                 }
                 if (interfaceSalidaTraspasoInfo.Formula != null)
                 {
                     var formulaBl = new FormulaBL();
                     interfaceSalidaTraspasoInfo.Formula = formulaBl.ObtenerPorID(interfaceSalidaTraspasoInfo.Formula.FormulaId);
                 }
                 if (interfaceSalidaTraspasoInfo.TipoGanado != null)
                 {
                     var tipoGanadoBl = new TipoGanadoBL();
                     interfaceSalidaTraspasoInfo.TipoGanado =
                         tipoGanadoBl.ObtenerPorID(interfaceSalidaTraspasoInfo.TipoGanado.TipoGanadoID);
                     interfaceSalidaTraspasoInfo.Sexo = interfaceSalidaTraspasoInfo.TipoGanado.Sexo;
                 }
             }
         }
         return(listado);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Пример #4
0
        /// <summary>
        /// Obtiene un ingrediente con su detalle
        /// Activo - Solo activos
        /// Inactivo - Solo inactivos
        /// Todos - Ambos
        /// </summary>
        /// <returns>IngredienteInfo</returns>
        internal IngredienteInfo ObtenerPorId(IngredienteInfo ingrediente, EstatusEnum estatus)
        {
            try
            {
                var ingredienteDal = new IngredienteDAL();
                ingrediente = ingredienteDal.ObtenerPorId(ingrediente, estatus);

                if (ingrediente != null)
                {
                    if (ingrediente.Organizacion.OrganizacionID > 0)
                    {
                        var organizacionBl = new OrganizacionBL();
                        ingrediente.Organizacion = organizacionBl.ObtenerPorID(ingrediente.Organizacion.OrganizacionID);
                    }
                    if (ingrediente.Formula.FormulaId > 0)
                    {
                        var formulaBl = new FormulaBL();
                        ingrediente.Formula = formulaBl.ObtenerPorID(ingrediente.Formula.FormulaId);
                    }

                    if (ingrediente.Producto.ProductoId > 0)
                    {
                        var productoBl = new ProductoBL();
                        ingrediente.Producto = productoBl.ObtenerPorID(ingrediente.Producto);
                    }
                }
            }
            catch (ExcepcionDesconocida)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }

            return(ingrediente);
        }
Пример #5
0
        /// <summary>
        /// Metodo para generar el archivo excel
        /// </summary>
        /// <param name="configuracionFormulaInfoLista"></param>
        /// <param name="configuracionFormulaExportar"></param>
        /// <returns></returns>
        private bool GenerarArchivo(IList <ConfiguracionFormulaInfo> configuracionFormulaInfoLista,
                                    ConfiguracionFormulaInfo configuracionFormulaExportar)
        {
            bool resp = false;

            try
            {
                Logger.Info();
                string file = configuracionFormulaExportar.NombreArchivo;
                if (File.Exists(file))
                {
                    try
                    {
                        File.Delete(file);
                    }
                    catch (Exception ex)
                    {
                        Logger.Error(ex);
                        throw new ExcepcionDesconocida(ResourceServices.ConfigurarFormula_ArchivoEnUso);
                    }
                }
                var newFile = new FileInfo(file);

                using (var pck = new ExcelPackage(newFile))
                {
                    // get the handle to the existing worksheet
                    var wsData = pck.Workbook.Worksheets.Add(ResourceServices.ConfigurarFormula_TituloExcel);

                    wsData.Cells["A1"].Value = ResourceServices.ConfigurarFormula_TituloExcel;

                    using (ExcelRange r = wsData.Cells["A1:K1"])
                    {
                        r.Merge = true;
                        r.Style.Font.SetFromFont(new Font("Arial Bold", 16, FontStyle.Regular));
                        r.Style.Font.Color.SetColor(Color.White);
                        r.Style.HorizontalAlignment = ExcelHorizontalAlignment.CenterContinuous;
                        r.Style.Fill.PatternType    = ExcelFillStyle.Solid;
                        r.Style.Fill.BackgroundColor.SetColor(Color.FromArgb(255, 178, 34, 34));
                    }

                    ExcelRangeBase dataRange;
                    if (configuracionFormulaInfoLista == null ||
                        configuracionFormulaInfoLista.Count <= 0)
                    {
                        var configuracionFormulaInfo = new ConfiguracionFormulaInfo
                        {
                            Formula = new FormulaInfo {
                                Descripcion = ""
                            },
                            PesoInicioMinimo = 0,
                            PesoInicioMaximo = 0,
                            TipoGanado       = "",
                            PesoSalida       = 0,
                            FormulaSiguiente = new FormulaInfo {
                                Descripcion = ""
                            },
                            DiasEstanciaMinimo   = 0,
                            DiasEstanciaMaximo   = 0,
                            DiasTransicionMinimo = 0,
                            DiasTransicionMaximo = 0,
                            Disponibilidad       = Disponibilidad.No
                        };
                        configuracionFormulaInfoLista = new List <ConfiguracionFormulaInfo> {
                            configuracionFormulaInfo
                        };

                        dataRange = wsData.Cells["A2"].LoadFromCollection(
                            from s in configuracionFormulaInfoLista
                            orderby s.ConfiguracionFormulaID
                            select new
                        {
                            Fórmula                = s.Formula.Descripcion,
                            Peso_Inicio_Mínimo     = s.PesoInicioMinimo,
                            Peso_Inicio_Máximo     = s.PesoInicioMaximo,
                            Tipo_Ganado            = s.TipoGanado,
                            Peso_Salida            = s.PesoSalida,
                            Fórmula_Siguiente      = s.FormulaSiguiente.Descripcion,
                            Días_Estancia_Mínimo   = s.DiasEstanciaMinimo,
                            Días_Estancia_Máximo   = s.DiasEstanciaMaximo,
                            Días_Transición_Mínimo = s.DiasTransicionMinimo,
                            Días_Transición_Máximo = s.DiasTransicionMaximo,
                            Disponibilidad         = s.Disponibilidad
                        },
                            true, TableStyles.None);
                    }
                    else
                    {
                        dataRange = wsData.Cells["A2"].LoadFromCollection(
                            from s in configuracionFormulaInfoLista
                            orderby s.ConfiguracionFormulaID
                            select new
                        {
                            Fórmula                = s.Formula.Descripcion,
                            Peso_Inicio_Mínimo     = s.PesoInicioMinimo,
                            Peso_Inicio_Máximo     = s.PesoInicioMaximo,
                            Tipo_Ganado            = s.TipoGanado,
                            Peso_Salida            = s.PesoSalida,
                            Fórmula_Siguiente      = s.FormulaSiguiente.Descripcion,
                            Días_Estancia_Mínimo   = s.DiasEstanciaMinimo,
                            Días_Estancia_Máximo   = s.DiasEstanciaMaximo,
                            Días_Transición_Mínimo = s.DiasTransicionMinimo,
                            Días_Transición_Máximo = s.DiasTransicionMaximo,
                            Disponibilidad         = s.Disponibilidad,
                        },
                            true, TableStyles.None);
                    }

                    using (ExcelRange r = wsData.Cells["A2:K2"])
                    {
                        r.Style.VerticalAlignment   = ExcelVerticalAlignment.Center;
                        r.Style.HorizontalAlignment = ExcelHorizontalAlignment.Center;
                        r.Style.Font.SetFromFont(new Font("Arial Bold", 11, FontStyle.Regular));
                        r.Style.Font.Color.SetColor(Color.White);
                        r.Style.Fill.PatternType = ExcelFillStyle.Solid;
                        r.Style.Fill.BackgroundColor.SetColor(Color.FromArgb(255, 178, 34, 34));
                    }

                    IList <FormulaInfo> formulasList = new List <FormulaInfo>();
                    var formulasBL = new FormulaBL();
                    formulasList = formulasBL.ObtenerTodos();

                    IList <Disponibilidad> disponibilidadEnums =
                        Enum.GetValues(typeof(Disponibilidad)).Cast <Disponibilidad>().OrderByDescending(x => x.ToString()).ToList();

                    if (formulasList != null && formulasList.Count > 0)
                    {
                        var celdasValidacionFormulas = String.Format("{0}{1}", "A3:A", configuracionFormulaInfoLista.Count + 2);
                        AsignarValidacionFormulas(celdasValidacionFormulas,
                                                  wsData,
                                                  formulasList);

                        celdasValidacionFormulas = String.Format("{0}{1}", "F3:F", configuracionFormulaInfoLista.Count + 2);
                        AsignarValidacionFormulas(celdasValidacionFormulas,
                                                  wsData,
                                                  formulasList);

                        celdasValidacionFormulas = String.Format("{0}{1}", "K3:K", configuracionFormulaInfoLista.Count + 2);
                        AsignarValidacionFormulas(celdasValidacionFormulas,
                                                  wsData,
                                                  disponibilidadEnums);

                        AgregarComentarios(wsData, configuracionFormulaInfoLista);
                    }

                    AgregarPestañaTipoGanado(pck);

                    dataRange.AutoFitColumns();

                    pck.Save();
                }
                resp = true;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(resp);
        }
        /// <summary>
        /// Carga el archivo data link en la orden de reparto
        /// </summary>
        /// <param name="validacionDatalink"></param>
        /// <param name="usuario"></param>
        /// <returns></returns>
        internal ResultadoOperacion CargarArchivoDatalink(ValidacionDataLink validacionDatalink, UsuarioInfo usuario)
        {
            var validar   = new DataLinkInfo();
            var resultado = new ResultadoOperacion {
                Resultado = true
            };

            try
            {
                Logger.Info();
                var corralBl  = new CorralBL();
                var loteBl    = new LoteBL();
                var repartoBl = new RepartoBL();
                using (var camionRepartoBl = new CamionRepartoBL())
                {
                    var servicioAlimentoBL           = new ServicioAlimentoBL();
                    var datalinks                    = new List <DataLinkInfo>();
                    var repartosServicioAlimentacion = new List <RepartoInfo>();
                    var repartosDetalles             = new List <RepartoDetalleInfo>();
                    var corralesEliminar             = new List <CorralInfo>();

                    var formulaBL = new FormulaBL();
                    IList <FormulaInfo> formulasExistentes = formulaBL.ObtenerTodos(EstatusEnum.Activo);

                    IList <CamionRepartoInfo> camionesRepartoOrganizacion =
                        camionRepartoBl.ObtenerPorOrganizacionID(usuario.Organizacion.OrganizacionID);

                    foreach (var dataLink in validacionDatalink.ListaDataLink)
                    {
                        validar = dataLink;

                        //CamionRepartoInfo camionRepartoInfo = camionRepartoBl.ObtenerPorNumeroEconomico(dataLink.NumeroCamion.Trim(), usuario.Organizacion.OrganizacionID);
                        CamionRepartoInfo camionRepartoInfo =
                            camionesRepartoOrganizacion.FirstOrDefault(
                                cam =>
                                cam.NumeroEconomico.Equals(dataLink.NumeroCamion.Trim(),
                                                           StringComparison.CurrentCultureIgnoreCase));
                        dataLink.CamionReparto = camionRepartoInfo;
                        CorralInfo corral = corralBl.ObtenerPorCodicoOrganizacionCorral(new CorralInfo
                        {
                            Codigo       = dataLink.CodigoCorral,
                            Organizacion = new OrganizacionInfo {
                                OrganizacionID = usuario.Organizacion.OrganizacionID
                            },
                            Activo = EstatusEnum.Activo,
                        });
                        if (corral != null)
                        {
                            var lote = loteBl.ObtenerPorCorralCerrado(usuario.Organizacion.OrganizacionID, corral.CorralID);
                            if (lote == null)
                            {
                                lote = new LoteInfo();
                            }
                            //if (lote != null)
                            //{

                            var fecha   = ObtenerFecha(dataLink.CadenaFechaReparto);
                            var reparto = repartoBl.ObtenerRepartoPorFechaCorralServicio(fecha, corral, dataLink.TipoServicio);
                            if (reparto != null)
                            {
                                //var formulaBl = new FormulaBL();
                                //int formulaId;
                                //int.TryParse(dataLink.ClaveFormula, out formulaId);
                                var formula = formulasExistentes.FirstOrDefault(fo => fo.Descripcion.Equals(dataLink.ClaveFormula.Trim(), StringComparison.CurrentCultureIgnoreCase));
                                if (formula != null)
                                {
                                    dataLink.FormulaServida = formula;
                                    dataLink.Reparto        = reparto;
                                    dataLink.UsuarioID      = usuario.UsuarioID;
                                    dataLink.OrganizacionID = usuario.Organizacion.OrganizacionID;
                                    datalinks.Add(dataLink);
                                }
                            }
                            //Si el Lote no se encuentra en el Reparto, buscarlo en la tabla ServicioAlimento
                            else
                            {
                                ServicioAlimentoInfo servicioAlimentoInfo =
                                    servicioAlimentoBL.ObtenerPorCorralID(usuario.Organizacion.OrganizacionID,
                                                                          corral.CorralID);

                                if (servicioAlimentoInfo != null)
                                {
                                    LoteDescargaDataLinkModel datosLote =
                                        loteBl.ObtenerLoteDataLink(usuario.Organizacion.OrganizacionID, lote.LoteID);

                                    if (datosLote == null)
                                    {
                                        datosLote = new LoteDescargaDataLinkModel
                                        {
                                            PesoInicio  = 0,
                                            FechaInicio = fecha,
                                            Cabezas     = 0,
                                        };
                                    }


                                    //var formulaBl = new FormulaBL();
                                    //int formulaId;
                                    //int.TryParse(dataLink.ClaveFormula, out formulaId);
                                    //var formula = formulaBl.ObtenerPorID(formulaId);
                                    var formula = formulasExistentes.FirstOrDefault(fo => fo.Descripcion.Equals(dataLink.ClaveFormula.Trim(), StringComparison.CurrentCultureIgnoreCase));
                                    if (formula != null)
                                    {
                                        var repartoNuevo = new RepartoInfo
                                        {
                                            OrganizacionID    = usuario.Organizacion.OrganizacionID,
                                            LoteID            = lote.LoteID,
                                            Corral            = corral,
                                            Fecha             = fecha,
                                            PesoInicio        = datosLote.PesoInicio,
                                            PesoProyectado    = 0,
                                            DiasEngorda       = Convert.ToInt32((fecha - datosLote.FechaInicio).TotalDays),
                                            PesoRepeso        = 0,
                                            DetalleReparto    = new List <RepartoDetalleInfo>(),
                                            UsuarioCreacionID = usuario.UsuarioID,
                                            Activo            = EstatusEnum.Activo
                                        };

                                        var detalleReparto = new RepartoDetalleInfo
                                        {
                                            TipoServicioID      = dataLink.TipoServicio,
                                            FormulaIDProgramada = servicioAlimentoInfo.FormulaID,
                                            FormulaIDServida    = formula.FormulaId,
                                            CantidadProgramada  = servicioAlimentoInfo.KilosProgramados,
                                            CantidadServida     = dataLink.KilosServidos,
                                            HoraReparto         = dataLink.Hora,
                                            CostoPromedio       = 0,
                                            Importe             = 0,
                                            Servido             = true,
                                            Cabezas             = datosLote.Cabezas == 0 ? 1 : datosLote.Cabezas,
                                            EstadoComederoID    = EstadoComederoEnum.Normal.GetHashCode(),
                                            CamionRepartoID     = dataLink.CamionReparto.CamionRepartoID,
                                            UsuarioCreacionID   = usuario.UsuarioID,
                                            Activo = EstatusEnum.Activo
                                        };
                                        repartoNuevo.DetalleReparto.Add(detalleReparto);

                                        repartosServicioAlimentacion.Add(repartoNuevo);

                                        var corralEliminar = new CorralInfo
                                        {
                                            CorralID = corral.CorralID,
                                            UsuarioModificacionID = usuario.UsuarioID
                                        };
                                        corralesEliminar.Add(corralEliminar);
                                    }
                                }
                            }
                            //}
                            //else
                            //{
                            //    var bitacoraBL = new BitacoraIncidenciasBL();
                            //    var errorInfo = new BitacoraErroresInfo
                            //        {
                            //            AccionesSiapID = AccionesSIAPEnum.DeDataLink,
                            //            Mensaje = "No es posible aplicar el consumo para el corral: " + corral.Codigo,
                            //            UsuarioCreacionID = usuario.UsuarioID
                            //        };

                            //    //DescargarArchivoDataLink
                            //    bitacoraBL.GuardarError(errorInfo);
                            //}
                        }
                    }
                    if (datalinks.Count > 0)
                    {
                        if (datalinks.Any(x => x.CamionReparto == null))
                        {
                            resultado.Resultado          = false;
                            resultado.DescripcionMensaje = ResourceServices.DescargaDataLink_msgCamionNoAsignado;
                        }
                        else
                        {
                            using (var transaccion = new TransactionScope())
                            {
                                if (repartosServicioAlimentacion.Any())
                                {
                                    foreach (var repartoInfo in repartosServicioAlimentacion)
                                    {
                                        int repartoID = repartoBl.Guardar(repartoInfo);
                                        repartoInfo.DetalleReparto.ToList().ForEach(rep => rep.RepartoID = repartoID);
                                        repartosDetalles.AddRange(repartoInfo.DetalleReparto);
                                    }
                                    repartoBl.GuardarRepartoDetalle(repartosDetalles);
                                    if (corralesEliminar.Any())
                                    {
                                        servicioAlimentoBL.EliminarXML(corralesEliminar);
                                    }
                                }

                                var res = repartoBl.CargarArchivoDatalink(datalinks);
                                resultado.RegistrosAfectados = res;
                                resultado.DescripcionMensaje = ResourceServices.DescargarDataLink_GuradadoOk;
                                transaccion.Complete();
                            }

                            RenombrarArchivos(validacionDatalink);
                        }
                    }
                    else
                    {
                        resultado.Resultado          = false;
                        resultado.DescripcionMensaje = ResourceServices.DescargarDataLink_NoSecargo;
                    }
                }
            }
            catch (ExcepcionGenerica)
            {
                if (validar != null)
                {
                }
                resultado.Resultado = false;
                throw;
            }
            catch (Exception ex)
            {
                if (validar != null)
                {
                }
                resultado.Resultado = false;
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(resultado);
        }