Exemple #1
0
        /// <summary>
        /// Método Público encargado de Regresar el Cobro Recurrente en caso de Reabrir la Liquidación
        /// </summary>
        /// <param name="id_usuario"></param>
        /// <returns></returns>
        public RetornoOperacion RegresaTotalCobroRecurrente(int id_usuario)
        {
            //Declarando Objetos de Retorno
            RetornoOperacion result           = new RetornoOperacion();
            RetornoOperacion resultDetalleLiq = new RetornoOperacion();

            //Declarando Variables Auxiliares
            DateTime fecha_cobro_anterior = DateTime.MinValue;
            decimal  total = 0;

            //Inicializando Bloque Transaccional
            using (TransactionScope trans = TSDK.Datos.Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
            {
                //Obteniendo Cantidad
                int cantidad = 0;
                //Obteniendo Estatus
                byte id_estatus = this._total_deuda == this._total_cobrado ? (byte)EstatusTermino.Vigente : this._id_estatus_termino;

                //Instanciando Detalle de Liquidación
                using (DetalleLiquidacion dl = new DetalleLiquidacion(this._id_cobro_recurrente, 77))
                {
                    //Validando que exista el Detalle
                    if (dl.id_detalle_liquidacion > 0)
                    {
                        //Obteniendo Cantidades
                        cantidad = Convert.ToInt32(dl.cantidad);
                        total    = dl.cantidad * dl.valor_unitario;

                        //Obteniendo Fecha Anterior
                        fecha_cobro_anterior = this._fecha_ultimo_cobro.AddDays(-1 * (cantidad * this._dias_cobro));

                        //Deshabilitando Detalle del Cobro Recurrente
                        resultDetalleLiq = dl.DeshabilitaDetalleLiquidacion(id_usuario);

                        //Validando la Eliminación del Detalle del Cobro
                        if (resultDetalleLiq.OperacionExitosa)
                        {
                            //Instanciando Cobro Recurrente
                            using (TipoCobroRecurrente tcr = new TipoCobroRecurrente(this._id_tipo_cobro_recurrente))
                            {
                                //Actualizando Registro
                                result = this.actualizaRegistros(this._id_tipo_cobro_recurrente, this._id_compania_emisor, this._total_deuda, this.total_cobrado - total,
                                                                 this._monto_cobro, this._tasa_monto, this._dias_cobro, this._id_tipo_entidad_aplicacion, this._id_unidad, this._id_operador,
                                                                 this._id_proveedor_compania, this._id_empleado, this._referencia, this._fecha_inicial, fecha_cobro_anterior,
                                                                 id_estatus, this._id_tabla, this._id_registro, id_usuario, this._habilitar);

                                //Validando que la Operación haya sido Completada
                                if (result.OperacionExitosa)
                                {
                                    //Completando Transacción
                                    trans.Complete();
                                }
                            }
                        }
                    }
                }
            }
            //Devolviendo Resultado Obtenido
            return(result);
        }
Exemple #2
0
        /// <summary>
        /// Método Público encargado de Calcular el Saldo Actual
        /// </summary>
        /// <param name="fecha">Fecha</param>
        /// <returns></returns>
        public decimal CalculaSaldoActual(DateTime fecha)
        {
            //Declarando Objeto de Retorno
            decimal saldo_actual = 0;

            //Obtiene la Fecha de Actualización
            DateTime fecha_actualizacion = this._fecha_ultimo_cobro == DateTime.MinValue ? this._fecha_inicial : this._fecha_ultimo_cobro;

            //Resta de Fechas
            TimeSpan ts = fecha - fecha_actualizacion;

            //Calculando Saldo Actual
            saldo_actual = (ts.Days / this._dias_cobro) * this._monto_cobro;

            //Instanciando Cobro Recurrente
            using (TipoCobroRecurrente tcr = new TipoCobroRecurrente(this._id_tipo_cobro_recurrente))
            {
                //Validando el Tipo de Cobro
                if ((TipoCobroRecurrente.TipoAplicacion)tcr.id_tipo_aplicacion == TipoCobroRecurrente.TipoAplicacion.Descuento)
                {
                    //Validando si el Saldo Actual es mayor que el calculado
                    saldo_actual = saldo_actual > this._saldo ? this._saldo : saldo_actual;
                }
            }

            //Devolviendo Ressultado Obtenido
            return(saldo_actual);
        }
Exemple #3
0
        /// <summary>
        /// Método Público encaragdo de Actualizar el Cobro Recurrente
        /// </summary>
        /// <param name="id_liquidacion"></param>
        /// <param name="fecha_calculo"></param>
        /// <param name="id_unidad"></param>
        /// <param name="id_operador"></param>
        /// <param name="id_proveedor"></param>
        /// <param name="id_usuario"></param>
        /// <returns></returns>
        public RetornoOperacion ActualizaTotalCobroRecurrente(int id_liquidacion, DateTime fecha_calculo, int id_unidad, int id_operador,
                                                              int id_proveedor, int id_usuario)
        {
            //Declarando Objetos de Retorno
            RetornoOperacion result           = new RetornoOperacion();
            RetornoOperacion resultDetalleLiq = new RetornoOperacion();

            //Declarando Variables Auxiliares
            decimal saldo_actual = 0.00M;

            //Inicializando Bloque Transaccional
            using (TransactionScope trans = TSDK.Datos.Transaccion.InicializaBloqueTransaccional(System.Transactions.IsolationLevel.ReadCommitted))
            {
                //Instanciando Tipo de Cobro Recurrente
                using (TipoCobroRecurrente tcr = new TipoCobroRecurrente(this._id_tipo_cobro_recurrente))
                {
                    //Obteniendo Dias
                    TimeSpan dias = fecha_calculo - this._fecha_ultimo_cobro;
                    //Asignando Estatus
                    byte id_estatus = this._id_estatus_termino;

                    //Declarando Cantidad
                    decimal cantidad = 0;

                    //Validando Estatus del Cobro Recurrente
                    switch ((EstatusTermino)this._id_estatus_termino)
                    {
                    case EstatusTermino.Vigente:
                    {
                        //Obteniendo Saldo Actual
                        saldo_actual = CalculaSaldoActual(fecha_calculo);

                        //Obteniendo Cantidad
                        cantidad = dias.Days / this.dias_cobro;

                        //Validando que el Tipo de Aplicación sea Descuento
                        if (tcr.id_tipo_aplicacion == 2)
                        {
                            //Total Actual Auxiliar
                            saldo_actual = saldo_actual >= this._saldo ? this._saldo : saldo_actual;

                            //Obteniendo Estatus
                            id_estatus = saldo_actual == this._saldo ? (byte)EstatusTermino.Terminado : this._id_estatus_termino;

                            //Calculando Cantidad
                            cantidad = Convert.ToDecimal(saldo_actual / monto_cobro);
                        }
                        break;
                    }

                    case EstatusTermino.Pausa:
                    {
                        //Asignando Valores
                        cantidad     = 0;
                        id_estatus   = (byte)EstatusTermino.Vigente;
                        saldo_actual = 0;
                        break;
                    }
                    }

                    //Insertando Detalle de Liquidación
                    resultDetalleLiq = DetalleLiquidacion.InsertaDetalleLiquidacion(77, this._id_cobro_recurrente, DetalleLiquidacion.Estatus.Liquidado, id_unidad, id_operador,
                                                                                    id_proveedor, 0, 0, fecha_calculo, id_liquidacion, cantidad, 0, this._monto_cobro, id_usuario);

                    //Validando si la Operación fue exitosa
                    if (resultDetalleLiq.OperacionExitosa)
                    {
                        //Instanciando Detalle de Liquidación
                        using (DetalleLiquidacion dl = new DetalleLiquidacion(resultDetalleLiq.IdRegistro))
                        {
                            //Cantidad Entera
                            int cantidad_int = Decimal.ToInt32(cantidad);

                            //Validando Estatus
                            if ((EstatusTermino)this._id_estatus_termino == EstatusTermino.Pausa)
                            {
                                //Obteniendo Cantidad
                                cantidad_int = dias.Days / this.dias_cobro;
                            }

                            //Calculando Fecha del Ultimo Cobro con respecto a la cantidad por los dias
                            DateTime fecha_cobro = this._fecha_ultimo_cobro.AddDays(cantidad_int * this._dias_cobro);

                            //Actualizando Registro
                            result = this.actualizaRegistros(this._id_tipo_cobro_recurrente, this._id_compania_emisor, this._total_deuda, this.total_cobrado + saldo_actual,
                                                             this._monto_cobro, this._tasa_monto, this._dias_cobro, this._id_tipo_entidad_aplicacion, this._id_unidad, this._id_operador,
                                                             this._id_proveedor_compania, this._id_empleado, this._referencia, this._fecha_inicial, fecha_cobro,
                                                             id_estatus, this._id_tabla, this._id_registro, id_usuario, this._habilitar);

                            //Validando que la Operación haya sido Completada
                            if (result.OperacionExitosa)
                            {
                                //Completando Transacción
                                trans.Complete();
                            }
                        }
                    }
                    else
                    {
                        //Instanciando Excepcion
                        result = new RetornoOperacion(resultDetalleLiq.Mensaje);
                    }
                }
            }
            //Devolviendo Resultado Obtenido
            return(result);
        }