Beispiel #1
0
 /// <summary>
 ///     Obtiene una entidad Clave Contable por su Clave de Cuenta y su Organizacion
 /// </summary>
 /// <param name="claveCuenta">Clave de la Cuenta a buscar</param>
 /// /// <param name="organizacionID">Organizacion de la Cuenta a buscar</param>
 internal ClaveContableInfo ObtenerPorClaveCuentaOrganizacion(string claveCuenta, int organizacionID)
 {
     try
     {
         Logger.Info();
         Dictionary <string, object> parameters = AuxCuentaDAL.ObtenerPorClaveCuentaOrganizacion(claveCuenta, organizacionID);
         DataSet           ds     = Retrieve("Cuenta_ObtenerCuentaPorClaveCuenta", parameters);
         ClaveContableInfo result = null;
         if (ValidateDataSet(ds))
         {
             result = MapCuentaDAL.ObtenerPorClaveCuentaOrganizacion(ds);
         }
         return(result);
     }
     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);
     }
 }
        internal ClaveContableInfo ObtenerCuentaInventario(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}", claveContable.Valor);
            }
            else
            {
                claveContable = new ClaveContableInfo();
            }
            return(claveContable);
        }
Beispiel #3
0
 /// <summary>
 ///     Obtiene una entidad Clave Contable por su Clave de Cuenta y su Organizacion
 /// </summary>
 /// <param name="claveCuenta">Clave de la Cuenta a buscar</param>
 /// /// <param name="organizacionID">Organizacion de la Cuenta a buscar</param>
 /// <returns></returns>
 internal ClaveContableInfo ObtenerPorClaveCuentaOrganizacion(string claveCuenta, int organizacionID)
 {
     try
     {
         Logger.Info();
         var cuentaDAL            = new CuentaDAL();
         ClaveContableInfo result = cuentaDAL.ObtenerPorClaveCuentaOrganizacion(claveCuenta, organizacionID);
         return(result);
     }
     catch (ExcepcionGenerica)
     {
         throw;
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
     }
 }
Beispiel #4
0
        /// <summary>
        ///     Método  que obtiene una lista de cuentas por tipo de cuenta
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        internal static ClaveContableInfo ObtenerPorClaveCuentaOrganizacion(DataSet ds)
        {
            try
            {
                Logger.Info();
                DataTable dt = ds.Tables[ConstantesDAL.DtDatos];

                ClaveContableInfo result =
                    (from info in dt.AsEnumerable()
                     select
                     new ClaveContableInfo
                {
                    Valor = info.Field <string>("Valor"),
                    Descripcion = info.Field <string>("Descripcion")
                }).FirstOrDefault();
                return(result);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
Beispiel #5
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);
        }
        private IList <PolizaInfo> ObtenerPoliza(GastoInventarioInfo gastoInventario)
        {
            var polizasGastosInventario = new List <PolizaInfo>();

            var costos = new List <int> {
                gastoInventario.Costo.CostoID
            };
            var retencionBL = new RetencionBL();
            var retenciones = retencionBL.ObtenerRetencionesConCosto(costos);
            IList <CuentaSAPInfo> cuentasSap = ObtenerCuentasSAP();

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

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

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

            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;
            string numeroReferencia = ObtenerNumeroReferenciaFolio(gastoInventario.FolioGasto);

            DateTime fecha        = gastoInventario.FechaGasto;
            string   archivoFolio = ObtenerArchivoFolio(fecha);

            OrganizacionInfo organizacion = ObtenerOrganizacionIVA(gastoInventario.Organizacion.OrganizacionID);

            if (organizacion == null)
            {
                organizacion = new OrganizacionInfo
                {
                    TipoOrganizacion = new TipoOrganizacionInfo()
                };
            }

            bool esProveedor    = gastoInventario.Proveedor != null && gastoInventario.Proveedor.ProveedorID > 0;
            bool tieneRetencion = gastoInventario.Retencion;
            var  renglon        = 0;

            ClaveContableInfo claveContableInfo = ObtenerCuentaInventario(gastoInventario.Costo
                                                                          , gastoInventario.Organizacion.OrganizacionID
                                                                          , 0);

            CuentaSAPInfo cuentaSapProvision = null;

            if (!esProveedor)
            {
                cuentaSapProvision =
                    cuentasSap.FirstOrDefault(
                        clave => clave.CuentaSAPID == gastoInventario.CuentaSAP.CuentaSAPID);
                if (cuentaSapProvision == null)
                {
                    cuentaSapProvision =
                        cuentasSap.FirstOrDefault(
                            clave =>
                            clave.CuentaSAP.Equals(gastoInventario.CuentaGasto,
                                                   StringComparison.InvariantCultureIgnoreCase));

                    if (cuentaSapProvision == null)
                    {
                        throw new ExcepcionServicio(
                                  string.Format("No se encuentra configurada la cuenta de provisión, para el costo {0}",
                                                gastoInventario.Costo.Descripcion));
                    }
                }
            }
            string complementoConcepto;

            if (gastoInventario.Corral != null)
            {
                complementoConcepto = string.Format("Corral {0}", gastoInventario.Corral.Codigo);
            }
            else
            {
                complementoConcepto = string.Format("{0} Corrales", gastoInventario.TotalCorrales);
            }
            PolizaInfo polizaEntrada;

            if (esProveedor)
            {
                if (!gastoInventario.IVA && !tieneRetencion)
                {
                    renglon++;
                    var datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroReferencia,
                        FechaEntrada     = gastoInventario.FechaGasto,
                        Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                        ClaseDocumento   = postFijoRef3,
                        Importe          =
                            string.Format("{0}",
                                          Cancelacion ? (gastoInventario.Importe * -1).ToString("F2")
                                                                      : gastoInventario.Importe.ToString("F2")),
                        Renglon          = Convert.ToString(renglon),
                        Division         = organizacion.Division,
                        ImporteIva       = "0",
                        Ref3             = ref3.ToString(),
                        Cuenta           = claveContableInfo.Valor,
                        ArchivoFolio     = archivoFolio,
                        DescripcionCosto = claveContableInfo.Descripcion,
                        PesoOrigen       = 0,
                        TipoDocumento    = textoDocumento,
                        Concepto         =
                            String.Format("{0}-{1},{2}", tipoMovimiento,
                                          gastoInventario.FolioGasto
                                          , complementoConcepto),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    polizaEntrada = GeneraRegistroPoliza(datos);
                    polizasGastosInventario.Add(polizaEntrada);

                    renglon++;
                    datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroReferencia,
                        FechaEntrada     = gastoInventario.FechaGasto,
                        Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                        ClaveProveedor   = gastoInventario.Proveedor.CodigoSAP,
                        ClaseDocumento   = postFijoRef3,
                        Importe          =
                            string.Format("{0}", Cancelacion ? gastoInventario.Importe.ToString("F2")
                                                                         : (gastoInventario.Importe * -1).ToString("F2")),
                        Renglon          = Convert.ToString(renglon),
                        ImporteIva       = "0",
                        Ref3             = ref3.ToString(),
                        ArchivoFolio     = archivoFolio,
                        DescripcionCosto = gastoInventario.Proveedor.Descripcion,
                        PesoOrigen       = 0,
                        Division         = organizacion.Division,
                        TipoDocumento    = textoDocumento,
                        Concepto         =
                            String.Format("{0}-{1},{2}", tipoMovimiento,
                                          gastoInventario.FolioGasto
                                          , complementoConcepto),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    polizaEntrada = GeneraRegistroPoliza(datos);
                    polizasGastosInventario.Add(polizaEntrada);
                }
                else
                {
                    if (gastoInventario.IVA)
                    {
                        CuentaSAPInfo cuentaIva = cuentasSap.FirstOrDefault(
                            clave => clave.CuentaSAP.Equals(organizacion.Iva.CuentaRecuperar.ClaveCuenta));
                        if (cuentaIva == null)
                        {
                            throw new ExcepcionServicio(string.Format("No se encuentra configurada la cuenta de iva, para la organización."));
                        }
                        renglon++;
                        var importeIva = gastoInventario.Importe * (organizacion.Iva.TasaIva / 100);
                        var datos      = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = gastoInventario.FechaGasto,
                            Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                            Division         = organizacion.Division,
                            ClaseDocumento   = postFijoRef3,
                            Importe          = string.Format("{0}",
                                                             Cancelacion ? (gastoInventario.Importe * -1).ToString("F2")
                                                                                : gastoInventario.Importe.ToString("F2")),
                            Renglon          = Convert.ToString(renglon),
                            ImporteIva       = "0",
                            Ref3             = ref3.ToString(),
                            Cuenta           = claveContableInfo.Valor,
                            ArchivoFolio     = archivoFolio,
                            DescripcionCosto = claveContableInfo.Descripcion,
                            PesoOrigen       = 0,
                            TipoDocumento    = textoDocumento,
                            Concepto         =
                                String.Format("{0}-{1},{2}", tipoMovimiento,
                                              gastoInventario.FolioGasto
                                              , complementoConcepto),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaEntrada = GeneraRegistroPoliza(datos);
                        polizasGastosInventario.Add(polizaEntrada);
                        renglon++;
                        datos = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = gastoInventario.FechaGasto,
                            Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                            ClaseDocumento   = postFijoRef3,
                            Importe          = string.Format("{0}",
                                                             Cancelacion ? (importeIva * -1).ToString("F2")
                                                                            : importeIva.ToString("F2"))
                            ,
                            Renglon           = Convert.ToString(renglon),
                            ImporteIva        = gastoInventario.Importe.ToString("F2"),
                            ClaveImpuesto     = ClaveImpuesto,
                            CondicionImpuesto = CondicionImpuesto,
                            IndicadorImpuesto = organizacion.Iva.IndicadorIvaRecuperar,
                            Ref3             = ref3.ToString(),
                            Division         = organizacion.Division,
                            Cuenta           = organizacion.Iva.CuentaRecuperar.ClaveCuenta,
                            ArchivoFolio     = archivoFolio,
                            DescripcionCosto = cuentaIva.Descripcion,
                            PesoOrigen       = 0,
                            TipoDocumento    = textoDocumento,
                            Concepto         =
                                String.Format("{0}-{1},{2}", tipoMovimiento,
                                              gastoInventario.FolioGasto
                                              , complementoConcepto),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaEntrada = GeneraRegistroPoliza(datos);
                        polizasGastosInventario.Add(polizaEntrada);
                        renglon++;
                        datos = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = gastoInventario.FechaGasto,
                            Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                            Division         = organizacion.Division,
                            ClaveProveedor   = gastoInventario.Proveedor.CodigoSAP,
                            ClaseDocumento   = postFijoRef3,
                            Importe          = string.Format("{0}",
                                                             Cancelacion ? (gastoInventario.Importe + importeIva).ToString("F2")
                                                                            : ((gastoInventario.Importe + importeIva) * -1).ToString("F2")),
                            Renglon          = Convert.ToString(renglon),
                            ImporteIva       = "0",
                            Ref3             = ref3.ToString(),
                            ArchivoFolio     = archivoFolio,
                            DescripcionCosto = gastoInventario.Proveedor.Descripcion,
                            PesoOrigen       = 0,
                            TipoDocumento    = textoDocumento,
                            Concepto         =
                                String.Format("{0}-{1},{2}", tipoMovimiento,
                                              gastoInventario.FolioGasto
                                              , complementoConcepto),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaEntrada = GeneraRegistroPoliza(datos);
                        polizasGastosInventario.Add(polizaEntrada);
                    }
                    if (tieneRetencion)
                    {
                        RetencionInfo retencion;
                        if (retenciones != null && retenciones.Any())
                        {
                            retencion =
                                retenciones.Where(
                                    costo => costo.CostoID.Equals(gastoInventario.Costo.CostoID)).
                                Select(ret => ret).FirstOrDefault();

                            if (retencion == null)
                            {
                                throw new ExcepcionServicio(string.Format("No se encuentra configurada retención para el costo {0}", gastoInventario.Costo.Descripcion));
                            }
                        }
                        else
                        {
                            throw new ExcepcionServicio(string.Format("No se encuentra configurada retención para el costo {0}", gastoInventario.Costo.Descripcion));
                        }
                        var parametrosRetencion = new StringBuilder();
                        parametrosRetencion.Append(String.Format("{0}{1}"
                                                                 , retencion.IndicadorRetencion
                                                                 , retencion.TipoRetencion));
                        var datos = new DatosPolizaInfo
                        {
                            NumeroReferencia  = numeroReferencia,
                            FechaEntrada      = gastoInventario.FechaGasto,
                            Folio             = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                            Division          = organizacion.Division,
                            ClaveProveedor    = gastoInventario.Proveedor.CodigoSAP,
                            ClaseDocumento    = postFijoRef3,
                            IndicadorImpuesto = parametrosRetencion.ToString(),
                            Importe           = string.Format("{0}{1}",
                                                              Cancelacion ? string.Empty : "-",
                                                              "0"),
                            Renglon          = Convert.ToString(renglon),
                            ImporteIva       = "0",
                            Ref3             = ref3.ToString(),
                            CodigoRetencion  = retencion.IndicadorImpuesto,
                            TipoRetencion    = retencion.IndicadorRetencion,
                            ArchivoFolio     = archivoFolio,
                            DescripcionCosto = gastoInventario.Proveedor.Descripcion,
                            PesoOrigen       = 0,
                            TipoDocumento    = textoDocumento,
                            Concepto         =
                                String.Format("{0}-{1},{2}", tipoMovimiento,
                                              gastoInventario.FolioGasto
                                              , complementoConcepto),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaEntrada = GeneraRegistroPoliza(datos);
                        polizasGastosInventario.Add(polizaEntrada);
                        if (!gastoInventario.IVA)
                        {
                            renglon++;
                            datos = new DatosPolizaInfo
                            {
                                NumeroReferencia = numeroReferencia,
                                FechaEntrada     = gastoInventario.FechaGasto,
                                Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                                Division         = organizacion.Division,
                                ClaveProveedor   = gastoInventario.Proveedor.CodigoSAP,
                                ClaseDocumento   = postFijoRef3,
                                Importe          = string.Format("{0}",
                                                                 Cancelacion
                                                                        ? gastoInventario.Importe.ToString("F2")
                                                                        : (gastoInventario.Importe * -1).ToString("F2"))
                                ,
                                Renglon          = Convert.ToString(renglon),
                                ImporteIva       = "0",
                                Ref3             = ref3.ToString(),
                                ArchivoFolio     = archivoFolio,
                                DescripcionCosto = gastoInventario.Proveedor.Descripcion,
                                PesoOrigen       = 0,
                                TipoDocumento    = textoDocumento,
                                Concepto         =
                                    String.Format("{0}-{1},{2}", tipoMovimiento,
                                                  gastoInventario.FolioGasto
                                                  , complementoConcepto),
                                Sociedad = organizacion.Sociedad,
                                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                            };
                            polizaEntrada = GeneraRegistroPoliza(datos);
                            polizasGastosInventario.Add(polizaEntrada);
                            renglon++;
                            datos = new DatosPolizaInfo
                            {
                                NumeroReferencia = numeroReferencia,
                                FechaEntrada     = gastoInventario.FechaGasto,
                                Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                                Division         = organizacion.Division,
                                ClaseDocumento   = postFijoRef3,
                                Importe          = string.Format("{0}",
                                                                 Cancelacion
                                                                        ? (gastoInventario.Importe * -1).ToString("F2")
                                                                        : gastoInventario.Importe.ToString("F2")),
                                Renglon          = Convert.ToString(renglon),
                                ImporteIva       = "0",
                                Ref3             = ref3.ToString(),
                                Cuenta           = claveContableInfo.Valor,
                                ArchivoFolio     = archivoFolio,
                                DescripcionCosto = claveContableInfo.Descripcion,
                                PesoOrigen       = 0,
                                TipoDocumento    = textoDocumento,
                                Concepto         =
                                    String.Format("{0}-{1},{2}", tipoMovimiento,
                                                  gastoInventario.FolioGasto
                                                  , complementoConcepto),
                                Sociedad = organizacion.Sociedad,
                                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                            };
                            polizaEntrada = GeneraRegistroPoliza(datos);
                            polizasGastosInventario.Add(polizaEntrada);
                        }
                    }
                }
            }
            else
            {
                renglon++;
                var datos = new DatosPolizaInfo
                {
                    NumeroReferencia = numeroReferencia,
                    FechaEntrada     = gastoInventario.FechaGasto,
                    Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                    Division         = organizacion.Division,
                    ClaseDocumento   = postFijoRef3,
                    Importe          = string.Format("{0}", Cancelacion ? (gastoInventario.Importe * -1).ToString("F2")
                                                                               : gastoInventario.Importe.ToString("F2")),
                    Renglon          = Convert.ToString(renglon),
                    ImporteIva       = "0",
                    Ref3             = ref3.ToString(),
                    Cuenta           = claveContableInfo.Valor,
                    ArchivoFolio     = archivoFolio,
                    DescripcionCosto = claveContableInfo.Descripcion,
                    PesoOrigen       = 0,
                    TipoDocumento    = textoDocumento,
                    Concepto         =
                        String.Format("{0}-{1},{2}", tipoMovimiento,
                                      gastoInventario.FolioGasto
                                      , complementoConcepto),
                    Sociedad = organizacion.Sociedad,
                    Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                };
                polizaEntrada = GeneraRegistroPoliza(datos);
                polizasGastosInventario.Add(polizaEntrada);

                renglon++;

                datos = new DatosPolizaInfo
                {
                    NumeroReferencia = numeroReferencia,
                    FechaEntrada     = gastoInventario.FechaGasto,
                    Folio            = gastoInventario.FolioGasto.ToString(CultureInfo.InvariantCulture),
                    Division         = organizacion.Division,
                    ClaseDocumento   = postFijoRef3,
                    Importe          = string.Format("{0}", Cancelacion ? gastoInventario.Importe.ToString("F2")
                                                                           : (gastoInventario.Importe * -1).ToString("F2")),
                    CentroCosto      = gastoInventario.CentroCosto,
                    Renglon          = Convert.ToString(renglon),
                    ImporteIva       = "0",
                    Ref3             = ref3.ToString(),
                    Cuenta           = cuentaSapProvision.CuentaSAP,
                    ArchivoFolio     = archivoFolio,
                    DescripcionCosto = cuentaSapProvision.Descripcion,
                    PesoOrigen       = 0,
                    TipoDocumento    = textoDocumento,
                    Concepto         =
                        String.Format("{0}-{1},{2}", tipoMovimiento,
                                      gastoInventario.FolioGasto
                                      , complementoConcepto),
                    Sociedad = organizacion.Sociedad,
                    Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                };
                polizaEntrada = GeneraRegistroPoliza(datos);
                polizasGastosInventario.Add(polizaEntrada);
            }
            return(polizasGastosInventario);
        }
        private IList <PolizaInfo> ObtenerPoliza(SalidaProductoInfo salidaProducto)
        {
            var polizasSalida = new List <PolizaInfo>();

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

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

            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 = string.Format("{0}{1}", salidaProducto.FolioSalida, ObtenerNumeroReferencia);
            string numeroReferencia = ObtenerNumeroReferenciaFolio(salidaProducto.FolioSalida);

            IList <CuentaSAPInfo>          cuentasSAP         = ObtenerCuentasSAP();
            IList <ClaseCostoProductoInfo> almacenesProductos = ObtenerCostosProducto(salidaProducto.Almacen.AlmacenID);
            OrganizacionInfo organizacion = ObtenerOrganizacionIVA(salidaProducto.Organizacion.OrganizacionID);

            if (organizacion == null)
            {
                organizacion = new OrganizacionInfo
                {
                    TipoOrganizacion = new TipoOrganizacionInfo()
                };
            }

            ClaseCostoProductoInfo almacenProducto =
                almacenesProductos.FirstOrDefault(prod => prod.ProductoID == salidaProducto.Producto.ProductoId);

            if (almacenProducto == null)
            {
                throw new ExcepcionServicio(string.Format("{0} {1} {2}", "CUENTA PARA PRODUCTO",
                                                          salidaProducto.Producto.Descripcion, "NO CONFIGURADA"));
            }
            CuentaSAPInfo cuentaSAP =
                cuentasSAP.FirstOrDefault(cuenta => cuenta.CuentaSAPID == almacenProducto.CuentaSAPID);

            if (cuentaSAP == null)
            {
                cuentaSAP = new CuentaSAPInfo
                {
                    Descripcion = string.Empty,
                    CuentaSAP   = string.Empty
                };
            }

            ClaveContableInfo claveContableCosto = ObtenerCuentaInventario(salidaProducto.Organizacion.
                                                                           OrganizacionID,
                                                                           TipoPoliza.ConsumoAlimento);

            if (claveContableCosto == null)
            {
                throw new ExcepcionServicio(string.Format("{0}", "CUENTA DE COSTO NO CONFIGURADA"));
            }
            ClaveContableInfo claveContableBeneficios = ObtenerCuentaInventario(salidaProducto.Organizacion.
                                                                                OrganizacionID,
                                                                                TipoPoliza.SalidaVentaProducto);

            if (claveContableBeneficios == null)
            {
                throw new ExcepcionServicio(string.Format("{0}", "CUENTA DE BENEFICIOS NO CONFIGURADA"));
            }

            ParametroOrganizacionInfo parametroCentroCosto =
                ObtenerParametroOrganizacionPorClave(organizacion.OrganizacionID,
                                                     ParametrosEnum.CTACENTROCOSTOMP.ToString());

            if (parametroCentroCosto == null)
            {
                throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE COSTO NO CONFIGURADO"));
            }

            ParametroOrganizacionInfo parametroCentroBeneficio =
                ObtenerParametroOrganizacionPorClave(organizacion.OrganizacionID,
                                                     ParametrosEnum.CTACENTROBENEFICIOMP.ToString());

            if (parametroCentroBeneficio == null)
            {
                throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE BENEFICIO NO CONFIGURADO"));
            }

            string archivoFolio = ObtenerArchivoFolio(salidaProducto.FechaSalida);
            int    cantidad     = salidaProducto.PesoBruto - salidaProducto.PesoTara;

            var almacenMovimientoDetalleBL = new AlmacenMovimientoDetalleBL();

            AlmacenMovimientoDetalle detalleMovimiento =
                almacenMovimientoDetalleBL.ObtenerPorAlmacenMovimientoID(
                    salidaProducto.AlmacenMovimiento.AlmacenMovimientoID);

            if (detalleMovimiento == null)
            {
                detalleMovimiento = new AlmacenMovimientoDetalle();
            }

            if (unidades == null)
            {
                unidades = ObtenerUnidadesMedicion();
            }
            if (productos == null)
            {
                productos = ObtenerProductos();
            }
            ProductoInfo producto =
                productos.FirstOrDefault(clave => clave.ProductoId == salidaProducto.Producto.ProductoId);

            if (producto == null)
            {
                producto = new ProductoInfo();
            }
            switch ((SubFamiliasEnum)producto.SubfamiliaId)
            {
            case SubFamiliasEnum.Granos:
                claveContableBeneficios.Valor = string.Concat(claveContableBeneficios.Valor,
                                                              PostFijoSubFamiliaGranos);
                claveContableCosto.Valor = string.Concat(claveContableCosto.Valor, PostFijoSubFamiliaGranos);
                break;

            default:
                claveContableBeneficios.Valor = string.Concat(claveContableBeneficios.Valor,
                                                              PostFijoSubFamiliaNoGranos);
                claveContableCosto.Valor = string.Concat(claveContableCosto.Valor, PostFijoSubFamiliaNoGranos);
                break;
            }
            var traspaso = false;

            if (salidaProducto.TipoMovimiento.TipoMovimientoID == TipoMovimiento.ProductoSalidaTraspaso.GetHashCode() ||
                salidaProducto.TipoMovimiento.Descripcion.Equals("salida por traspaso", StringComparison.InvariantCultureIgnoreCase))
            {
                salidaProducto.Cliente = new ClienteInfo
                {
                    CodigoSAP   = salidaProducto.CuentaSAP.CuentaSAP,
                    Descripcion = salidaProducto.CuentaSAP.Descripcion
                };
                traspaso = true;
            }
            string unidad = unidades.Where(clave => clave.UnidadID == producto.UnidadId).
                            Select(uni => uni.ClaveUnidad).FirstOrDefault();
            var datos = new DatosPolizaInfo
            {
                NumeroReferencia = numeroReferencia,
                FechaEntrada     = salidaProducto.FechaSalida,
                Folio            = salidaProducto.FolioSalida.ToString(),
                Cliente          = traspaso ? string.Empty : salidaProducto.Cliente.CodigoSAP,
                Cuenta           = traspaso ? salidaProducto.Cliente.CodigoSAP : string.Empty,
                Importe          = string.Format("{0}", salidaProducto.Importe.ToString("F2")),
                Renglon          = Convert.ToString(linea++),
                ImporteIva       = "0",
                ClaseDocumento   = postFijoRef3,
                Ref3             = ref3.ToString(),
                Division         = organizacion.Division,
                ArchivoFolio     = archivoFolio,
                DescripcionCosto = salidaProducto.Cliente.Descripcion,
                PesoOrigen       = cantidad,
                TipoDocumento    = textoDocumento,
                Concepto         = String.Format("{0}-{1} {2} {3} {4}",
                                                 tipoMovimiento,
                                                 salidaProducto.FolioSalida, cantidad.ToString("N0"),
                                                 unidad,
                                                 cuentaSAP.Descripcion),
                Sociedad = organizacion.Sociedad,
                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad)
            };
            PolizaInfo polizaSalida = GeneraRegistroPoliza(datos);

            polizasSalida.Add(polizaSalida);

            datos = new DatosPolizaInfo
            {
                NumeroReferencia = numeroReferencia,
                FechaEntrada     = salidaProducto.FechaSalida,
                Folio            = salidaProducto.FolioSalida.ToString(),
                Importe          = (detalleMovimiento.Importe * -1).ToString("F2"),
                Renglon          = Convert.ToString(linea++),
                ImporteIva       = "0",
                Ref3             = ref3.ToString(),
                Cuenta           = cuentaSAP.CuentaSAP,
                DescripcionCosto = cuentaSAP.Descripcion,
                Division         = organizacion.Division,
                ArchivoFolio     = archivoFolio,
                PesoOrigen       = cantidad,
                ClaseDocumento   = postFijoRef3,
                TipoDocumento    = textoDocumento,
                Concepto         = String.Format("{0}-{1} {2} {3} {4}",
                                                 tipoMovimiento,
                                                 salidaProducto.FolioSalida, cantidad.ToString("N0"),
                                                 unidad,
                                                 cuentaSAP.Descripcion),
                Sociedad = organizacion.Sociedad,
                Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad)
            };
            polizaSalida = GeneraRegistroPoliza(datos);
            polizasSalida.Add(polizaSalida);

            if (!traspaso)
            {
                cuentaSAP = cuentasSAP.FirstOrDefault(cuenta => cuenta.CuentaSAP == claveContableCosto.Valor);
                if (cuentaSAP == null)
                {
                    throw new ExcepcionServicio("CUENTA DE COSTO NO CONFIGURADA");
                }
                datos = new DatosPolizaInfo
                {
                    NumeroReferencia = numeroReferencia,
                    FechaEntrada     = salidaProducto.FechaSalida,
                    Folio            = salidaProducto.FolioSalida.ToString(),
                    Importe          = detalleMovimiento.Importe.ToString("F2"),
                    Renglon          = Convert.ToString(linea++),
                    ImporteIva       = "0",
                    Ref3             = ref3.ToString(),
                    Cuenta           = cuentaSAP.CuentaSAP,
                    Division         = organizacion.Division,
                    ArchivoFolio     = archivoFolio,
                    DescripcionCosto = cuentaSAP.Descripcion,
                    CentroCosto      =
                        claveContableCosto.Valor.StartsWith(PrefijoCuentaCentroCosto) ||
                        claveContableCosto.Valor.StartsWith(PrefijoCuentaCentroGasto)
                                       ? parametroCentroCosto.Valor
                                       : string.Empty,
                    //CentroBeneficio =
                    //    claveContableBeneficios.Valor.StartsWith(PrefijoCuentaCentroBeneficio)
                    //        ? parametroCentroBeneficio.Valor
                    //        : string.Empty,
                    PesoOrigen     = cantidad,
                    ClaseDocumento = postFijoRef3,
                    TipoDocumento  = textoDocumento,
                    Concepto       = String.Format("{0}-{1} {2} {3} {4}",
                                                   tipoMovimiento,
                                                   salidaProducto.FolioSalida, cantidad.ToString("N0"),
                                                   unidad,
                                                   cuentaSAP.Descripcion),
                    Sociedad = organizacion.Sociedad,
                    Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad)
                };
                polizaSalida = GeneraRegistroPoliza(datos);
                polizasSalida.Add(polizaSalida);

                cuentaSAP = cuentasSAP.FirstOrDefault(cuenta => cuenta.CuentaSAP == claveContableBeneficios.Valor);
                if (cuentaSAP == null)
                {
                    throw new ExcepcionServicio("CUENTA DE BENEFICIOS NO CONFIGURADA");
                }
                datos = new DatosPolizaInfo
                {
                    NumeroReferencia = numeroReferencia,
                    FechaEntrada     = salidaProducto.FechaSalida,
                    Folio            = salidaProducto.FolioSalida.ToString(),
                    Importe          = string.Format("{0}", (salidaProducto.Importe * -1).ToString("F2")),
                    Renglon          = Convert.ToString(linea),
                    ImporteIva       = "0",
                    Ref3             = ref3.ToString(),
                    Cuenta           = cuentaSAP.CuentaSAP,
                    Division         = organizacion.Division,
                    ArchivoFolio     = archivoFolio,
                    DescripcionCosto = cuentaSAP.Descripcion,
                    //CentroCosto =
                    //    claveContableCosto.Valor.StartsWith(PrefijoCuentaCentroCosto) ||
                    //    claveContableCosto.Valor.StartsWith(PrefijoCuentaCentroGasto)
                    //        ? parametroCentroCosto.Valor
                    //        : string.Empty,
                    CentroBeneficio =
                        claveContableBeneficios.Valor.StartsWith(PrefijoCuentaCentroBeneficio)
                                        ? parametroCentroBeneficio.Valor
                                        : string.Empty,
                    PesoOrigen     = cantidad,
                    ClaseDocumento = postFijoRef3,
                    TipoDocumento  = textoDocumento,
                    Concepto       = String.Format("{0}-{1} {2} {3} {4}",
                                                   tipoMovimiento,
                                                   salidaProducto.FolioSalida, cantidad.ToString("N0"),
                                                   unidad,
                                                   cuentaSAP.Descripcion),
                    Sociedad = organizacion.Sociedad,
                    Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad)
                };
                polizaSalida = GeneraRegistroPoliza(datos);
                polizasSalida.Add(polizaSalida);
            }

            return(polizasSalida);
        }
        private IList <PolizaInfo> ObtenerPoliza(GanadoIntensivoInfo ganadoIntensivo)
        {
            var polizasSalidaMuerteIntensiva = new List <PolizaInfo>();

            if (ganadoIntensivo.ListaGanadoIntensivoCosto != null && ganadoIntensivo.ListaGanadoIntensivoCosto.Any())
            {
                TipoPolizaInfo tipoPoliza =
                    TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == TipoPoliza.SalidaMuerteIntensiva.GetHashCode());
                if (tipoPoliza == null)
                {
                    throw new ExcepcionServicio(string.Format("{0} {1}", "EL TIPO DE POLIZA",
                                                              TipoPoliza.SalidaMuerteIntensiva));
                }
                string textoDocumento = tipoPoliza.TextoDocumento;
                string tipoMovimiento = tipoPoliza.ClavePoliza;
                string postFijoRef3   = tipoPoliza.PostFijoRef3;

                int 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();
                }

                foreach (var ganadoIntensivoCostoInfo in ganadoIntensivo.ListaGanadoIntensivoCosto)
                {
                    CostoInfo costo =
                        costos.FirstOrDefault(tipo => tipo.CostoID == ganadoIntensivoCostoInfo.Costos.CostoID);
                    if (costo == null)
                    {
                        costo = new CostoInfo();
                    }
                    //= ObtenerOrganizacionIVA(ganadoIntensivo.Organizacion.OrganizacionID);


                    OrganizacionInfo organizacion = ObtenerOrganizacionSociedadDivision(ganadoIntensivo.Organizacion.OrganizacionID, SociedadEnum.SuKarne);
                    if (organizacion == null)
                    {
                        organizacion = new OrganizacionInfo
                        {
                            TipoOrganizacion = new TipoOrganizacionInfo()
                        };
                    }

                    const int Corral_Intensivo = 4;
                    const int Corral_Maquila   = 6;

                    int tipoOrganizacioID = 0;

                    switch (ganadoIntensivo.Lote.TipoCorralID)
                    {
                    case Corral_Intensivo:
                        tipoOrganizacioID = TipoOrganizacion.Intensivo.GetHashCode();
                        break;

                    case Corral_Maquila:
                        tipoOrganizacioID = TipoOrganizacion.Maquila.GetHashCode();
                        break;
                    }
                    if (tipoOrganizacioID > 0)
                    {
                        organizacion.TipoOrganizacion.TipoOrganizacionID = tipoOrganizacioID;
                    }


                    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.SalidaMuerteIntensiva);
                    if (claveContableCargo == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA EL COSTO",
                                                                  costo.Descripcion));
                    }
                    ParametroOrganizacionInfo parametroCentroCosto =
                        ObtenerParametroOrganizacionPorClave(organizacion.OrganizacionID,
                                                             ParametrosEnum.CTACENTROCTOINT.ToString());
                    if (parametroCentroCosto == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE COSTO NO CONFIGURADO"));
                    }
                    EntradaGanadoInfo entradaGanado = ganadoIntensivo.EntradaGanado;
                    var pesoMuerteTotal             = Math.Round(((entradaGanado.PesoBruto - entradaGanado.PesoTara) / entradaGanado.CabezasRecibidas) * ganadoIntensivo.Cabezas, 0);
                    //VALIDAR FECHA
                    DateTime fecha = DateTime.Today;
                    if (fecha != null)
                    {
                        string archivoFolio = ObtenerArchivoFolio(fecha);
                        var    datos        = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = fecha,
                            Folio            = ganadoIntensivo.FolioTicket.ToString(),
                            Importe          = string.Format("{0}", ganadoIntensivoCostoInfo.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} CABEZAS {2} kgs",
                                                            tipoMovimiento,
                                                            ganadoIntensivo.Cabezas, pesoMuerteTotal),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        PolizaInfo polizaSalida = GeneraRegistroPoliza(datos);
                        polizasSalidaMuerteIntensiva.Add(polizaSalida);

                        datos = new DatosPolizaInfo
                        {
                            NumeroReferencia = numeroReferencia,
                            FechaEntrada     = fecha,
                            Folio            = ganadoIntensivo.FolioTicket.ToString(),
                            Importe          = string.Format("{0}", (ganadoIntensivoCostoInfo.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}, CABEZAS, {2} kgs",
                                                           tipoMovimiento,
                                                           ganadoIntensivo.Cabezas, pesoMuerteTotal),
                            Sociedad = organizacion.Sociedad,
                            Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                        };
                        polizaSalida = GeneraRegistroPoliza(datos);
                        polizasSalidaMuerteIntensiva.Add(polizaSalida);
                    }
                }
            }

            return(polizasSalidaMuerteIntensiva);
        }
Beispiel #9
0
        private IList <PolizaInfo> ObtenerPoliza(List <ContenedorAlmacenMovimientoCierreDia> contenedor)
        {
            var polizasConsumo = new List <PolizaInfo>();
            IList <CuentaSAPInfo> cuentasSap = ObtenerCuentasSAP();

            int organizacionID            = contenedor[0].Almacen.Organizacion.OrganizacionID;
            int almacenID                 = contenedor[0].Almacen.AlmacenID;
            OrganizacionInfo organizacion = ObtenerOrganizacionIVA(organizacionID);
            int tipoOrigenID              = organizacion.TipoOrganizacion.TipoProceso.TipoProcesoID;

            IList <CostoInfo> costos = ObtenerCostos();

            IList <CuentaAlmacenSubFamiliaInfo> cuentasSubFamilia;

            var movimientos = contenedor.GroupBy(prod => new { prod.Producto.ProductoId, prod.Producto.Descripcion })
                              .Select(mov => new
            {
                Importe           = mov.Sum(det => det.AlmacenMovimientoDetalle.Importe),
                ProductoID        = mov.Key.ProductoId,
                Producto          = mov.Key.Descripcion,
                FechaMovimiento   = mov.Select(fech => fech.AlmacenMovimiento.FechaMovimiento).FirstOrDefault(),
                SubFamilia        = mov.Select(sf => sf.Producto.SubFamilia.Descripcion).FirstOrDefault(),
                SubFamiliaID      = mov.Select(sf => sf.Producto.SubFamilia.SubFamiliaID).FirstOrDefault(),
                Familia           = mov.Select(fam => fam.Producto.SubFamilia.Familia.Descripcion).FirstOrDefault(),
                TipoTratamientoID = mov.Select(trat => trat.AlmacenMovimientoDetalle.Tratamiento.TipoTratamientoInfo.TipoTratamientoID).FirstOrDefault(),
                TipoTratamiento   = mov.Select(trat => trat.AlmacenMovimientoDetalle.Tratamiento.TipoTratamientoInfo.Descripcion).FirstOrDefault(),
                Almacen           = mov.Select(alm => alm.Almacen.Descripcion).FirstOrDefault(),
                AlmacenID         = mov.Select(alm => alm.Almacen.AlmacenID).FirstOrDefault(),
                FolioAlmacen      = mov.Select(folio => folio.FolioAlmacen).FirstOrDefault()
            }).ToList();
            TipoPolizaInfo tipoPoliza =
                TiposPoliza.FirstOrDefault(clave => clave.TipoPolizaID == TipoPoliza.ConsumoProducto.GetHashCode());

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

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

            const int TIPO_COSTO = 3;
            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);

            ParametroOrganizacionInfo parametroOrganizacion =
                ObtenerParametroOrganizacionPorClave(organizacion.OrganizacionID,
                                                     ParametrosEnum.CTACENTROCOSTOENG.ToString());
            string numeroDocumento = ObtenerNumeroReferencia;

            var archivoFolio = string.Empty;
            var filtros      = new FiltroCierreDiaInventarioInfo
            {
                AlmacenID        = almacenID,
                TipoMovimientoID = TipoMovimiento.DiferenciasDeInventario.GetHashCode()
            };
            var almacenBL           = new AlmacenBL();
            int folioAlmacen        = almacenBL.ObtenerFolioAlmacenConsulta(filtros);
            var almacenMovimientoBL = new AlmacenMovimientoBL();

            almacenMovimientoBL.ActualizarFolioAlmacen(almacenID);
            if (movimientos.Any())
            {
                var folioRef = new StringBuilder();
                folioRef.Append(almacenID.ToString(CultureInfo.InvariantCulture).PadLeft(3, '0'));
                folioRef.Append(folioAlmacen.ToString(CultureInfo.InvariantCulture).PadLeft(7, '0'));
                DateTime fecha = movimientos[0].FechaMovimiento;
                archivoFolio    = ObtenerArchivoFolio(fecha);
                numeroDocumento = folioRef.ToString();

                for (var indexMovimientos = 0; indexMovimientos < movimientos.Count; indexMovimientos++)
                {
                    var       mov = movimientos[indexMovimientos];
                    string    descripcionMovimiento = ObtenerDescripcionMovimiento(mov.TipoTratamientoID);
                    CostoInfo costo =
                        costos.FirstOrDefault(
                            tipo =>
                            tipo.TipoCosto.TipoCostoID == TIPO_COSTO &&
                            tipo.Descripcion.IndexOf(descripcionMovimiento, StringComparison.InvariantCultureIgnoreCase) >=
                            0);
                    if (costo == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA",
                                                                  descripcionMovimiento));
                    }
                    ClaveContableInfo claveContable = ObtenerCuentaInventario(costo, organizacionID, tipoOrigenID);
                    if (claveContable == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA EL COSTO",
                                                                  costo.Descripcion));
                    }
                    var datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroDocumento,
                        FechaEntrada     = mov.FechaMovimiento,
                        Importe          = string.Format("{0}", mov.Importe.ToString("F2")),
                        Renglon          = Convert.ToString(linea++),
                        Division         = organizacion.Division,
                        ImporteIva       = "0",
                        ClaseDocumento   = postFijoRef3,
                        Ref3             = ref3.ToString(),
                        Cuenta           = claveContable.Valor,
                        ArchivoFolio     = archivoFolio,
                        DescripcionCosto = claveContable.Descripcion,
                        CentroCosto      =
                            claveContable.Valor.StartsWith(PrefijoCuentaCentroCosto)
                                                ? parametroOrganizacion.Valor
                                                : string.Empty,
                        PesoOrigen    = 0,
                        TipoDocumento = textoDocumento,
                        Folio         = folioAlmacen.ToString(),
                        Concepto      = String.Format("{0}-{1} {2}",
                                                      tipoMovimiento,
                                                      folioAlmacen,
                                                      mov.Producto),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    PolizaInfo polizaConsumo = GeneraRegistroPoliza(datos);
                    polizasConsumo.Add(polizaConsumo);
                }
            }

            movimientos = contenedor.GroupBy(prod => new { prod.Producto.SubFamilia.SubFamiliaID }).Select(mov => new
            {
                Importe         = mov.Sum(det => det.AlmacenMovimientoDetalle.Importe),
                ProductoID      = 0,
                Producto        = string.Empty,
                FechaMovimiento = mov.Select(fech => fech.AlmacenMovimiento.FechaMovimiento).FirstOrDefault(),
                SubFamilia      = mov.Select(sf => sf.Producto.SubFamilia.Descripcion).FirstOrDefault(),
                mov.Key.SubFamiliaID,
                Familia           = mov.Select(fam => fam.Producto.SubFamilia.Familia.Descripcion).FirstOrDefault(),
                TipoTratamientoID = mov.Select(trat => trat.AlmacenMovimientoDetalle.Tratamiento.TipoTratamientoInfo.TipoTratamientoID).FirstOrDefault(),
                TipoTratamiento   = mov.Select(trat => trat.AlmacenMovimientoDetalle.Tratamiento.TipoTratamientoInfo.Descripcion).FirstOrDefault(),
                Almacen           = mov.Select(alm => alm.Almacen.Descripcion).FirstOrDefault(),
                AlmacenID         = mov.Select(alm => alm.Almacen.AlmacenID).FirstOrDefault(),
                FolioAlmacen      = mov.Select(folio => folio.FolioAlmacen).FirstOrDefault()
            }).ToList();
            if (movimientos != null && movimientos.Any())
            {
                CuentaSAPInfo cuentaSap;
                CuentaAlmacenSubFamiliaInfo cuentaSubFamilia;

                for (var indexMovimientos = 0; indexMovimientos < movimientos.Count; indexMovimientos++)
                {
                    var       mov = movimientos[indexMovimientos];
                    string    descripcionMovimiento = ObtenerDescripcionMovimiento(mov.TipoTratamientoID);
                    CostoInfo costo =
                        costos.FirstOrDefault(
                            tipo =>
                            tipo.TipoCosto.TipoCostoID == TIPO_COSTO &&
                            tipo.Descripcion.IndexOf(descripcionMovimiento, StringComparison.InvariantCultureIgnoreCase) >=
                            0);
                    if (costo == null)
                    {
                        costo = new CostoInfo();
                    }
                    ClaveContableInfo claveContable = ObtenerCuentaInventario(costo, organizacionID, tipoOrigenID);
                    if (claveContable == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0} {1}", "NO EXISTE CONFIGURACION PARA EL COSTO",
                                                                  costo.Descripcion));
                    }
                    cuentasSubFamilia = ObtenerCostosSubFamilia(mov.AlmacenID);
                    if (cuentasSubFamilia == null)
                    {
                        cuentasSubFamilia = new List <CuentaAlmacenSubFamiliaInfo>();
                    }
                    cuentaSubFamilia = cuentasSubFamilia.FirstOrDefault(clave => clave.SubFamiliaID == mov.SubFamiliaID);
                    if (cuentaSubFamilia == null)
                    {
                        cuentaSubFamilia = new CuentaAlmacenSubFamiliaInfo();
                    }
                    cuentaSap = cuentasSap.FirstOrDefault(clave => clave.CuentaSAPID == cuentaSubFamilia.CuentaSAPID);
                    if (cuentaSap == null)
                    {
                        throw new ExcepcionServicio(string.Format("CUENTA NO CONFIGURADA PARA EL PRODUCTO {0}",
                                                                  mov.Producto));
                    }
                    var datos = new DatosPolizaInfo
                    {
                        NumeroReferencia = numeroDocumento,
                        FechaEntrada     = mov.FechaMovimiento,
                        Importe          = string.Format("{0}", (mov.Importe * -1).ToString("F2")),
                        Renglon          = Convert.ToString(linea++),
                        ImporteIva       = "0",
                        ClaseDocumento   = postFijoRef3,
                        Division         = organizacion.Division,
                        Ref3             = ref3.ToString(),
                        Cuenta           = cuentaSap.CuentaSAP,
                        ArchivoFolio     = archivoFolio,
                        CentroCosto      =
                            cuentaSap.CuentaSAP.StartsWith(PrefijoCuentaCentroCosto)
                                                ? parametroOrganizacion.Valor
                                                : string.Empty,
                        DescripcionCosto = cuentaSap.Descripcion,
                        PesoOrigen       = 0,
                        TipoDocumento    = textoDocumento,
                        ComplementoRef1  = string.Empty,
                        Folio            = folioAlmacen.ToString(),
                        Concepto         = String.Format("{0}-{1} {2}",
                                                         tipoMovimiento,
                                                         folioAlmacen,
                                                         mov.Producto),
                        Sociedad = organizacion.Sociedad,
                        Segmento = string.Format("{0}{1}", PrefijoSegmento, organizacion.Sociedad),
                    };
                    PolizaInfo polizaConsumo = GeneraRegistroPoliza(datos);
                    polizasConsumo.Add(polizaConsumo);
                }
            }
            return(polizasConsumo);
        }
Beispiel #10
0
        /// <summary>
        /// Metodo para armar los objetos para generar poliza
        /// </summary>
        /// <param name="datosPoliza">Objeto salidaGanadotransitoInfo</param>
        /// <returns>poliza</returns>
        public override IList <PolizaInfo> GeneraPoliza(object datosPoliza)
        {
            IList <PolizaInfo> polizaSalida = new List <PolizaInfo>();

            var noLinea         = 1;
            var costosPl        = new CostoPL();
            var cliente         = new ClientePL();
            var cuentasSap      = ObtenerCuentasSAP();
            var interfaceBl     = new InterfaceSalidaBL();
            var parOrganizacion = new ParametroOrganizacionBL();
            var parametroCentro = new ParametroOrganizacionInfo();
            var input           = (SalidaGanadoEnTransitoInfo)datosPoliza;
            var costosClaves    = costosPl.ObtenerTodos(EstatusEnum.Activo);
            var costoAbono      = new CostoInfo {
                ClaveContable = string.Empty
            };
            var costoGanado = input.Costos.FirstOrDefault(x => x.CostoID == Costo.CostoGanado.GetHashCode());
            var claveCuenta = parOrganizacion.ObtenerPorOrganizacionIDClaveParametro(input.OrganizacionID, ParametrosEnum.CTAFALTANTESOBRANTE.ToString());

            ClaveContableInfo clavecontablecargo;

            detalles      = input.DetallesSalida;
            datos         = obtenerDatosPolizaSalidaPorVenta(input);
            input.Cliente = cliente.ObtenerPorID(input.Cliente.ClienteID);

            //la var datos debe contener datos para poder acceder a su valor en la propiedad PostFijoRef3
            var ref3         = Ref3(input);
            var archivoFolio = ArchivoFolio(input);

            #region linea1(+) Proveedor
            var linea1 = InicializarPolizaInfo(input, ref3, archivoFolio, noLinea);
            linea1.Importe = input.Importe.ToString("N", CultureInfo.InvariantCulture);
            linea1.Cliente = input.Cliente.CodigoSAP;
            //linea1.Cuenta = input.Cliente.CodigoSAP;
            polizaSalida.Add(linea1);
            noLinea++;
            #endregion

            #region linea2(-) Beneficiario
            var linea2 = InicializarPolizaInfo(input, ref3, archivoFolio, noLinea);
            //linea2.Cliente = input.Cliente.CodigoSAP;
            linea2.Importe = "-" + input.Importe.ToString("N", CultureInfo.InvariantCulture);
            var claveContableAbono = interfaceBl.ObtenerCuentaInventario(costoAbono, input.OrganizacionID, ClaveCuenta.CuentaBeneficioInventario);

            if (claveContableAbono != null)
            {
                var cuentaSap = cuentasSap.FirstOrDefault(clave => clave.CuentaSAP == claveContableAbono.Valor);
                claveContableAbono.Descripcion = cuentaSap == null ? string.Empty : cuentaSap.Descripcion;
            }
            else
            {
                claveContableAbono = new ClaveContableInfo
                {
                    Valor = string.Empty
                };
            }

            var beneficio = false;
            if (claveContableAbono.Valor.StartsWith(PrefijoCuentaCentroBeneficio))
            {
                parametroCentro = ObtenerParametroOrganizacionPorClave(input.OrganizacionID, ParametrosEnum.CTACENTROBENEFICIOENG.ToString());

                if (parametroCentro == null)
                {
                    throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE BENEFICIO NO CONFIGURADO"));
                }
                beneficio = true;
            }
            else
            {
                if (claveContableAbono.Valor.StartsWith(PrefijoCuentaCentroCosto) || claveContableAbono.Valor.StartsWith(PrefijoCuentaCentroGasto))
                {
                    parametroCentro = ObtenerParametroOrganizacionPorClave(input.OrganizacionID, ParametrosEnum.CTACENTROCOSTOENG.ToString());

                    if (parametroCentro == null)
                    {
                        throw new ExcepcionServicio(string.Format("{0}", "CENTRO DE BENEFICIO NO CONFIGURADO"));
                    }
                }
            }
            if (beneficio)
            {
                linea2.CentroBeneficio = parametroCentro.Valor;
            }
            else
            {
                linea2.CentroCosto = parametroCentro.Valor;
            }

            linea2.Cuenta = claveContableAbono.Valor;
            polizaSalida.Add(linea2);
            noLinea++;
            #endregion

            #region linea3 cargo a cuenta costo ganado(-)
            //se elimino esta linea
            #endregion

            #region linea4 cargo a costo corral(-)
            if (costoGanado == null)
            {
                return(polizaSalida);
            }

            var linea4 = InicializarPolizaInfo(input, ref3, archivoFolio, noLinea);
            linea4.Cuenta = claveCuenta.Valor;

            if (claveCuenta.Valor.Substring(0, 4) == "5001")
            {
                linea4.CentroCosto = datos.ParametroOrganizacionValor;
            }

            var importeCostos = input.DetallesSalida.Sum(costo => costo.ImporteCosto);

            linea4.Importe = "-" + importeCostos.ToString(CultureInfo.InvariantCulture);
            polizaSalida.Add(linea4);
            noLinea++;
            #endregion

            #region linea5 cargoACuentaResultados (-)(importe total)
            var linea5 = InicializarPolizaInfo(input, ref3, archivoFolio, noLinea);

            if (claveCuenta.Valor.Substring(0, 4) == "5001")
            {
                linea5.CentroCosto = datos.ParametroOrganizacionValor;
            }

            var salidaVentaTransito = input.DetallesSalida.FirstOrDefault(detalle => detalle.CostoId == Costo.CostoGanado.GetHashCode());
            if (salidaVentaTransito != null)
            {
                linea5.Importe = salidaVentaTransito.ImporteCosto.ToString(CultureInfo.InvariantCulture);
            }

            costos = ObtenerCostos();
            var firstOrDefault = costos.FirstOrDefault(x => x.CostoID == costoGanado.CostoID);

            if (firstOrDefault != null)
            {
                costoAbono.ClaveContable = firstOrDefault.ClaveContable;
                clavecontablecargo       = ObtenerCuentaInventario(costoAbono, input.OrganizacionID, TipoPoliza.PolizaMuerteTransito);
                if (clavecontablecargo != null)
                {
                    linea5.Cuenta = clavecontablecargo.Valor;
                }
            }

            polizaSalida.Add(linea5);
            noLinea++;
            #endregion

            #region linea6 abono a cuenta Resultados a la misma cuenta que el punto anterior en foreach
            var linea6 = new List <PolizaInfo>();

            foreach (var costoCargo in input.DetallesSalida.SkipWhile(costo => costo.CostoId == Costo.CostoGanado.GetHashCode()))
            {
                var temp = InicializarPolizaInfo(input, ref3, archivoFolio, noLinea);
                temp.Importe = costoCargo.ImporteCosto.ToString(CultureInfo.InvariantCulture);

                var claveCosto = costosClaves.FirstOrDefault(x => x.CostoID == costoCargo.CostoId);
                if (claveCosto != null)
                {
                    costoAbono.ClaveContable = claveCosto.ClaveContable;
                    clavecontablecargo       = ObtenerCuentaInventario(costoAbono, input.OrganizacionID, TipoPoliza.PolizaMuerteTransito);
                    if (clavecontablecargo != null)
                    {
                        temp.Cuenta = clavecontablecargo.Valor;
                    }
                }

                if (claveCuenta.Valor.Substring(0, 4) == "5001")
                {
                    temp.CentroCosto = datos.ParametroOrganizacionValor;
                }

                linea6.Add(temp);
                noLinea++;
            }

            foreach (var polizaItem in linea6)
            {
                polizaSalida.Add(polizaItem);
            }
            #endregion

            return(polizaSalida);
        }