Exemple #1
0
        /// <summary>
        ///     Obtiene parametros para crear
        /// </summary>
        /// <param name="costoInfo"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametrosGuardado(CostoInfo costoInfo)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@Descripcion", costoInfo.Descripcion },
                    { "@Activo", costoInfo.Activo },
                    { "@TipoCostoID", costoInfo.TipoCosto.TipoCostoID },
                    { "@TipoProrrateoID", costoInfo.TipoProrrateo.TipoProrrateoID },
                    { "@ClaveContable", costoInfo.ClaveContable },
                    { "@RetencionID", costoInfo.Retencion.RetencionID == 0 ? null : costoInfo.Retencion.RetencionID },
                    { "@AbonoA", costoInfo.AbonoA.ToString() },
                    { "@UsuarioCreacionID", costoInfo.UsuarioCreacionID },
                    { "@CompraIndividual", costoInfo.CompraIndividual },
                    { "@Compra", costoInfo.Compra },
                    { "@Recepcion", costoInfo.Recepcion },
                    { "@Gasto", costoInfo.Gasto },
                    { "@Costo", costoInfo.Costo },
                    { "@TipoCostoIDCentro", costoInfo.TipoCostoCentro.TipoCostoCentroID == 0 ? null : costoInfo.TipoCostoCentro.TipoCostoCentroID }
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }

            return(parametros);
        }
Exemple #2
0
        /// <summary>
        ///     Obtiene un TipoCostoInfo por Id
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal CostoInfo ObtenerPorClaveContableTipoCosto(CostoInfo filtro)
        {
            CostoInfo info;

            try
            {
                Logger.Info();
                var costoDAL = new CostoDAL();
                info = costoDAL.ObtenerPorClaveContableTipoCosto(filtro);
                if (info == null)
                {
                    return(null);
                }
                info.ListaTipoCostos = filtro.ListaTipoCostos;
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(info);
        }
Exemple #3
0
 /// <summary>
 ///     Metodo que crear un Tipo Costo
 /// </summary>
 /// <param name="info"></param>
 internal void Crear(CostoInfo info)
 {
     try
     {
         Logger.Info();
         var costoDAL = new CostoDAL();
         if (info.CostoID == 0)
         {
             costoDAL.Crear(info);
         }
         else
         {
             costoDAL.Actualizar(info);
         }
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
        /// <summary>
        /// Carga el Costo de la Ayuda
        /// </summary>
        private CostoInfo CargarCosto()
        {
            var costo = new CostoInfo
            {
                ClaveContable = skAyudaCosto.Clave,
                CostoID       = int.Parse(skAyudaCosto.Id),
                Descripcion   = skAyudaCosto.Descripcion
            };

            return(costo);
        }
        /// <summary>
        /// Asigna valores al contexto despues
        /// de que se realice un guardado
        /// </summary>
        /// <param name="contextoClone"></param>
        private void AsignarValoresContexto(CostoInfo contextoClone)
        {
            if (contextoClone != null)
            {
                Contexto.ListaRetencion        = contextoClone.ListaRetencion;
                Contexto.ListaTipoCostos       = contextoClone.ListaTipoCostos;
                Contexto.ListaTipoProrrateo    = contextoClone.ListaTipoProrrateo;
                Contexto.ListaTipoCostoCentro  = contextoClone.ListaTipoCostoCentro;
                Contexto.UsuarioCreacionID     = contextoClone.UsuarioCreacionID;
                Contexto.UsuarioModificacionID = contextoClone.UsuarioModificacionID;

                RetencionInfo retencion =
                    contextoClone.ListaRetencion.FirstOrDefault(ret => ret.RetencionID == 0);
                if (retencion != null)
                {
                    Contexto.Retencion = retencion;
                }

                TipoProrrateoInfo tipoProrrateo =
                    contextoClone.ListaTipoProrrateo.FirstOrDefault(tip => tip.TipoProrrateoID == 0);
                if (tipoProrrateo != null)
                {
                    Contexto.TipoProrrateo = tipoProrrateo;
                }

                TipoCostoInfo tipoCosto =
                    contextoClone.ListaTipoCostos.FirstOrDefault(costo => costo.TipoCostoID == 0);
                if (tipoCosto != null)
                {
                    Contexto.TipoCosto = tipoCosto;
                }

                TipoCostoCentroInfo tipoCostoCentro =
                    contextoClone.ListaTipoCostoCentro.FirstOrDefault(CostoCentro => CostoCentro.TipoCostoCentroID == 0);
                if (tipoCostoCentro != null)
                {
                    Contexto.TipoCostoCentro = tipoCostoCentro;
                }

                cboRetencion.ItemsSource       = Contexto.ListaRetencion;
                cboTipoCosto.ItemsSource       = Contexto.ListaTipoCostos;
                cboTipoProrrateo.ItemsSource   = Contexto.ListaTipoProrrateo;
                cboTipoCostoCentro.ItemsSource = Contexto.ListaTipoCostoCentro;

                cboTipoCosto.SelectedItem       = Contexto.TipoCosto;
                cboRetencion.SelectedItem       = Contexto.Retencion;
                cboTipoProrrateo.SelectedItem   = Contexto.TipoProrrateo;
                cboTipoCostoCentro.SelectedItem = Contexto.TipoCostoCentro;

                txtClaveContable.Focus();
            }
        }
Exemple #6
0
        /// <summary>
        /// Levanta la ventana de edicion
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Editar_OnClick(object sender, RoutedEventArgs e)
        {
            var btn = e.Source as Button;

            try
            {
                var costoSelecionado = btn.CommandParameter as CostoInfo;
                if (costoSelecionado != null)
                {
                    var costo = new CostoInfo
                    {
                        ListaTipoCostos       = Contexto.ListaTipoCostos,
                        ListaRetencion        = Contexto.ListaRetencion,
                        ListaTipoProrrateo    = Contexto.ListaTipoProrrateo,
                        CostoID               = costoSelecionado.CostoID,
                        ClaveContable         = costoSelecionado.ClaveContable,
                        Descripcion           = costoSelecionado.Descripcion,
                        UsuarioModificacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
                        Retencion             = costoSelecionado.Retencion,
                        TipoCosto             = costoSelecionado.TipoCosto,
                        TipoProrrateo         = costoSelecionado.TipoProrrateo,
                        AbonoA               = costoSelecionado.AbonoA,
                        Activo               = costoSelecionado.Activo,
                        CompraIndividual     = costoSelecionado.CompraIndividual,
                        Compra               = costoSelecionado.Compra,
                        Recepcion            = costoSelecionado.Recepcion,
                        Gasto                = costoSelecionado.Gasto,
                        Costo                = costoSelecionado.Costo,
                        TipoCostoCentro      = costoSelecionado.TipoCostoCentro,
                        ListaTipoCostoCentro = Contexto.ListaTipoCostoCentro
                    };

                    var costoEdicion = new CostoEdicion(costo)
                    {
                        ucTitulo = { TextoTitulo = Properties.Resources.Costo_Editar_Titulo }
                    };
                    costoEdicion.Left  = (ActualWidth - costoEdicion.Width) / 2;
                    costoEdicion.Top   = ((ActualHeight - costoEdicion.Height) / 2) + 132;
                    costoEdicion.Owner = Application.Current.Windows[ConstantesVista.WindowPrincipal];
                    costoEdicion.ShowDialog();
                    CambiarLeyendaCombo();
                    ReiniciarValoresPaginador();
                    Buscar();
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                                  Properties.Resources.Costo_ErrorEditar, MessageBoxButton.OK, MessageImage.Error);
            }
        }
Exemple #7
0
        public void CostoObtenerPorPaginaSinDatos()
        {
            var pl     = new CostoPL();
            var pagina = new PaginacionInfo {
                Inicio = 1, Limite = 15
            };
            var filtro = new CostoInfo {
                Descripcion = "."
            };

            ResultadoInfo <CostoInfo> listaPaginada = pl.ObtenerPorPagina(pagina, filtro);

            Assert.AreEqual(listaPaginada, null);
        }
        internal ClaveContableInfo ObtenerCuentaInventario(CostoInfo costo, int organizacionID, ClaveCuenta claveCuenta)
        {
            var cuentaBL          = new CuentaBL();
            var claveCuentaString = Auxiliar.Auxiliar.ObtenerClaveCuenta(claveCuenta);
            var claveContable     = cuentaBL.ObtenerPorClaveCuentaOrganizacion(claveCuentaString, organizacionID);

            if (claveContable != null)
            {
                claveContable.Valor = string.Format("{0}{1}", claveContable.Valor, costo.ClaveContable);
            }
            else
            {
                claveContable = new ClaveContableInfo();
            }
            return(claveContable);
        }
 /// <summary>
 /// Evento que se ejecuta mientras se esta cerrando la ventana
 /// </summary>
 /// <param name="e"></param>
 protected override void OnClosing(CancelEventArgs e)
 {
     if (confirmaSalir)
     {
         MessageBoxResult result = SkMessageBox.Show(this, Properties.Resources.Msg_CerrarSinGuardar
                                                     , MessageBoxButton.YesNo,
                                                     MessageImage.Question);
         if (result == MessageBoxResult.Yes)
         {
             Contexto = null;
         }
         else
         {
             e.Cancel = true;
         }
     }
 }
Exemple #10
0
 internal static IList <CostoInfo> ObtenerTodos(IDataReader reader)
 {
     try
     {
         Logger.Info();
         var       result = new List <CostoInfo>();
         CostoInfo elemento;
         while (reader.Read())
         {
             elemento = new CostoInfo
             {
                 CostoID       = Convert.ToInt32(reader["CostoID"]),
                 ClaveContable = Convert.ToString(reader["ClaveContable"]),
                 Descripcion   = Convert.ToString(reader["Descripcion"]),
                 TipoCosto     =
                     new TipoCostoInfo
                 {
                     TipoCostoID = Convert.ToInt32(reader["TipoCostoID"]),
                     Descripcion = Convert.ToString(reader["TipoCosto"])
                 },
                 TipoProrrateo =
                     new TipoProrrateoInfo
                 {
                     TipoProrrateoID = Convert.ToInt32(reader["TipoProrrateoID"]),
                     Descripcion     = Convert.ToString(reader["TipoProrrateo"])
                 },
                 Retencion =
                     new RetencionInfo
                 {
                     RetencionID = Convert.ToInt32(reader["RetencionID"]),
                     Descripcion = Convert.ToString(reader["Retencion"])
                 },
                 AbonoA = Convert.ToString(reader["AbonoA"]).StringAEnum(),
                 Activo = Convert.ToBoolean(reader["Activo"]).BoolAEnum(),
             };
             result.Add(elemento);
         }
         return(result);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #11
0
        public void CostoGuardarDescripcionExistente()
        {
            var pl    = new CostoPL();
            var costo = new CostoInfo
            {
                CostoID     = 0,
                Descripcion = "Costo",
                Activo      = EstatusEnum.Activo
            };

            try
            {
                pl.Actualizar(costo);
            }
            catch (Exception)
            {
                Assert.AreEqual(costo.CostoID, 0);
            }
        }
Exemple #12
0
        /// <summary>
        /// Obtiene los parametros necesario para obtener un costo por id
        /// </summary>
        /// <param name="costo"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametroCostoPorID(CostoInfo costo)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@CostoID", costo.CostoID }
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(parametros);
        }
Exemple #13
0
        /// <summary>
        ///     Obtiene Parametros por Id
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal static Dictionary <string, object> ObtenerParametroPorClaveContable(CostoInfo filtro)
        {
            Dictionary <string, object> parametros;

            try
            {
                Logger.Info();
                parametros = new Dictionary <string, object>
                {
                    { "@ClaveContable", filtro.ClaveContable }
                };
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(parametros);
        }
Exemple #14
0
 /// <summary>
 /// Obtiene una entidad Costo por su descripción
 /// </summary>
 /// <param name="descripcion"></param>
 /// <returns></returns>
 internal CostoInfo ObtenerPorDescripcion(string descripcion)
 {
     try
     {
         Logger.Info();
         var       costoDAL = new CostoDAL();
         CostoInfo result   = costoDAL.ObtenerPorDescripcion(descripcion);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #15
0
 /// <summary>
 ///  Método que obtiene un registro
 /// </summary>
 /// <param name="ds"></param>
 /// <returns></returns>
 internal static CostoInfo ObtenerPorDescripcion(DataSet ds)
 {
     try
     {
         Logger.Info();
         DataTable dt      = ds.Tables[ConstantesDAL.DtDatos];
         CostoInfo entidad =
             (from info in dt.AsEnumerable()
              select
              new CostoInfo
         {
             CostoID = info.Field <int>("CostoID"),
             ClaveContable = info.Field <string>("ClaveContable"),
             Descripcion = info.Field <string>("Descripcion"),
             TipoCosto =
                 new TipoCostoInfo
             {
                 TipoCostoID = info.Field <int>("TipoCostoID"),
                 Descripcion = info.Field <string>("TipoCosto")
             },
             TipoProrrateo =
                 new TipoProrrateoInfo
             {
                 TipoProrrateoID = info.Field <int>("TipoProrrateoID"),
                 Descripcion = info.Field <string>("TipoProrrateo")
             },
             Retencion =
                 new RetencionInfo
             {
                 RetencionID = info.Field <int>("RetencionID"),
                 Descripcion = info.Field <string>("Retencion")
             },
             AbonoA = info.Field <string>("AbonoA").StringAEnum(),
             Activo = info.Field <bool>("Activo").BoolAEnum(),
         }).First();
         return(entidad);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Exemple #16
0
 /// <summary>
 /// Manda llamar la pantalla para
 /// Generar un Nuevo Producto
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void BtnNuevo_OnClick(object sender, RoutedEventArgs e)
 {
     try
     {
         var costoInfo = new CostoInfo
         {
             ListaRetencion       = Contexto.ListaRetencion,
             ListaTipoCostos      = Contexto.ListaTipoCostos,
             ListaTipoProrrateo   = Contexto.ListaTipoProrrateo,
             ListaTipoCostoCentro = Contexto.ListaTipoCostoCentro,
             AbonoA            = AbonoA.AMBOS,
             UsuarioCreacionID = AuxConfiguracion.ObtenerUsuarioLogueado(),
             Retencion         = new RetencionInfo {
                 RetencionID = 0
             },
             TipoProrrateo = new TipoProrrateoInfo {
                 TipoProrrateoID = 0
             },
             TipoCostoCentro = new TipoCostoCentroInfo {
                 TipoCostoCentroID = 0
             }
         };
         var costoEdicion = new CostoEdicion(costoInfo)
         {
             ucTitulo = { TextoTitulo = Properties.Resources.Costo_Nuevo_Titulo }
         };
         costoEdicion.Left  = (ActualWidth - costoEdicion.Width) / 2;
         costoEdicion.Top   = ((ActualHeight - costoEdicion.Height) / 2) + 132;
         costoEdicion.Owner = Application.Current.Windows[ConstantesVista.WindowPrincipal];
         costoEdicion.ShowDialog();
         CambiarLeyendaCombo();
         ReiniciarValoresPaginador();
         Buscar();
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                           Properties.Resources.Costo_ErrorNuevo, MessageBoxButton.OK, MessageImage.Error);
     }
 }
Exemple #17
0
        /// <summary>
        ///     Obtiene un lista paginada
        /// </summary>
        /// <param name="pagina"></param>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal ResultadoInfo <CostoInfo> ObtenerPorPagina(PaginacionInfo pagina, CostoInfo filtro)
        {
            ResultadoInfo <CostoInfo> costoLista;

            try
            {
                Logger.Info();
                var costoDAL = new CostoDAL();
                costoLista = costoDAL.ObtenerPorPagina(pagina, filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(costoLista);
        }
Exemple #18
0
        /// <summary>
        /// Obtiene el centro de costo para un costoid dado
        /// </summary>
        /// <param name="filtro"></param>
        /// <returns></returns>
        internal CentroCostoInfo ObtenerCentroCostoSAPPorCosto(CostoInfo filtro)
        {
            CentroCostoInfo info;

            try
            {
                Logger.Info();
                var costoDAL = new CostoDAL();
                info = costoDAL.ObtenerCentroCostoSAPPorCosto(filtro);
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(info);
        }
Exemple #19
0
        /// <summary>
        /// Actualiza los importes,cantidades de los registros de entrada de ganado en transito correspondientes a la salida
        /// </summary>
        /// <param name="info">salida de ganado en transito en base al cual se actualizaran las tablas de entradas de ganado en transito y del lote</param>
        /// <returns>Regresa un true si se logro actualizar exitosamente las entradas de ganado en transito y del lote</returns>
        internal bool ActualizarEntradas(SalidaGanadoEnTransitoInfo info)
        {
            try
            {
                Logger.Info();
                info.FechaCreacion = DateTime.Now;

                var importes = new List <CostoInfo>();
                for (int i = 0; i < info.DetallesSalida.Count; i++)
                {
                    var temp = new CostoInfo
                    {
                        CostoID      = info.DetallesSalida[i].CostoId,
                        ImporteCosto = info.Costos[i].Importe - info.DetallesSalida[i].ImporteCosto
                    };
                    importes.Add(temp);
                }

                Dictionary <string, object> parameters = AuxSalidaGanadoEnTransitoDAL.ObtenerParametrosActualizarEntradas(info, importes);
                Update("SalidaGanadoTransito_ActualizarEntradasGanadoTransito", parameters);

                return(true);
            }
            catch (SqlException ex)
            {
                Logger.Error(ex);
                throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
            }
            catch (DataException ex)
            {
                Logger.Error(ex);
                throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Exemple #20
0
 /// <summary>
 ///     Metodo que actualiza un Costo
 /// </summary>
 /// <param name="info"></param>
 internal void Actualizar(CostoInfo info)
 {
     try
     {
         Dictionary <string, object> parameters = AuxCostoDAL.ObtenerParametrosActualizar(info);
         Update("[dbo].[Costo_Actualizar]", parameters);
     }
     catch (SqlException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (DataException ex)
     {
         Logger.Error(ex);
         throw new ExcepcionServicio(MethodBase.GetCurrentMethod(), ex);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
        /// <summary>
        /// Cargar la Auida de Costo
        /// </summary>
        private void AgregarAyudaCosto()
        {
            var costoInfo = new CostoInfo
            {
                ListaTipoCostos = listaTipoCosto
            };

            skAyudaCosto = new SKAyuda <CostoInfo>(160, false, costoInfo, "PropiedadClaveProgramacionEmbarqueCostos"
                                                   , "PropiedadDescripcionProgramacionEmbarqueCostos"
                                                   , "PropiedadOcultaProgramacionEmbarqueCostos", true)
            {
                AyudaPL = new CostoPL(),
                MensajeClaveInexistente = Properties.Resources.Costo_CodigoInvalidoEmbarque,
                MensajeBusquedaCerrar   = Properties.Resources.Costo_SalirSinSeleccionar,
                MensajeBusqueda         = Properties.Resources.Costo_Busqueda,
                MensajeAgregar          = Properties.Resources.Costo_Seleccionar,
                TituloEtiqueta          = Properties.Resources.LeyehdaAyudaBusquedaCosto,
                TituloPantalla          = Properties.Resources.BusquedaCosto_Titulo,
            };
            skAyudaCosto.LlamadaMetodos += CostoObtenido;
            SplAyudaCosto.Children.Clear();
            SplAyudaCosto.Children.Add(skAyudaCosto);
        }
Exemple #22
0
        public void CostoActualizar()
        {
            var       random       = new Random();
            int       randomNumber = random.Next(0, 100);
            var       pl           = new CostoPL();
            CostoInfo costo        = pl.ObtenerPorID(1);

            if (costo != null)
            {
                string descripcion;
                try
                {
                    descripcion                 = string.Format("Prueba Unitaria Actualizar {0:D10}", randomNumber);
                    costo.Descripcion           = descripcion;
                    costo.UsuarioModificacionID = 2;
                    pl.Actualizar(costo);
                }
                catch (Exception)
                {
                    descripcion = string.Empty;
                }
                Assert.AreEqual(costo.Descripcion, descripcion);
            }
        }
 /// <summary>
 /// Iniciliaza el contexto
 /// </summary>
 private void InicializaContexto()
 {
     Contexto = new CostoInfo();
 }
 public CostoEdicion(CostoInfo costo)
 {
     InitializeComponent();
     Contexto = costo;
     CambiarLeyendaCombo();
 }
        /// <summary>
        /// Valida los campos para su guardado
        /// </summary>
        /// <returns></returns>
        private bool ValidaGuardar()
        {
            var guardar = true;
            var mensaje = string.Empty;

            if (string.IsNullOrWhiteSpace(Contexto.ClaveContable))
            {
                guardar = false;
                txtClaveContable.Focus();
                mensaje = Properties.Resources.CostoEdicion_ClaveContable_Requerida;
            }
            else
            {
                if (string.IsNullOrWhiteSpace(Contexto.Descripcion))
                {
                    guardar = false;
                    txtDescripcion.Focus();
                    mensaje = Properties.Resources.CostoEdicion_Descripcion_Requerida;
                }
                else
                {
                    if (Contexto.TipoCosto.TipoCostoID == 0)
                    {
                        guardar = false;
                        cboTipoCosto.Focus();
                        mensaje = Properties.Resources.CostoEdicion_TipoCosto_Requerida;
                    }
                    else
                    {
                        if (Contexto.TipoProrrateo.TipoProrrateoID == 0)
                        {
                            guardar = false;
                            cboTipoProrrateo.Focus();
                            mensaje = Properties.Resources.CostoEdicion_TipoProrrateo_Requerida;
                        }
                    }
                }
            }
            if (guardar)
            {
                var       costoPL = new CostoPL();
                CostoInfo costo   = costoPL.ObtenerPorDescripcion(Contexto.Descripcion);
                if (costo != null && Contexto.CostoID != costo.CostoID)
                {
                    mensaje = string.Format(Properties.Resources.CostoEdicion_Descripcion_Existente,
                                            costo.CostoID);
                    txtDescripcion.Focus();
                    guardar = false;
                }
                else
                {
                    costo = costoPL.ObtenerPorClaveContable(Contexto);
                    if (costo != null && Contexto.CostoID != costo.CostoID)
                    {
                        mensaje = Properties.Resources.CostoEdicion_ClaveConable_Existente;
                        txtClaveContable.Focus();
                        guardar = false;
                    }
                }
            }
            if (!string.IsNullOrWhiteSpace(mensaje))
            {
                SkMessageBox.Show(this, mensaje, MessageBoxButton.OK, MessageImage.Warning);
            }
            return(guardar);
        }
        /// <summary>
        /// Genera linea para los registros
        /// contable
        /// </summary>
        /// <param name="polizas"> </param>
        /// <param name="cargos"> </param>
        /// <param name="abonos"> </param>
        protected override void GeneraLineaRegistroContable(IList <PolizaInfo> polizas, out IList <PolizaInfo> cargos
                                                            , out IList <PolizaInfo> abonos)
        {
            base.GeneraLineaRegistroContable(polizas, out cargos, out abonos);
            const int CADENA_LARGA = 29;

            IList <CostoInfo> costos = ObtenerCostos();

            PolizaModel.RegistroContable = new List <PolizaRegistroContableModel>();
            PolizaRegistroContableModel registroContable;

            foreach (var cargo in cargos)
            {
                if (string.IsNullOrWhiteSpace(cargo.Descripcion))
                {
                    CostoInfo descripcionCosto =
                        costos.FirstOrDefault(
                            costo =>
                            cargo.Cuenta.EndsWith(costo.ClaveContable));
                    if (descripcionCosto == null)
                    {
                        cargo.Descripcion = string.Empty;
                    }
                    else
                    {
                        cargo.Descripcion = descripcionCosto.Descripcion;
                    }
                }

                var sbDescripcion = new StringBuilder();
                sbDescripcion.Append(cargo.Descripcion.Length > CADENA_LARGA
                                         ? cargo.Descripcion.Substring(0, CADENA_LARGA - 1).Trim()
                                         : cargo.Descripcion.Trim());
                registroContable = new PolizaRegistroContableModel
                {
                    Cuenta =
                        Cancelacion
                            ? string.IsNullOrWhiteSpace(cargo.Proveedor)
                                  ? cargo.Cuenta
                                  : cargo.Proveedor
                            : cargo.Cuenta,
                    Descripcion = sbDescripcion.ToString(),
                    Concepto    = cargo.Concepto,
                    Cargo       =
                        Convert.ToDecimal(cargo.Importe.Replace("-", string.Empty)).ToString(
                            "N", CultureInfo.CurrentCulture)
                };
                PolizaModel.RegistroContable.Add(registroContable);
            }

            foreach (var abono in abonos)
            {
                if (string.IsNullOrWhiteSpace(abono.Descripcion))
                {
                    CostoInfo descripcionCosto =
                        costos.FirstOrDefault(
                            costo =>
                            abono.Cuenta.EndsWith(costo.ClaveContable));
                    if (descripcionCosto == null)
                    {
                        abono.Descripcion = string.Empty;
                    }
                    else
                    {
                        abono.Descripcion = descripcionCosto.Descripcion;
                    }
                }

                var sbDescripcion = new StringBuilder();
                sbDescripcion.Append(abono.Descripcion.Length > CADENA_LARGA
                                         ? abono.Descripcion.Substring(0, CADENA_LARGA - 1).Trim()
                                         : abono.Descripcion.Trim());
                registroContable = new PolizaRegistroContableModel
                {
                    Cuenta =
                        (string.IsNullOrWhiteSpace(abono.Proveedor)
                             ? abono.Cuenta
                             : abono.Proveedor),
                    Descripcion = sbDescripcion.ToString(),
                    Concepto    = abono.Concepto,
                    Abono       =
                        Convert.ToDecimal(abono.Importe.Replace("-", string.Empty)).ToString(
                            "N", CultureInfo.CurrentCulture)
                };
                PolizaModel.RegistroContable.Add(registroContable);
            }
        }
Exemple #27
0
        private IList <PolizaInfo> ObtenerPoliza(List <AnimalCostoInfo> costosAnimales)
        {
            var polizasSalidaMuerte = new List <PolizaInfo>();

            var costosAgrupados =
                costosAnimales.Where(imp => imp.Importe > 0).GroupBy(costo => new { costo.CostoID, costo.AnimalID })
                .Select(animal => new
            {
                Importe = animal.Sum(imp => imp.Importe),
                animal.Key.CostoID,
                animal.Key.AnimalID,
                Arete           = animal.Select(ani => ani.Arete).FirstOrDefault(),
                FolioReferencia =
                    animal.Select(folio => folio.FolioReferencia).FirstOrDefault(),
                FechaCosto     = animal.Select(fecha => fecha.FechaCosto).FirstOrDefault(),
                OrganizacionID = animal.Select(org => org.OrganizacionID).FirstOrDefault()
            }).ToList();

            if (costosAgrupados != null && costosAgrupados.Any())
            {
                TipoPolizaInfo tipoPoliza =
                    TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == TipoPoliza.SalidaMuerte.GetHashCode());
                if (tipoPoliza == null)
                {
                    throw new ExcepcionServicio(string.Format("{0} {1}", "EL TIPO DE POLIZA",
                                                              TipoPoliza.SalidaMuerte));
                }

                string textoDocumento = tipoPoliza.TextoDocumento;
                string tipoMovimiento = tipoPoliza.ClavePoliza;
                string postFijoRef3   = tipoPoliza.PostFijoRef3;

                var linea = 1;

                var ref3 = new StringBuilder();
                ref3.Append("03");
                ref3.Append(
                    string.Format("{0}{1}{2}", DateTime.Today.Day, DateTime.Today.Month, DateTime.Today.Year).PadLeft(
                        10, ' '));
                ref3.Append(new Random(10).Next(10, 20));
                ref3.Append(new Random(30).Next(30, 40));
                ref3.Append(DateTime.Now.Millisecond);
                ref3.Append(postFijoRef3);

                //string numeroReferencia = ObtenerNumeroReferencia;

                if (costos == null)
                {
                    costos = ObtenerCostos();
                }

                List <AnimalInfo> animales = costosAgrupados.Select(ani => new AnimalInfo
                {
                    AnimalID = ani.AnimalID
                }).ToList();
                List <AnimalMovimientoInfo> animalesMovimiento = ObtenerUltimoMovimiento(animales);
                for (var indexCostos = 0; indexCostos < costosAgrupados.Count; indexCostos++)
                {
                    var       costoAnimal = costosAgrupados[indexCostos];
                    CostoInfo costo       =
                        costos.FirstOrDefault(
                            tipo =>
                            tipo.CostoID == costoAnimal.CostoID);
                    if (costo == null)
                    {
                        costo = new CostoInfo();
                    }

                    string numeroReferencia = costoAnimal.Arete;

                    OrganizacionInfo organizacion = ObtenerOrganizacionIVA(costoAnimal.OrganizacionID);
                    if (organizacion == null)
                    {
                        organizacion = new OrganizacionInfo
                        {
                            TipoOrganizacion = new TipoOrganizacionInfo()
                        };
                    }
                    ClaveContableInfo claveContableAbono = ObtenerCuentaInventario(costo, organizacion.OrganizacionID,
                                                                                   organizacion.TipoOrganizacion.TipoOrganizacionID);
                    if (claveContableAbono == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA EL COSTO",
                                                                  costo.Descripcion));
                    }
                    ClaveContableInfo claveContableCargo = ObtenerCuentaInventario(costo, organizacion.OrganizacionID,
                                                                                   TipoPoliza.SalidaMuerte);
                    if (claveContableCargo == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA EL COSTO",
                                                                  costo.Descripcion));
                    }
                    ParametroOrganizacionInfo parametroCentroCosto =
                        ObtenerParametroOrganizacionPorClave(organizacion.OrganizacionID,
                                                             ParametrosEnum.CTACENTROCOSTOENG.ToString());
                    if (parametroCentroCosto == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE COSTO NO CONFIGURADO"));
                    }
                    int peso =
                        animalesMovimiento.Where(kilos => kilos.AnimalID == costoAnimal.AnimalID
                                                 &&
                                                 kilos.TipoMovimientoID == TipoMovimiento.Muerte.GetHashCode())
                        .Select(proyeccion => proyeccion.Peso).FirstOrDefault();
                    DateTime fecha =
                        animalesMovimiento.Where(kilos => kilos.AnimalID == costoAnimal.AnimalID
                                                 &&
                                                 kilos.TipoMovimientoID == TipoMovimiento.Muerte.GetHashCode())
                        .Select(proyeccion => proyeccion.FechaMovimiento).FirstOrDefault();
                    if (fecha != null && fecha > default(DateTime))
                    {
                        string archivoFolio = ObtenerArchivoFolio(fecha);
                        var    datos        = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = fecha,
                            Folio            = numeroReferencia,
                            Importe          = string.Format("{0}", costoAnimal.Importe.ToString("F2")),
                            Renglon          = Convert.ToString(linea++),
                            ImporteIva       = "0",
                            Ref3             = ref3.ToString(),
                            Cuenta           = claveContableCargo.Valor,
                            Division         = organizacion.Division,
                            ArchivoFolio     = archivoFolio,
                            CentroCosto      =
                                claveContableCargo.Valor.StartsWith(PrefijoCuentaCentroCosto) ||
                                claveContableCargo.Valor.StartsWith(PrefijoCuentaCentroGasto)
                                    ? parametroCentroCosto.Valor
                                    : string.Empty,
                            PesoOrigen      = peso,
                            TipoDocumento   = textoDocumento,
                            ClaseDocumento  = postFijoRef3,
                            ComplementoRef1 = string.Empty,
                            Concepto        = String.Format("{0}-{1} {2} kgs",
                                                            tipoMovimiento,
                                                            numeroReferencia,
                                                            peso),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        PolizaInfo polizaSalida = GeneraRegistroPoliza(datos);
                        polizasSalidaMuerte.Add(polizaSalida);

                        datos = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = fecha,
                            Folio            = numeroReferencia,
                            Importe          = string.Format("{0}", (costoAnimal.Importe * -1).ToString("F2")),
                            Renglon          = Convert.ToString(linea++),
                            ImporteIva       = "0",
                            Ref3             = ref3.ToString(),
                            Cuenta           = claveContableAbono.Valor,
                            ArchivoFolio     = archivoFolio,
                            Division         = organizacion.Division,
                            PesoOrigen       = peso,
                            TipoDocumento    = textoDocumento,
                            ClaseDocumento   = postFijoRef3,
                            Concepto         = String.Format("{0}-{1} {2} kgs",
                                                             tipoMovimiento,
                                                             numeroReferencia,
                                                             peso),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaSalida = GeneraRegistroPoliza(datos);
                        polizasSalidaMuerte.Add(polizaSalida);
                    }
                }
            }
            return(polizasSalidaMuerte);
        }
Exemple #28
0
        /// <summary>
        /// Obtiene el ultimo costo registrado que coincida con el origen, destino y proveedor
        /// </summary>
        /// <param name="embarqueDetalleInfo"></param>
        /// <returns></returns>
        internal CostoInfo ObtenerUltimoCostoPorProveedorIDOrigenIDDestinoIDCostoID(EmbarqueInfo embarqueInfo)
        {
            CostoInfo        info  = null;
            List <CostoInfo> lista = null;

            try
            {
                Logger.Info();
                var costoEmbarqueDetalleDAL = new CostoEmbarqueDetalleDAL();

                if (embarqueInfo.TipoEmbarque.TipoEmbarqueID == (int)TipoEmbarque.Ruteo)
                {
                    int numTotalEscalas = embarqueInfo.ListaEscala.Last().Orden;
                    int numEscala       = 1;
                    int esIgual         = 1;
                    if (embarqueInfo.ListaEscala.Count > 2)
                    {
                        IList <EmbarqueDetalleInfo> detalles = costoEmbarqueDetalleDAL.ObtenerEmbarqueDetallesCostosPorProveedorIDOrigenIDDestinoIDCostoID(embarqueInfo);
                        if (detalles != null)
                        {
                            detalles = (from EmbarqueDetalleInfo item in detalles
                                        orderby item.EmbarqueID descending, item.Orden
                                        select item).ToList();
                            decimal importe = 0;
                            for (int i = 0; i < detalles.Count; i++)
                            {
                                if (detalles[i].ListaCostoEmbarqueDetalle.Count > 0)
                                {
                                    importe = detalles[i].ListaCostoEmbarqueDetalle[0].Importe;
                                }
                                if (detalles[i].OrganizacionOrigen.OrganizacionID == embarqueInfo.ListaEscala[numEscala].OrganizacionOrigen.OrganizacionID &&
                                    detalles[i].OrganizacionDestino.OrganizacionID == embarqueInfo.ListaEscala[numEscala].OrganizacionDestino.OrganizacionID)
                                {
                                    esIgual = 1;
                                }
                                else
                                {
                                    esIgual = 0;
                                }

                                if (numEscala == numTotalEscalas)
                                {
                                    if (esIgual == 1)
                                    {
                                        info = new CostoInfo()
                                        {
                                            ImporteCosto = importe
                                        };
                                        break;
                                    }
                                    numEscala = 1;
                                    esIgual   = 1;
                                }
                                numEscala++;
                            }
                        }
                    }
                }
                else
                {
                    lista = costoEmbarqueDetalleDAL.ObtenerCostosPorProveedorIDOrigenIDDestinoIDCostoID(embarqueInfo);
                    if (lista != null)
                    {
                        info = (from CostoInfo item in lista
                                orderby item.FechaCosto descending
                                select item).FirstOrDefault <CostoInfo>();
                    }
                }
            }
            catch (ExcepcionGenerica)
            {
                throw;
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
            return(info);
        }
Exemple #29
0
        /// <summary>
        /// Genera linea para los registros
        /// contable
        /// </summary>
        /// <param name="polizas"> </param>
        /// <param name="cargos"> </param>
        /// <param name="abonos"> </param>
        protected override void GeneraLineaRegistroContable(IList <PolizaInfo> polizas, out IList <PolizaInfo> cargos
                                                            , out IList <PolizaInfo> abonos)
        {
            base.GeneraLineaRegistroContable(polizas, out cargos, out abonos);
            cargos.ToList().ForEach(cliente =>
            {
                if (string.IsNullOrWhiteSpace(cliente.Cuenta))
                {
                    cliente.Cuenta = string.Empty;
                }
            });
            cargos = cargos.OrderBy(cliente => cliente.Cuenta).ToList();
            abonos = abonos.OrderBy(cliente => cliente.Cuenta).ToList();

            if (costos == null || !costos.Any())
            {
                costos = ObtenerCostos();
            }

            PolizaModel.RegistroContable = new List <PolizaRegistroContableModel>();
            PolizaRegistroContableModel registroContable;

            foreach (var cargo in cargos)
            {
                CostoInfo descripcionCosto =
                    costos.FirstOrDefault(
                        costo => cargo.Cuenta.EndsWith(costo.ClaveContable));
                if (descripcionCosto == null)
                {
                    descripcionCosto = new CostoInfo
                    {
                        Descripcion = string.Empty
                    };
                }

                var sbDescripcion = new StringBuilder();
                sbDescripcion.Append(descripcionCosto.Descripcion.Length > CADENA_LARGA
                                         ? descripcionCosto.Descripcion.Substring(0, CADENA_LARGA - 1).Trim()
                                         : descripcionCosto.Descripcion.Trim());
                registroContable = new PolizaRegistroContableModel
                {
                    Cuenta =
                        string.IsNullOrWhiteSpace(cargo.Cuenta) ? cargo.Cliente : cargo.Cuenta,
                    Descripcion = sbDescripcion.ToString(),
                    Cargo       =
                        Convert.ToDecimal(cargo.Importe.Replace("-", string.Empty)).ToString(
                            "N", CultureInfo.CurrentCulture)
                };
                PolizaModel.RegistroContable.Add(registroContable);
            }

            foreach (var abono in abonos)
            {
                CostoInfo descripcionCosto =
                    costos.FirstOrDefault(
                        costo => abono.Cuenta.EndsWith(costo.ClaveContable));
                if (descripcionCosto == null)
                {
                    descripcionCosto = new CostoInfo
                    {
                        Descripcion = string.Empty
                    };
                }
                var sbDescripcion = new StringBuilder();
                sbDescripcion.Append(descripcionCosto.Descripcion.Length > CADENA_LARGA
                                         ? descripcionCosto.Descripcion.Substring(0, CADENA_LARGA - 1).Trim()
                                         : descripcionCosto.Descripcion.Trim());
                registroContable = new PolizaRegistroContableModel
                {
                    Cuenta      = abono.Cuenta,
                    Descripcion = sbDescripcion.ToString(),
                    Abono       =
                        Convert.ToDecimal(abono.Importe.Replace("-", string.Empty)).ToString(
                            "N", CultureInfo.CurrentCulture)
                };
                PolizaModel.RegistroContable.Add(registroContable);
            }
        }
        private IList <PolizaInfo> ObtenerPoliza(PolizaConsumoAlimentoModel contenedor)
        {
            var polizasConsumo = new List <PolizaInfo>();

            TipoPolizaInfo tipoPoliza =
                TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == TipoPoliza.ConsumoAlimento.GetHashCode());

            if (tipoPoliza == null)
            {
                throw new ExcepcionServicio(string.Format("{0} {1}", "EL TIPO DE POLIZA", TipoPoliza.ConsumoAlimento));
            }

            string textoDocumento = tipoPoliza.TextoDocumento;
            string tipoMovimiento = tipoPoliza.ClavePoliza;
            string postFijoRef3   = tipoPoliza.PostFijoRef3;

            var linea = 1;
            var ref3  = new StringBuilder();

            ref3.Append("03");
            ref3.Append(
                string.Format("{0}{1}{2}", DateTime.Today.Day, DateTime.Today.Month, DateTime.Today.Year).PadLeft(
                    10, ' '));
            ref3.Append(new Random(10).Next(10, 20));
            ref3.Append(new Random(30).Next(30, 40));
            ref3.Append(DateTime.Now.Millisecond);
            ref3.Append(postFijoRef3);

            string numeroDocumento = ObtenerNumeroReferenciaFolio(contenedor.AlmacenMovimiento.FolioMovimiento);

            DateTime            fecha        = contenedor.Reparto.Fecha;
            string              archivoFolio = ObtenerArchivoFolio(fecha);
            IList <CostoInfo>   costos       = ObtenerCostos();
            IList <FormulaInfo> formulas     = ObtenerFormulas();

            OrganizacionInfo                    organizacion;
            List <RepartoDetalleInfo>           repatoAgrupado = null;
            List <ProduccionFormulaDetalleInfo> produccionAgrupado;

            CostoInfo costo =
                costos.FirstOrDefault(
                    tipo => "002".Equals(tipo.ClaveContable));

            if (costo == null)
            {
                costo = new CostoInfo();
            }
            PolizaInfo polizaConsumo;

            IList <CuentaSAPInfo> cuentasSAP = ObtenerCuentasSAP();

            if (cuentasSAP == null)
            {
                cuentasSAP = new List <CuentaSAPInfo>();
            }
            CuentaSAPInfo cuentaSap;

            if (contenedor.Reparto != null && contenedor.Reparto.DetalleReparto != null &&
                contenedor.Reparto.DetalleReparto.Any())
            {
                repatoAgrupado = contenedor.Reparto.DetalleReparto
                                 .GroupBy(formu => formu.FormulaIDServida)
                                 .Select(agrupado => new RepartoDetalleInfo
                {
                    OrganizacionID =
                        agrupado.Select(org => org.OrganizacionID).FirstOrDefault(),
                    Importe          = agrupado.Sum(imp => imp.Importe),
                    FormulaIDServida =
                        agrupado.Select(form => form.FormulaIDServida).FirstOrDefault()
                }).Where(imp => imp.Importe > 0).ToList();
                for (var indexReparto = 0; indexReparto < repatoAgrupado.Count; indexReparto++)
                {
                    RepartoDetalleInfo detalle = repatoAgrupado[indexReparto];

                    organizacion = ObtenerOrganizacionIVA(detalle.OrganizacionID);
                    cuentaSap    = cuentasSAP.FirstOrDefault(clave => clave.CuentaSAP.Equals("1151401002"));
                    if (cuentaSap == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "CUENTA NO CONFIGURADA PARA",
                                                                  costo.Descripcion));
                    }
                    var datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroDocumento,
                        FechaEntrada     = fecha,
                        Folio            = numeroDocumento,
                        Importe          = string.Format("{0}", detalle.Importe.ToString("F2")),
                        Renglon          = Convert.ToString(linea),
                        ImporteIva       = "0",
                        Ref3             = ref3.ToString(),
                        ClaseDocumento   = postFijoRef3,
                        Cuenta           = cuentaSap.CuentaSAP,
                        ArchivoFolio     = archivoFolio,
                        DescripcionCosto = cuentaSap.Descripcion,
                        PesoOrigen       = 0,
                        Division         = organizacion.Division,
                        TipoDocumento    = textoDocumento,
                        Concepto         = String.Format("{0}-{1} {2}",
                                                         tipoMovimiento,
                                                         numeroDocumento,
                                                         cuentaSap.CuentaSAP),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    linea++;
                    polizaConsumo = GeneraRegistroPoliza(datos);
                    polizasConsumo.Add(polizaConsumo);
                }
            }
            int almacenID = 0;

            if (contenedor.ProduccionFormula != null && contenedor.ProduccionFormula.ProduccionFormulaDetalle != null &&
                contenedor.ProduccionFormula.ProduccionFormulaDetalle.Any())
            {
                produccionAgrupado =
                    contenedor.ProduccionFormula.ProduccionFormulaDetalle
                    .GroupBy(formu => formu.ProduccionFormulaId)
                    .Select(agrupado => new ProduccionFormulaDetalleInfo
                {
                    ProduccionFormulaId = agrupado.Key,
                    OrganizacionID      =
                        agrupado.Select(org => org.OrganizacionID).FirstOrDefault(),
                    AlmacenID = agrupado.Select(alm => alm.AlmacenID).FirstOrDefault()
                }).ToList();
                ClaseCostoProductoInfo         producto;
                IList <ClaseCostoProductoInfo> almacenesProductosCuentas;
                FormulaInfo formula;
                for (var indexFormula = 0; indexFormula < produccionAgrupado.Count; indexFormula++)
                {
                    ProduccionFormulaDetalleInfo detalle = produccionAgrupado[indexFormula];

                    almacenID = detalle.AlmacenID;
                    almacenesProductosCuentas = ObtenerCostosProducto(almacenID);
                    organizacion = ObtenerOrganizacionIVA(detalle.OrganizacionID);
                    formula      = formulas.FirstOrDefault(clave => clave.FormulaId == detalle.ProduccionFormulaId);
                    if (formula == null)
                    {
                        formula =
                            formulas.FirstOrDefault(clave => clave.Producto.ProductoId == detalle.ProduccionFormulaId);
                        if (formula == null)
                        {
                            formula = new FormulaInfo
                            {
                                Producto = new ProductoInfo()
                            };
                        }
                    }
                    decimal importe = 0;
                    if (repatoAgrupado != null)
                    {
                        importe =
                            repatoAgrupado.Where(formu => formu.FormulaIDServida == formula.FormulaId).Sum(
                                imp => imp.Importe);
                        if (importe == 0)
                        {
                            importe =
                                repatoAgrupado.Where(formu => formu.FormulaIDServida == formula.Producto.ProductoId).Sum
                                    (imp => imp.Importe);
                        }
                    }
                    if (importe == 0)
                    {
                        continue;
                    }
                    producto =
                        almacenesProductosCuentas.FirstOrDefault(p => p.ProductoID == formula.Producto.ProductoId);
                    if (producto == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "CUENTA NO CONFIGURADA PARA EL PRODUCTO",
                                                                  formula.Producto.Descripcion));
                    }
                    cuentaSap = cuentasSAP.FirstOrDefault(cuenta => cuenta.CuentaSAPID == producto.CuentaSAPID);
                    if (cuentaSap == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "CUENTA NO CONFIGURADA PARA EL PRODUCTO",
                                                                  formula.Producto.Descripcion));
                    }
                    var datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroDocumento,
                        FechaEntrada     = fecha,
                        Importe          = string.Format("{0}", (importe * -1).ToString("F2")),
                        Renglon          = Convert.ToString(linea),
                        ImporteIva       = "0",
                        Ref3             = ref3.ToString(),
                        Cuenta           = cuentaSap.CuentaSAP,
                        ClaseDocumento   = postFijoRef3,
                        ArchivoFolio     = archivoFolio,
                        DescripcionCosto = cuentaSap.Descripcion,
                        PesoOrigen       = 0,
                        Division         = organizacion.Division,
                        TipoDocumento    = textoDocumento,
                        Folio            = numeroDocumento,
                        Concepto         = String.Format("{0}-{1} {2}",
                                                         tipoMovimiento,
                                                         numeroDocumento,
                                                         cuentaSap.CuentaSAP),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    linea++;
                    polizaConsumo = GeneraRegistroPoliza(datos);
                    polizasConsumo.Add(polizaConsumo);
                }
            }
            return(polizasConsumo);
        }