///|
pub(all) struct CalculationCheck {
role_uri : String
parent : QName
context_ref : String
expected : Decimal
actual : Decimal
matched : Bool
child_count : Int32
} derive(Eq, @debug.Debug)
///|
pub(all) struct CalculationReport {
checks : Array[CalculationCheck]
} derive(Eq, @debug.Debug)
///|
pub fn CalculationReport::is_valid(self : CalculationReport) -> Bool {
for check in self.checks {
if !check.matched {
return false
}
}
true
}
///|
pub fn CalculationReport::mismatches(
self : CalculationReport,
) -> Array[CalculationCheck] {
let result : Array[CalculationCheck] = []
for check in self.checks {
if !check.matched {
result.push(check)
}
}
result
}
///|
fn numeric_fact_value(fact : XbrlFact) -> Result[Decimal, XbrlError] {
match Decimal::parse(fact.value.trim()) {
Ok(value) => Ok(value)
Err(_) => Err(InvalidFact("calculation fact is not a decimal", fact.offset))
}
}
///|
fn calculation_unit_matches(
parent : XbrlFact,
child : XbrlFact,
) -> Result[Unit, XbrlError] {
match parent.unit_ref {
Some(parent_unit) =>
match child.unit_ref {
Some(child_unit) =>
if parent_unit == child_unit {
Ok(())
} else {
Err(
InvalidFact("calculation facts use different units", child.offset),
)
}
None =>
Err(InvalidFact("calculation child fact has no unit", child.offset))
}
None =>
Err(InvalidFact("calculation parent fact has no unit", parent.offset))
}
}
///|
pub fn check_calculations(
linkbase : XbrlLinkbase,
taxonomy : ResolvedTaxonomy,
instance : XbrlInstance,
) -> Result[CalculationReport, XbrlError] {
let groups = match linkbase.calculation_groups(taxonomy) {
Ok(value) => value
Err(err) => return Err(err)
}
let checks : Array[CalculationCheck] = []
for group in groups {
for parent_fact in instance.facts {
if parent_fact.nil || parent_fact.concept != group.parent {
continue
}
let actual = match numeric_fact_value(parent_fact) {
Ok(value) => value
Err(err) => return Err(err)
}
let mut expected = Decimal::zero()
let mut child_count = 0
for relation in group.relations {
for child_fact in instance.facts {
if child_fact.nil ||
child_fact.concept != relation.child ||
child_fact.context_ref != parent_fact.context_ref {
continue
}
match calculation_unit_matches(parent_fact, child_fact) {
Ok(_) => ()
Err(err) => return Err(err)
}
let child_value = match numeric_fact_value(child_fact) {
Ok(value) => value
Err(err) => return Err(err)
}
let weighted = match
child_value.mul(relation.weight, child_fact.offset) {
Ok(value) => value
Err(err) => return Err(err)
}
expected = match expected.add(weighted, parent_fact.offset) {
Ok(value) => value
Err(err) => return Err(err)
}
child_count += 1
}
}
if child_count == 0 {
continue
}
checks.push({
role_uri: group.role_uri,
parent: group.parent,
context_ref: parent_fact.context_ref,
expected,
actual,
matched: expected.compare(actual) == 0,
child_count,
})
}
}
Ok({ checks, })
}
///|
pub fn XbrlLinkbase::check_calculations(
self : XbrlLinkbase,
taxonomy : ResolvedTaxonomy,
instance : XbrlInstance,
) -> Result[CalculationReport, XbrlError] {
check_calculations(self, taxonomy, instance)
}
///|
pub extend CalculationCheck with Eq::{not_equal, equal}
///|
pub extend CalculationCheck with @debug.Debug::{to_repr}
///|
pub extend CalculationReport with Eq::{not_equal, equal}
///|
pub extend CalculationReport with @debug.Debug::{to_repr}