示例#1
0
        public void CostoObtenerPorIdExistente()
        {
            var       pl    = new CostoPL();
            CostoInfo costo = pl.ObtenerPorID(1);

            Assert.AreNotEqual(costo, null);
        }
示例#2
0
        public void CostoCrear()
        {
            var random       = new Random();
            int randomNumber = random.Next(0, 100);

            string descripcion = string.Format("Prueba Unitaria Crear {0:D10}", randomNumber);

            var pl    = new CostoPL();
            var costo = new CostoInfo
            {
                CostoID           = 0,
                Descripcion       = descripcion,
                ClaveContable     = string.Format("{0:D3}", randomNumber),
                UsuarioCreacionID = 1,
                TipoCosto         = new TipoCostoInfo {
                    TipoCostoID = 1
                },
                TipoProrrateo = new TipoProrrateoInfo {
                    TipoProrrateoID = 1
                },
                Retencion = new RetencionInfo {
                    RetencionID = 1
                },
                Activo = EstatusEnum.Activo
            };

            pl.Crear(costo);
            costo = pl.ObtenerPorDescripcion(descripcion);
            Assert.AreNotEqual(costo.CostoID, 0);
        }
示例#3
0
        public void CostoObtenerTodosActivos()
        {
            var pl = new CostoPL();
            IList <CostoInfo> lista = pl.ObtenerTodos(EstatusEnum.Activo);

            Assert.AreNotEqual(lista, null);
        }
示例#4
0
        public void CostoObtenerPorId()
        {
            var       pl    = new CostoPL();
            CostoInfo costo = pl.ObtenerPorID(0);

            Assert.AreEqual(costo, null);
        }
示例#5
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);
        }
示例#6
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);
            }
        }
示例#7
0
 /// <summary>
 /// Obtiene una Lista de Productos
 /// </summary>
 /// <param name="inicio"></param>
 /// <param name="limite"></param>
 private void ObtenerCostos(int inicio, int limite)
 {
     try
     {
         if (ucPaginacion.ContextoAnterior != null)
         {
             bool contextosIguales = ucPaginacion.CompararObjetos(Contexto, ucPaginacion.ContextoAnterior);
             if (!contextosIguales)
             {
                 ucPaginacion.Inicio = 1;
                 inicio = 1;
             }
         }
         var costoPL = new CostoPL();
         var pagina  = new PaginacionInfo {
             Inicio = inicio, Limite = limite
         };
         ResultadoInfo <CostoInfo> resultadoInfo = costoPL.ObtenerPorPagina(pagina, Contexto);
         if (resultadoInfo != null && resultadoInfo.Lista != null &&
             resultadoInfo.Lista.Count > 0)
         {
             gridDatos.ItemsSource       = resultadoInfo.Lista;
             ucPaginacion.TotalRegistros = resultadoInfo.TotalRegistros;
         }
         else
         {
             ucPaginacion.TotalRegistros = 0;
             gridDatos.ItemsSource       = new List <CostoInfo>();
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                           Properties.Resources.Costo_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(Application.Current.Windows[ConstantesVista.WindowPrincipal],
                           Properties.Resources.Costo_ErrorBuscar, MessageBoxButton.OK, MessageImage.Error);
     }
 }
示例#8
0
 /// <summary>
 /// Guardar un Nuevo Costo
 /// </summary>
 private void Guardar()
 {
     try
     {
         bool guardar = ValidaGuardar();
         if (guardar)
         {
             var costoPL = new CostoPL();
             costoPL.Crear(Contexto);
             SkMessageBox.Show(this, Properties.Resources.GuardadoConExito, MessageBoxButton.OK,
                               MessageImage.Correct);
             if (Contexto.CostoID != 0)
             {
                 confirmaSalir = false;
                 Close();
             }
             else
             {
                 var contextoClone = Extensor.ClonarInfo(Contexto) as CostoInfo;
                 InicializaContexto();
                 AsignarValoresContexto(contextoClone);
             }
         }
     }
     catch (ExcepcionGenerica)
     {
         SkMessageBox.Show(this, Properties.Resources.Producto_ErrorGuardar, MessageBoxButton.OK,
                           MessageImage.Error);
     }
     catch (Exception ex)
     {
         Logger.Error(ex);
         SkMessageBox.Show(this, Properties.Resources.Producto_ErrorGuardar, MessageBoxButton.OK,
                           MessageImage.Error);
     }
 }
示例#9
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);
            }
        }
示例#10
0
        /// <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 los nodos correspondientes a la poliza de una salida de ganado en transito por muerte
        /// </summary>
        /// <param name="datosPoliza">El objeto SalidaGanadoEnTransitoInfo con la informacion de la salida de ganado en transito por muerte al que se le generara la poliza</param>
        /// <returns>Regresa la lista de nodos de la poliza generada por la salida de ganado en transito por muerte</returns>
        public override IList <PolizaInfo> GeneraPoliza(object datosPoliza)
        {
            try
            {
                IList <PolizaInfo> polizaSalida = new List <PolizaInfo>();
                var input = (SalidaGanadoEnTransitoInfo)datosPoliza;
                detalles = input.DetallesSalida;
                datos    = ObtenerDatosPolizaSalidaPorMuerte(input);

                var noLinea = 1;

                //genera el ref3:
                var ref3 = new StringBuilder();
                ref3.Append("03");
                ref3.Append(Convert.ToString(input.Folio).PadLeft(10, ' '));
                ref3.Append(new Random(10).Next(10, 20));
                ref3.Append(new Random(30).Next(30, 40));
                ref3.Append(DateTime.Now.Millisecond.ToString(CultureInfo.InvariantCulture));
                ref3.Append(datos.PostFijoRef3);
                //

                //genera el folio de archivo:
                var archivoFolio = new StringBuilder();
                archivoFolio.Append("P01");
                archivoFolio.Append(input.Fecha.ToString("yyyyMMdd"));
                archivoFolio.Append(DateTime.Now.Minute);
                archivoFolio.Append(DateTime.Now.Second);
                archivoFolio.Append(new Random(1).Next(1, 9));
                //

                //busca el costo de ganado
                var costoGanado = input.Costos.FirstOrDefault(costo => costo.CostoID == Costo.CostoGanado.GetHashCode());
                //

                if (costoGanado != null)
                {
                    //calcula el importe total sumando los importes de los detalles
                    if (input.DetallesSalida != null)
                    {
                        input.Importe = input.DetallesSalida.Sum(x => x.ImporteCosto);

                        #region Primer nodo : Total de costos de salida

                        //genera un nodo generico de la poliza por salida de ganado en transito por muerte
                        var nodo1 = GenerarNodoPlantillaPolizaMuerteTransito(input, noLinea, ref3.ToString(),
                                                                             archivoFolio.ToString());
                        //

                        //busca la cuenta de Faltantes / Sobrantes de la organizacion que registro la salida de ganado en transito
                        var parOrganizacion = new ParametroOrganizacionBL();
                        var claveCuenta     = parOrganizacion.ObtenerPorOrganizacionIDClaveParametro(input.OrganizacionID,
                                                                                                     ParametrosEnum.CTAFALTANTESOBRANTE.ToString());
                        nodo1.Cuenta = claveCuenta.Valor;
                        if (claveCuenta.Valor.Substring(0, 4) == "5001")
                        {
                            nodo1.CentroCosto = datos.ParametroOrganizacionValor;
                        }
                        //

                        var importeCostos = input.DetallesSalida.Sum(costo => costo.ImporteCosto);
                        nodo1.Importe = "-" + importeCostos.ToString(CultureInfo.InvariantCulture);
                        polizaSalida.Add(nodo1);

                        #endregion

                        #region segundo nodo : Costo de salida correspondiente a salida de ganado

                        noLinea++;
                        ClaveContableInfo clavecontablecargo;
                        var nodo2 = GenerarNodoPlantillaPolizaMuerteTransito(input, noLinea, ref3.ToString(),
                                                                             archivoFolio.ToString());

                        if (claveCuenta.Valor.Substring(0, 4) == "5001")
                        {
                            nodo2.CentroCosto = datos.ParametroOrganizacionValor;
                        }
                        var salidaPorMuerteEnTransitoDetalle =
                            input.DetallesSalida.FirstOrDefault(
                                detalle => detalle.CostoId == Costo.CostoGanado.GetHashCode());
                        if (salidaPorMuerteEnTransitoDetalle != null)
                        {
                            nodo2.Importe =
                                salidaPorMuerteEnTransitoDetalle.ImporteCosto.ToString(CultureInfo.InvariantCulture);
                        }
                        else
                        {
                            var ex = new Exception(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_CostosGanadoNoEncontrado);
                            Logger.Error(ex);
                            throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                        }

                        costos = ObtenerCostos();
                        var firstOrDefault = costos.FirstOrDefault(x => x.CostoID == costoGanado.CostoID);
                        if (firstOrDefault != null)
                        {
                            var costoAbonos = new CostoInfo
                            {
                                ClaveContable = firstOrDefault.ClaveContable
                            };
                            clavecontablecargo = ObtenerCuentaInventario(costoAbonos, input.OrganizacionID,
                                                                         TipoPoliza.SalidaMuerteEnTransito);
                            if (clavecontablecargo != null)
                            {
                                nodo2.Cuenta = clavecontablecargo.Valor;
                            }
                        }
                        else
                        {
                            var ex = new Exception(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_CostosGanadoNoEncontrado);
                            Logger.Error(ex);
                            throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                        }
                        polizaSalida.Add(nodo2);

                        #endregion

                        #region nodos de detalles importes costo corral

                        var nodosDetalles = new List <PolizaInfo>();
                        var costosPl      = new CostoPL();
                        var costosclaves  = costosPl.ObtenerTodos(EstatusEnum.Activo);

                        //agrega todos los costos de los detalles excepto el costo de ganado (por que ya se encuentra agregado)
                        foreach (
                            var costoCargo in
                            input.DetallesSalida.SkipWhile(costo => costo.CostoId == Costo.CostoGanado.GetHashCode())
                            )
                        {
                            noLinea++;

                            var temp = GenerarNodoPlantillaPolizaMuerteTransito(input, noLinea, ref3.ToString(),
                                                                                archivoFolio.ToString());
                            if (costosclaves == null)
                            {
                                var ex = new Exception(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_CostosNoEncontrados);
                                Logger.Error(ex);
                                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                            }
                            var claveCosto = costosclaves.FirstOrDefault(x => x.CostoID == costoCargo.CostoId);
                            if (claveCosto != null)
                            {
                                var costosAbono = new CostoInfo
                                {
                                    ClaveContable = claveCosto.ClaveContable
                                };
                                //busca la clave contable para el costo correspondiente
                                clavecontablecargo = ObtenerCuentaInventario(costosAbono, input.OrganizacionID,
                                                                             TipoPoliza.SalidaMuerteEnTransito);
                                if (clavecontablecargo != null)
                                {
                                    temp.Cuenta = clavecontablecargo.Valor;
                                }
                            }
                            else
                            {
                                var ex = new Exception(
                                    string.Format(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_CostoIdNoEncontrado, costoCargo.CostoId));
                                Logger.Error(ex);
                                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                            }
                            if (claveCuenta.Valor.Substring(0, 4) == "5001")
                            {
                                temp.CentroCosto = datos.ParametroOrganizacionValor;
                            }
                            temp.Importe = costoCargo.ImporteCosto.ToString(CultureInfo.InvariantCulture);
                            nodosDetalles.Add(temp);
                        }

                        foreach (var polizaItem in nodosDetalles)
                        {
                            polizaSalida.Add(polizaItem);
                        }

                        #endregion
                    }
                    else
                    {
                        var ex = new Exception(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_DetalleSalidaGanadoTransitoNoProporcionados);
                        Logger.Error(ex);
                        throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                    }
                }
                else
                {
                    var ex = new Exception(Properties.ResourceServices.PolizaSalidaMuerteGanadoTransito_CostosGanadoNoEncontrado);
                    Logger.Error(ex);
                    throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
                }
                return(polizaSalida);
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
                throw new ExcepcionDesconocida(MethodBase.GetCurrentMethod(), ex);
            }
        }
示例#12
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);
        }