public List <FactBaseQuery> SoftCombineQueries(params List <FactBaseQuery>[] querypool)
{
var nonempty = querypool.Where(i => i.Count > 0);
var combinedqueries = MathX.CartesianProduct(nonempty);
var mergedqueries = new List <FactBaseQuery>();
foreach (var combination in combinedqueries)
{
var mergedquery = new FactBaseQuery();
var combinationlist = combination.ToList();
var ix = 0;
foreach (var fbq in combinationlist)
{
//Merge(fbq, mergedquery);
mergedquery.NrOfDictFilters += fbq.NrOfDictFilters;
//if (ix == combinationlist.Count - 1)
//{
// Merge(fbq, mergedquery);
//}
FactBaseQuery.Merge(fbq, mergedquery);
ix++;
}
mergedqueries.Add(mergedquery);
}
return(mergedqueries);
}
public void RemoveCommon(FactBaseQuery querytoremovefrom, FactBaseQuery query)
{
var common_dfs = query.DictFilterIndexes.Intersect(querytoremovefrom.DictFilterIndexes).ToList();
var common_ndfs = query.NegativeDictFilterIndexes.Intersect(querytoremovefrom.NegativeDictFilterIndexes).ToList();
foreach (var common_df in common_dfs)
{
querytoremovefrom.DictFilterIndexes.Remove(common_df);
}
foreach (var common_ndf in common_ndfs)
{
querytoremovefrom.NegativeDictFilterIndexes.Remove(common_ndf);
}
querytoremovefrom.DictFilters = "";
foreach (var df in querytoremovefrom.DictFilterIndexes)
{
querytoremovefrom.DictFilters += Taxonomy.CounterFactParts[df] + ",";
}
querytoremovefrom.FalseFilters = "";
foreach (var ndf in querytoremovefrom.NegativeDictFilterIndexes)
{
querytoremovefrom.FalseFilters += Taxonomy.CounterFactParts[ndf] + ",";
}
//querytoremovefrom.NrOfDictFilters = querytoremovefrom.DictFilterIndexes.Count;
}
public FactBaseQuery GetQuery(Hierarchy <XbrlIdentifiable> item, int level = 0)
{
var query = new FactBaseQuery();
foreach (var child in item.Children)
{
var filter = child.Item as Filter;
if (filter != null)
{
//Console.WriteLine(String.Format("GetQuery({0}, {1}) at child {2}", item, level, child));
var chquery = filter.GetQuery(this.Taxonomy, child, query);
//FactBaseQuery.Merge(chquery, query);
if (chquery != null)
{
query.AddChildQuery(chquery);
//FactBaseQuery.MergeQueries(query, chquery);
}
else
{
//GetQuery not implemented for the filter
}
}
}
query.Simplify();
return(query);
}
public override FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
//Console.WriteLine(String.Format("ConceptFilter.GetQuery( {0} ) ", currentfilter.Item));
var factparts = taxonomy.FactParts;
var factsofparts = taxonomy.FactsOfParts;
//var query = new FactBaseQuery();
FactBaseQuery result = null;
var queries = new List <FactBaseQuery>();
if (Concepts.Count == 1)
{
}
foreach (var concept in Concepts)
{
var query = new FactBaseQuery();
queries.Add(query);
var tag = concept.QName.Content;
query.Concept = tag;
if (!Complement)
{
query.DictFilters = parent.DictFilters + String.Format("{0} ", tag);
if (factparts.ContainsKey(tag))
{
query.DictFilterIndexes.Add(factparts[tag]);
}
}
else
{
query.FalseFilters = parent.DictFilters + String.Format("{0} ", tag);
if (factparts.ContainsKey(tag))
{
query.NegativeDictFilterIndexes.Add(factparts[tag]);
}
}
SetCover(query);
}
if (queries.Count == 1)
{
result = queries.FirstOrDefault();
}
if (queries.Count > 1)
{
result = new FactPoolQuery();
foreach (var query in queries)
{
result.AddChildQuery(query);
}
}
return(result);
}
public override FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
var query = new FactBaseQuery();
foreach (var child in currentfilter.Children)
{
var filter = child.Item as Filter;
if (filter != null)
{
var childquery = filter.GetQuery(taxonomy, child, query);
FactBaseQuery.MergeQueries(query, childquery);
//query.AddChildQuery(childquery);
//FactBaseQuery.Merge(childquery, query);
}
}
return(query);
}
public List <FactBaseQuery> CombineQueries(params List <FactBaseQuery>[] querypool)
{
var nonempty = querypool.Where(i => i.Count > 0);
var combinedqueries = MathX.CartesianProduct(nonempty);
var mergedqueries = new List <FactBaseQuery>();
foreach (var combination in combinedqueries)
{
var mergedquery = new FactBaseQuery();
foreach (var fbq in combination)
{
FactBaseQuery.Merge(fbq, mergedquery);
}
mergedqueries.Add(mergedquery);
}
return(mergedqueries);
}
public override FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
//Console.WriteLine(String.Format("TypedDimensionFilter.GetQuery( {0} ) ", currentfilter.Item));
var query = new FactBaseQuery();
var factparts = taxonomy.FactParts;
var typeddomain = taxonomy.FindDimensionDomain(this.Dimension.QName.Content);
// var td = taxonomy.TypedDimensions.FirstOrDefault(i => i.Key.EndsWith(":" + this.Dimension.QName.Value));
var domainpart = typeddomain.Namespace + ":" + typeddomain.Name;
var tag = String.Format("[{0}:{1}]{2}", this.Dimension.QName.Domain, this.Dimension.QName.Value, domainpart);
if (!Complement)
{
//var tag = String.Format(":{0}]", this.Dimension.QName.Value);
query.TrueFilters = query.TrueFilters + String.Format("{0}, ", tag);
if (factparts.ContainsKey(tag))
{
query.DictFilterIndexes.Add(factparts[tag]);
}
}
else
{
//var tag = String.Format(":{0}]", this.Dimension.QName.Value);
query.FalseFilters = query.FalseFilters + String.Format("{0} ", tag);
if (factparts.ContainsKey(tag))
{
query.NegativeDictFilterIndexes.Add(factparts[tag]);
}
}
SetCover(query);
return(query);
}
public LogicalModel.Validation.ValidationRule GetLogicalRule(Hierarchy <XbrlIdentifiable> hrule, XbrlTaxonomyDocument document)
{
this.Document = document;
var tmp_rule = hrule.Copy();
//FixRule(tmp_rule);
var logicalrule = new LogicalModel.Validation.ValidationRule();
var valueassertion = tmp_rule.Item as ValueAssertion;
logicalrule.ID = valueassertion.ID;
//Utilities.Logger.WriteLine("Getting rule for " + logicalrule.ID);
logicalrule.LabelID = valueassertion.LabelID;
logicalrule.OriginalExpression = valueassertion.Test.Replace("\r\n", " ").Replace("\r", " ").Replace("\n", " ");
logicalrule.SetTaxonomy(this.Taxonomy);
var sb = new StringBuilder();
sb.AppendLine(logicalrule.DisplayText);
sb.AppendLine(valueassertion.Test);
var rawval = document.FileName + "\r\n" + document.LocalPath + "\r\n" + logicalrule.DisplayText + "\r\n" + logicalrule.OriginalExpression + "\r\n" + hrule.ToHierarchyString(i => i.ToString()) + "\r\n";
logicalrule.RawInfo = rawval;
Utilities.FS.AppendAllText(Taxonomy.TaxonomyValidationFolder + "Validations_XML.txt", rawval);
if (logicalrule.ID.Contains("1058"))/*,"es_v354"*/
{
}
var factvariables = tmp_rule.Where(i => i.Item is FactVariable);
foreach (var fv in factvariables)
{
tmp_rule.Remove(fv);
}
logicalrule.BaseQuery = GetQuery(tmp_rule);
logicalrule.BaseQuery.GetString(Taxonomy);
foreach (var fv in factvariables)
{
var factvariable = fv.Item as FactVariable;
var name = factvariable.Name;
var parameter = new LogicalModel.Validation.ValidationParameter(name, logicalrule.ID);
logicalrule.Parameters.Add(parameter);
parameter.BindAsSequence = factvariable.BindAsSequence;
parameter.FallBackValue = factvariable.FallbackValue;
parameter.BaseQuery = GetQuery(fv);
parameter.Concept = parameter.BaseQuery.GetConcept();
if (String.IsNullOrEmpty(parameter.Concept))
{
parameter.Concept = logicalrule.BaseQuery.GetConcept();
}
if (parameter.BaseQuery.HasDictFilter("find:filingIndicator"))
{
parameter.IsGeneral = true;
parameter.StringValue = "filingindicators";
}
ValidationRuleHelper.SetParamerterTypes(Taxonomy, logicalrule);
}
var factparameterqueries = logicalrule.Parameters.Where(i => !i.IsGeneral).Select(i => i.BaseQuery).ToArray();
var commconparameterquery = FactBaseQuery.GetCommonQuery(factparameterqueries);
if (commconparameterquery != null && commconparameterquery.HasFilters())
{
FactBaseQuery.MergeQueries(logicalrule.BaseQuery, commconparameterquery);
foreach (var pquery in factparameterqueries)
{
FactBaseQuery.RemoveQuery(pquery, commconparameterquery);
}
}
var sbquery = new StringBuilder();
if (1 == 1)
{
sbquery.AppendLine("RuleQuery: ");
sbquery.AppendLine(logicalrule.BaseQuery != null? logicalrule.BaseQuery.ToString():"");
sbquery.AppendLine();
foreach (var p in logicalrule.Parameters)
{
sbquery.AppendLine(p + " Query: ");
if (p.BaseQuery != null)
{
sbquery.AppendLine(p.BaseQuery != null ? p.BaseQuery.ToString() : "");
}
}
}
foreach (var gp in Taxonomy.ValidationParameters)
{
if (valueassertion.Test.Contains(gp.Value.XPathName))
{
if (gp.Key == "ReportingLevel")
{
var p_rl1 = new LogicalModel.Validation.ValidationParameter("ReportingLevel", logicalrule.ID);
p_rl1.StringValue = this.Taxonomy.EntryDocument.FileName.Contains("_con") ? "con" : "ind";
p_rl1.Type = LogicalModel.TypeEnum.String;
p_rl1.IsGeneral = true;
logicalrule.Parameters.Add(p_rl1);
continue;
}
if (gp.Key == "AccountingStandard")
{
var p_rl2 = new LogicalModel.Validation.ValidationParameter("AccountingStandard", logicalrule.ID);
p_rl2.StringValue = this.Taxonomy.EntryDocument.FileName.Contains("GAAP") ? "GAAP" : "IFRS";
p_rl2.Type = LogicalModel.TypeEnum.String;
p_rl2.IsGeneral = true;
logicalrule.Parameters.Add(p_rl2);
continue;
}
var p_rl = new LogicalModel.Validation.ValidationParameter(gp.Key, logicalrule.ID);
p_rl.StringValue = "Unresolved";
p_rl.Type = LogicalModel.TypeEnum.String;
p_rl.IsGeneral = true;
logicalrule.Parameters.Add(p_rl);
}
}
/*
* if (valueassertion.Test.Contains("$ReportingLevel"))
* {
* var p_rl1 = new LogicalModel.Validation.ValidationParameter("ReportingLevel", logicalrule.ID);
* p_rl1.StringValue = this.Taxonomy.EntryDocument.FileName.Contains("_con") ? "con" : "ind";
* p_rl1.Type = LogicalModel.TypeEnum.String;
* p_rl1.IsGeneral = true;
* logicalrule.Parameters.Add(p_rl1);
* }
* if (valueassertion.Test.Contains("$AccountingStandard"))
* {
* var p_rl2 = new LogicalModel.Validation.ValidationParameter("AccountingStandard", logicalrule.ID);
* p_rl2.StringValue = this.Taxonomy.EntryDocument.FileName.Contains("GAAP") ? "GAAP" : "IFRS";
* p_rl2.Type = LogicalModel.TypeEnum.String;
* p_rl2.IsGeneral = true;
* logicalrule.Parameters.Add(p_rl2);
* }
*/
logicalrule.SetTaxonomy(this.Taxonomy);
ValidationRuleHelper.ExecuteExplicitFiltering(this.Taxonomy, logicalrule);
ValidationRuleHelper.ExecuteImplicitFiltering(this.Taxonomy, logicalrule);
ValidationRuleHelper.ExecuteMatching(this.Taxonomy, logicalrule);
ValidationRuleHelper.CheckConsistency(this.Taxonomy, logicalrule);
//SetFacts(logicalrule);
return(logicalrule);
}
public override FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
//Console.WriteLine(String.Format("ExplicitDimensionFilter.GetQuery( {0} ) ", currentfilter.Item));
var _complement = Complement;
var factsofparts = taxonomy.FactsOfParts;
var factparts = taxonomy.FactParts;
var resultquery = new FactBaseQuery();
//var querycontainer = parent;
if (Members.Count == 0)
{
var dimkey = String.Format("{0}:{1}", this.Dimension.QName.Domain, this.Dimension.QName.Value);
var domains = taxonomy.DomainsofDimensions.ContainsKey(dimkey) ? taxonomy.DomainsofDimensions[dimkey] : new List <string>();
var firstdomain = domains.FirstOrDefault();
if (firstdomain != null)
{
var members = taxonomy.GetMembersOf(firstdomain).Where(i => !i.IsDefaultMember).ToList();
this.Members = members.Select(i => {
var dm = new DimensionMember();
dm.QName.Content = i.Content;
dm.IsDefaultMember = i.IsDefaultMember;
return(dm);
}).ToList();
}
}
var firstmemebr = Members.FirstOrDefault();
var domaintag = String.Format("[{0}:{1}]{2}", this.Dimension.QName.Domain, this.Dimension.QName.Value, firstmemebr.QName.Domain);
//FactBaseQuery resultquery = new FactBaseQuery();
var querycontainer = resultquery;
var poolneeded = Members.Count > 1 || (Members.Count == 1 && firstmemebr.IsDefaultMember && this.Complement);
if (poolneeded)
{
querycontainer = new FactPoolQuery();
resultquery.AddChildQuery(querycontainer);
//resultquery.DictFilterIndexes.Add(factparts[domaintag]);
//querycontainer = resultquery;
}
foreach (var member in Members)
{
var membertag = String.Format("[{0}:{1}]{2}", this.Dimension.QName.Domain, this.Dimension.QName.Value, member.QName.Content);
if (!member.IsDefaultMember)
{
if (!_complement)
{
if (factparts.ContainsKey(membertag))
{
var xquery = querycontainer;
if (xquery is FactPoolQuery)
{
var fbq = new FactBaseQuery();
xquery.AddChildQuery(fbq);
xquery = fbq;
}
xquery.DictFilterIndexes.Add(factparts[membertag]);
}
}
else
{
if (factparts.ContainsKey(membertag))
{
querycontainer.NegativeDictFilterIndexes.Add(factparts[membertag]);
}
}
}
else
{
//default member
if (!_complement)
{
if (factparts.ContainsKey(domaintag))
{
var xquery = querycontainer;
if (xquery is FactPoolQuery)
{
var fbq = new FactBaseQuery();
xquery.AddChildQuery(fbq);
xquery = fbq;
}
xquery.NegativeDictFilterIndexes.Add(factparts[domaintag]);
}
}
else
{
//default member with complement
if (Members.Count == 1)
{
var tag = String.Format("[{0}:{1}]", this.Dimension.QName.Domain, this.Dimension.QName.Value);
var domain = member.QName.Domain;
var members = taxonomy.GetMembersOf(domain, this._Members.Select(i => i.QName.Content).ToList());
foreach (var memberitem in members)
{
var mfbq = new FactBaseQuery();
var memberdictfilter = tag + memberitem;
//FP if (taxonomy.FactsOfDimensions.ContainsKey(memberdictfilter))
var ix = taxonomy.FactParts[memberdictfilter];
if (taxonomy.FactsOfParts.ContainsKey(ix))
{
mfbq.DictFilters = memberdictfilter + ", ";
if (factparts.ContainsKey(memberdictfilter))
{
mfbq.DictFilterIndexes.Add(factparts[memberdictfilter]);
}
querycontainer.AddChildQuery(mfbq);
}
}
//return resultquery;
}
else
{
if (factparts.ContainsKey(domaintag))
{
querycontainer.DictFilterIndexes.Add(factparts[domaintag]);
}
}
}
}
}
SetCover(resultquery);
return(resultquery);
}
public override FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
var query = new FactPoolQuery();
query.DictFilterIndexes.AddRange(parent.DictFilterIndexes);
foreach (var child in currentfilter.Children)
{
var filter = child.Item as Filter;
if (filter != null)
{
var childquery = filter.GetQuery(taxonomy, child, query);
query.AddChildQuery(childquery);
}
}
parent.AddChildQuery(query);
return(query);
}
public virtual void SetCover(FactBaseQuery query)
{
query.Cover = this.Cover;
}
//public abstract Func<string, bool> GetFunc(FactBaseQuery fbq);
//public virtual List<FactBaseQuery> GetQueries(Taxonomy taxonomy, int level)
//{
// var queries = new List<FactBaseQuery>();
// return queries;
//}
//public virtual FactBaseQuery GetQuery(Taxonomy taxonomy, int level)
//{
// var queries = new FactBaseQuery();
// return null;
//}
public virtual FactBaseQuery GetQuery(Taxonomy taxonomy, Hierarchy <XbrlIdentifiable> currentfilter, FactBaseQuery parent)
{
var queries = new FactBaseQuery();
return(null);
}
