/*
* public List<FactBaseQuery> GetRuleQuery(Hierarchy<XbrlIdentifiable> item)
* {
* //root level
* var rootfilters = item.Children.Where(i => i.Item is Filter).ToList();
* var rootquerypool = new List<List<FactBaseQuery>>();
*
* foreach (var rootfilter in rootfilters)
* {
* var rootfilterItem = rootfilter.Item as Filter;
* var queries = rootfilterItem.GetQueries(this.Taxonomy, 0);
* //rootquerypool.Add(queries);
* if (queries.Count > 0)
* {
* if (queries.Count == 1)
* {
* rootquerypool.Add(queries);
* }
* else
* {
*
* }
* }
*
* }
*
* var rootqueries = CombineQueries(rootquerypool.ToArray());
*
* var allqueries = rootqueries;
* foreach (var qry in allqueries)
* {
* qry.NrOfDictFilters = qry.DictFilterIndexes.Count;
* }
* return allqueries;
* }
*/
/*
* public List<FactBaseQuery> GetRuleBaseQuery(Hierarchy<XbrlIdentifiable> item)
* {
* //root level
* var rootfilters = item.Children.Where(i => i.Item is Filter).ToList();
* var rootquerypool = new List<List<FactBaseQuery>>();
*
* foreach (var rootfilter in rootfilters)
* {
* var rootfilterItem = rootfilter.Item as Filter;
* var queries = rootfilterItem.GetQueries(this.Taxonomy, 0);
* //rootquerypool.Add(queries);
* if (queries.Count > 0)
* {
* if (queries.Count == 1)
* {
* rootquerypool.Add(queries);
* item.Children.Remove(rootfilter);
* }
* else
* {
*
* }
* }
*
* }
*
* var rootqueries = CombineQueries(rootquerypool.ToArray());
*
* var allqueries = rootqueries;
* foreach (var qry in allqueries)
* {
* qry.NrOfDictFilters = qry.DictFilterIndexes.Count;
* }
* return allqueries;
* }
*/
/*
* public List<FactBaseQuery> GetFactQuery(Hierarchy<XbrlIdentifiable> item,int level=0)
* {
* //or queries
* var orfilters = item.Where(i => i.Item is OrFilter).ToList();
* var querycombinationpool = new List<List<FactBaseQuery>>();
* foreach (var orfilter in orfilters)
* {
*
* var orfilteritem = orfilter.Item as OrFilter;
* var andfilters = orfilter.Where(i => i.Item is AndFilter).ToList();
* var orquerycombinationpool = new List<List<FactBaseQuery>>();
* var queries = new List<FactBaseQuery>();
* foreach (var andfilter in andfilters)
* {
* var andfilteritem = andfilter.Item as AndFilter;
*
* var levelquerypool = new List<List<FactBaseQuery>>();
*
* foreach (var filteritem in andfilter.Children)
* {
* var levelfilteritem = filteritem.Item as Filter;
* var levelqueries = levelfilteritem.GetQueries(this.Taxonomy, level);
* //queries.AddRange(levelqueries);
* levelquerypool.Add(levelqueries);
* }
* var andqueries = CombineQueries(levelquerypool.ToArray());
* queries.AddRange(andqueries);
* //orquerycombinationpool.Add(andqueries);
*
* }
*
* //List<FactBaseQuery> queries = CombineQueries(orquerycombinationpool.ToArray());
*
* item.Children.Remove(orfilter);
* querycombinationpool.Add(queries);
* }
* var mergedqueries = CombineQueries(querycombinationpool.ToArray());
*
* //root level
* var rootfilters = item.Where(i => i.Item is Filter).ToList();
* var rootquerypool = new List<List<FactBaseQuery>>();
*
* foreach (var rootfilter in rootfilters)
* {
* var rootfilterItem = rootfilter.Item as Filter;
* rootquerypool.Add(rootfilterItem.GetQueries(this.Taxonomy, level));
*
* }
*
* var rootqueries = CombineQueries(rootquerypool.ToArray());
*
* var allqueries = CombineQueries(rootqueries, mergedqueries);
* foreach (var qry in allqueries)
* {
* qry.NrOfDictFilters = qry.DictFilterIndexes.Count;
* }
* return allqueries;
* }
*/
/*
* public List<int> GetFactIDsByDict(FactBaseQuery fbq, List<int> IdList)
* {
* IEnumerable<int> ids = null;
*
*
* var rulefactquery = fbq;
* var dimparts = rulefactquery.GetDimensions().Distinct().ToList();
* var source = IdList == null ? Taxonomy.FactIndexEnumerable() : IdList;
*
* if (dimparts.Count > 0)
* {
* ids = source;
* var firstdimpartix = Taxonomy.FactParts[dimparts[0]];
* ids = Taxonomy.FactsOfParts[firstdimpartix];
* for (int i = 1; i < dimparts.Count; i++)
* {
* var ix = Taxonomy.FactParts[dimparts[i]];
* if (Taxonomy.FactsOfParts.ContainsKey(ix))
* {
* ids = Utilities.Objects.IntersectSorted(ids, Taxonomy.FactsOfParts[ix], null).AsQueryable().ToList();
* }
* }
*
* }
* else
* {
* return source.ToList();
* }
* return ids.ToList();
* }
*/
public List <String> GetFactsByIds(IEnumerable <int> ids)
{
var factlist = new List <String>();//ids.Count());
foreach (var id in ids)
{
var key = Taxonomy.GetFactStringKey(Taxonomy.FactsManager.GetFactKey(id));
factlist.Add(key);
}
return(factlist);
}
public List <KeyValue <string, int> > GetFactsKVByIds(IEnumerable <int> ids)
{
var factlist = new List <KeyValue <string, int> >();//ids.Count());
foreach (var id in ids)
{
var key = Taxonomy.GetFactStringKey(Taxonomy.FactsManager.GetFactKey(id));
factlist.Add(new KeyValue <string, int>(key, id));
}
return(factlist);
}
public List <ValidationRuleResult> GetAllResults()
{
var results = new List <ValidationRuleResult>();
var factgroups = Parameters.FirstOrDefault().TaxFacts;
for (int i = 0; i < factgroups.Count; i++)
{
var vruleresult = new ValidationRuleResult();
vruleresult.Rule = this;
results.Add(vruleresult);
vruleresult.ID = this.ID;
foreach (var p in Parameters)
{
if (p.IsGeneral)
{
continue;
}
p.Clear();
//p.CurrentCells.Clear();
var itemfacts = new List <string>();
var itemfactids = new List <int>();
var sp = new SimpleValidationParameter();
sp.Name = p.Name;
sp.BindAsSequence = p.BindAsSequence;
vruleresult.Parameters.Add(sp);
//TODO
IList <int> facts = null;
if (i >= p.TaxFacts.Count && p.TaxFacts.Count == 1)
{
facts = p.TaxFacts[0];
}
else
{
facts = p.TaxFacts[i];
}
if (p.BindAsSequence)
{
//set the cells
itemfactids.AddRange(facts);
itemfacts.AddRange(facts.Select(f => Taxonomy.GetFactStringKey(Taxonomy.FactsManager.GetFactKey(f))));
foreach (var tax_fact in itemfactids)
{
//var cellist = new List<string>();
//sp.Cells.Add(cellist);
//var taxfactkey = Taxonomy.FactsManager.GetFactKey(tax_fact);
//if (Taxonomy.HasFact(taxfactkey))
//{
// var cells = Taxonomy.GetCellsOfFact(taxfactkey);
// cellist.AddRange(cells);
//}
}
}
else
{
if (facts.Count > 1)
{
//TODO
//Logger.WriteLine("Issue with " + this.ID + " parameter " + p.Name);
}
else
{
if (facts.Count == 1)
{
var factkey = Taxonomy.GetFactStringKey(Taxonomy.FactsManager.GetFactKey(facts.FirstOrDefault()));
itemfacts.Add(factkey);
var factid = facts.FirstOrDefault();
itemfactids.Add(factid);
//set the cells
//var cells = new List<String>();
//sp.Cells.Add(cells); ;
//if (Taxonomy.HasFact(factkey))
//{
// cells.AddRange(Taxonomy.GetCellsOfFact(factkey));
//}
}
}
}
//sp.Facts.AddRange(itemfacts);
sp.FactIDs.AddRange(itemfactids.Select(f => String.Format("T:{0}", f)));
//p.FactIDs.Add(String.Format("I:{0}", fact.IX));
//
}
}
//results = ValidationRuleHelper.ExecuteImplicitFiltering(Taxonomy, results);
//Taxonomy.SetCells(results);
ValidationRuleHelper.SetCells(Taxonomy, results);
return(results);
}
public string CheckCells(LogicalModel.Validation.ValidationParameter parameter)
{
var cellfound = false;
var sb = new StringBuilder();
var sequence = parameter.BindAsSequence ? "Sequence" : "";
sb.AppendLine("parameter: " + parameter.Name + " " + sequence);
var c_sb = new StringBuilder();
var log = false;
foreach (var factgroup in parameter.TaxFacts)
{
foreach (var factid in factgroup.AsEnumerable())
{
var cellslist = new List <List <String> >();
var factkey = Taxonomy.FactsManager.GetFactKey(factid);
var fact = FactBase.GetFactFrom(Taxonomy.GetFactStringKey(factkey));
if (Taxonomy.HasFact(factkey))
{
var cells = Taxonomy.GetCellsOfFact(factkey);
if (parameter.RuleID.Contains("0602"))
{
cellslist.Add(cells.Select(i => i + " {" + factkey + "} ").ToList());
}
else
{
cellslist.Add(cells);
}
if (cells.Count == 0)
{
if (log)
{
c_sb.AppendLine(parameter.RuleID + " fact found but no cells! " + factkey);
}
}
}
else
{
var s_facts = Taxonomy.FactKeysAsEnumerable().Select(i => i).AsEnumerable();
if (fact.Concept != null)
{
//s_facts = s_facts.Where(i => i.StartsWith(fact.Concept.Content));
//if (Taxonomy.FactsOfDimensions.ContainsKey(fact.Concept.Content))
var ix = Taxonomy.FactParts[fact.Concept.Content];
if (Taxonomy.FactsOfParts.ContainsKey(ix))
{
s_facts = Taxonomy.FactsOfParts[ix].Select(
i => Taxonomy.FactsManager.GetFactKey(i));
}
else
{
s_facts = new List <int[]>();
}
}
foreach (var dimension in fact.Dimensions)
{
s_facts = s_facts.Where(i => Taxonomy.GetFactStringKey(i).Contains(dimension.DomainMemberFullName));
}
// var s_factlist = s_facts.ToList();
var hasanyfact = false;
foreach (var s_fact in s_facts)
{
hasanyfact = true;
var cells = Taxonomy.GetCellsOfFact(s_fact);
if (cells.Count == 0)
{
if (log)
{
c_sb.AppendLine(parameter.RuleID + " for parameter " + parameter.Name + " no cells were found! " + s_fact);
}
}
if (parameter.RuleID.Contains("0602"))
{
cellslist.Add(cells.Select(i => i + " {" + factkey + "} ").ToList());
}
else
{
cellslist.Add(cells);
}
}
if (!hasanyfact)
{
if (log)
{
c_sb.AppendLine(parameter.RuleID + " fact for parameter " + parameter.Name + " not found! " + factkey);
}
}
}
if (cellslist.Count == 0)
{
}
else
{
cellfound = true;
}
//sb.AppendLine(fact.GetFactKey());
foreach (var cells in cellslist)
{
foreach (var cell in cells)
{
sb.Append(cell + ", ");
}
sb.AppendLine();
}
}
}
if (!cellfound)
{
if (log)
{
c_sb.AppendLine("None of the Fact Groups can be found for " + parameter.RuleID + " - " + parameter.Name);
}
}
if (c_sb.Length > 0)
{
Logger.WriteLine(c_sb.ToString());
}
return(sb.ToString());
}
