Bug en balanceo de Moneda (Contablidad)

Inicio Foros Foro principal Desarrolladores Bug en balanceo de Moneda (Contablidad)

  • Este debate está vacío.
Viendo 1 entrada (de un total de 1)
  • Autor
    Entradas
  • #31418
    Javier Ader
    Participante

    Buenas. Es muy probable que no se haya pasado desapercibido ya que se da bajo situaciones extrañas: la contabilidad no tiene que estar configurada para hacer el balanceo de diferencias por por conversiones entre monedas en una cuenta aparte y se tiene que generar un documento que use una moneda distinta a la del esquema contable que al hacer la conversión quede balanceado (por pequeñas diferencias de conversión supongo).
    Fact.balanceAccounting()->FactLine.currencyCorrect(diff) [linea 671].
    En este método está el bug (por suerte, parece ser que es solamente llamado en el path anterior). El tema es que este metodo existe para que disminuya o incremente el debe o el haber de una linea en un “delta” para que el asiento al que que pertenece quede balanceado; el delta en si mismo puede ser negativo o positivo (el delta se calcular sumando todos los debes de las lineas, y restandole las suma de todos los haber; ver Fact.getAcctBalance()).
    Si este delta negativo, significa que el asiento contable esta desbalaceado por el haber (el debe total es menor que el haber total). Para balancear se tiene o
    que incrementar el debe de una linea por el valor absoluto de la diferencia o disminuir el haber restandole el valor absoluto del delta.
    Si este delta es positivo, significa que el debe total del asiento es mayor que el haber total. Para balancear se tiene que decrementar el debe de una linea por este delta o incrementar el haber por este delta.

    Bueno el tema es que el codigo no hace esto; si el lado (debe o haber de la linea) a afectar es el debe hace lo siguiente:

    Code:
    if( adjustDr ) {
    if( negative ) { //si el delta es negativo
    setAmtAcctDr( getAmtAcctDr().subtract( deltaAmount ));
    } else {
    setAmtAcctDr( getAmtAcctDr().add( deltaAmount ));
    }
    }

    setAmtAcctDr( getAmtAcctDr().subtract( deltaAmount )
    Es equivalente, ya que el el delta es negativo, a incrementar el debe por el valor absoluto (debe = debe – delta es lo mismo que debe = debe + |delta|). En este caso esta bien , ya que si el delta es negativo signifca que el haber total era mayor que el debe total; incrementando este ultimo en la linea por el valor absoluto de la diferencia, el hecho contable (asiento) queda balanceado.
    Ahora, si el delta no es negativo se ejecuta
    setAmtAcctDr( getAmtAcctDr().add( deltaAmount))
    Lo cual es exactamente igual que lo ultimo, ya que el delta es positivo…(Debe = debe + delta === debe + |delta|). Esto incrementa el debe desbalanceando aún mas al asiento!
    Una forma de solucionarlo es siempre restar, independientemente de si el delta es negativo o no (y en ese caso el if (negative) no tiene mucho sentido).
    En conclusión: independientemente de si el delta es negativo o positivo, el debe de la linea es incrementado por el valor absoluto del delta. El código necesariamente es incorrecto.

    Algo similar ocurre si el lado a afectar es el haber. Si el delta es negativo (Debe Total < Haber Total), se debe decrementar el haber de la linea (lo cual es lo mismo que sumarle directamente el delta, ya que es negativo). Pero si es positivo (Debe Total > Haber Total) hay que incrementar el haber de la linea (lo cual de nuevo, como el delta es positivo, equivale a directamente a sumarle el delta). Es decir, acá siempre en hay que sumar.

    El código arreglado quedaría así:

    Code:
    public void currencyCorrect( BigDecimal deltaAmount ) {
    boolean negative = deltaAmount.compareTo( Env.ZERO ) < 0; boolean adjustDr = getAmtAcctDr().compareTo( getAmtAcctCr()) > 0;
    //si el delta es negativo hay que incrementar el debe o decrementar el haber
    //si es positivo hay que decrementar el debe o incrementar el haber
    log.fine( deltaAmount.toString() + “; Old-AcctDr=” + getAmtAcctDr() +
    “,AcctCr=” + getAmtAcctCr() + “; Negative=” + negative +
    “; AdjustDr=” + adjustDr );

    if( adjustDr ) { //NO importa si el delta es negativo; siempre restar.
    // Si el delta es negativo se tiene que incrementar el debe,
    // restadoselo directamente debe actual lo va a incrementar, por ej
    // (10 – (-5) = 10 + 5).
    //si el delta en positivo, hay que decrementar el debe; por lo tanto
    //tambien se logra restando.
    setAmtAcctDr( getAmtAcctDr().subtract( deltaAmount ));
    } else { //NO importa si el delta es negativo; siempre sumar
    //si el delta es negativo hay que decrementar el haber;
    //sumandoselo directamente al haber actual se decrementa
    //por ej (10 + (-5) = 10 – 5)
    //si el delta es positivo, hay que incrementar el haber actual
    //lo cual tambien se logra sumandoselo
    setAmtAcctCr( getAmtAcctCr().add( deltaAmount ));
    }

    log.fine( “New-AcctDr=” + getAmtAcctDr() + “,AcctCr=” + getAmtAcctCr());
    } // currencyCorrect

    Bueno, me releeo y no me entiendo ni yo mismo jaja. Ok, chequeenlo mirando el código si no se entiende muy bien.

Viendo 1 entrada (de un total de 1)
  • Debes estar registrado para responder a este debate.