public void ShowLabel(CommandIterator iterator, string memberGroupKey)
{
object objToHide = null;
switch (iterator.Selection)
{
case CommandIterator.SelectionType.Element:
objToHide = this.ElementRow;
break;
case CommandIterator.SelectionType.Period:
objToHide = this.Period;
break;
case CommandIterator.SelectionType.Unit:
objToHide = this.Unit;
break;
}
//this must be a segment...
if (objToHide == null)
{
objToHide = this.Segments.Find(seg => seg.DimensionInfo.dimensionId == memberGroupKey);
}
if (objToHide != null && this.hiddenObjects.Contains(objToHide))
{
this.hiddenObjects.Remove(objToHide);
}
}
public void GenerateEmbedLabel(ColumnRowRequirement embedRequirements, bool showDefault)
{
this.Labels.Clear();
string calendarLabel = null;
if (embedRequirements.HasSelectionType(CommandIterator.SelectionType.Period))
{
CommandIterator cmdI = Array.Find(embedRequirements.EmbedCommands, cmd => cmd.Selection == CommandIterator.SelectionType.Period);
if (cmdI != null)
{
calendarLabel = embedRequirements.GetLabel(cmdI, false);
}
}
string[] labels = embedRequirements.GetLabels(this.HasMultiCurrency, showDefault);
for (int i = 0; i < labels.Length; i++)
{
if (calendarLabel != null)
{
if (string.Equals(labels[i], calendarLabel))
{
this.Labels.Add(new LabelLine(i, labels[i], "Calendar"));
continue;
}
}
this.Labels.Add(new LabelLine(i, labels[i]));
}
}
public void Remove(CommandIterator iterator, string memberGroupKey)
{
switch (iterator.Selection)
{
case CommandIterator.SelectionType.Element:
this.ElementRow = null;
break;
case CommandIterator.SelectionType.Period:
this.Period = null;
break;
case CommandIterator.SelectionType.Unit:
this.Unit = null;
break;
}
//this must be a segment...
Segment segment = this.Segments.Find(seg => seg.DimensionInfo.dimensionId == memberGroupKey);
if (segment != null)
{
this.Segments.Remove(segment);
}
}
public void Add(CommandIterator iterator, object memberGroupValue)
{
switch (iterator.Selection)
{
case CommandIterator.SelectionType.Element:
this.ElementRow = memberGroupValue as InstanceReportRow;
break;
case CommandIterator.SelectionType.Period:
this.Period = memberGroupValue as CalendarPeriod;
break;
case CommandIterator.SelectionType.Unit:
this.Unit = (EmbeddedUnitWrapper)memberGroupValue;
break;
}
//this must be a segment...
Segment segment = memberGroupValue as Segment;
if (segment != null)
{
this.Segments.Add(segment);
}
}
/// <summary>
/// Retrieve all labels for a report.
/// </summary>
/// <param name="showCurrency">Whether or not to show currency labels.
/// </param>
/// <param name="showDefault">Whether or not to show default labels.
/// </param>
/// <returns></returns>
public string[] GetLabels(bool showCurrency, bool showDefault)
{
List <string> labels = new List <string>();
for (int c = 0; c < this.EmbedCommands.Length; c++)
{
CommandIterator iterator = this.EmbedCommands[c];
if (!showCurrency && iterator.Selection == CommandIterator.SelectionType.Unit)
{
continue;
}
string label = this.GetLabel(iterator, showDefault);
if (string.IsNullOrEmpty(label))
{
continue;
}
if (!labels.Contains(label))
{
labels.Add(label);
}
}
return(labels.ToArray());
}
//TODO make private
public bool Parse(out string embedWarning)
{
//As we read in all of our command tokens,
//there are a couple of things to keep in mind:
//Walter suggests that commands types have a specific order:
// columns then rows.
//If for any reason we can't discern the IteratorType,
//the default will be decided based on whether or not we've
//parsed any 'row' types yet.
bool foundRows = false;
string rowsAndCols;
if (!HasMatch(this.EmbedInstruction, out embedWarning, out this.Role, out rowsAndCols))
{
return(false);
}
MatchCollection matches = COMMAND_PARSER.Matches(rowsAndCols);
foreach (Match m in matches)
{
string type = m.Groups[GROUP_TYPE].Value;
string cmdSelection = m.Groups[GROUP_SELECTION].Value;
string style = m.Groups[GROUP_STYLE].Value;
string cmdFilter = m.Groups[GROUP_FILTER].Value;
CommandIterator.IteratorType cmdType = CommandIterator.ParseIteratorType(type, ref foundRows);
CommandIterator.StyleType cmdStyle = CommandIterator.ParseStyleType(style);
CommandIterator iterator = new CommandIterator(cmdType, cmdSelection, cmdStyle, cmdFilter);
this.LoadIterator(iterator);
}
return(true);
}
public bool HasSelectionType(CommandIterator iterator)
{
if (iterator.Selection == CommandIterator.SelectionType.Axis)
{
return(HasSelectionType(iterator.Selection, iterator.SelectionString, iterator.Filter));
}
else
{
return(this.HasSelectionType(iterator.Selection));
}
}
/// <summary>
/// Creates a new instance of <see cref="EmbedReport"/>.
/// </summary>
public EmbedReport()
{
if (!this.selections.ContainsKey("period"))
{
/**
* If the command has no iterator for “period”, it is assumed as an iterator starting the entire command, “column period compact *”.
**/
this.selections["period"] = CommandIterator.CreateDefaultPeriod();
}
//this.selections[ "unit" ] = new CommandIterator( CommandIterator.IteratorType.Column, "unit", CommandIterator.StyleType.Compact, "*" ) );
}
public string GetSeparator()
{
string separator = string.Empty;
CommandIterator ci = Array.Find(this.EmbedCommands, ec => ec.Selection == CommandIterator.SelectionType.Separator);
if (ci != null && !string.IsNullOrEmpty(ci.Filter))
{
separator = ci.Filter;
if (separator.Length > 1 && separator.StartsWith("\"") && separator.EndsWith("\""))
{
separator = separator.Substring(1, separator.Length - 2);
}
}
return(separator);
}
//TODO make private
public void LoadIterator(CommandIterator iterator)
{
if (iterator.Selection == CommandIterator.SelectionType.Axis)
{
this.selections[iterator.SelectionString] = iterator;
}
else if (iterator.Selection == CommandIterator.SelectionType.Element)
{
this.selections["primary"] = iterator;
}
else
{
this.selections[iterator.Selection.ToString().ToLower()] = iterator;
}
}
public KeyValuePair <string, object> GetMemberKeyValue(CommandIterator iterator)
{
switch (iterator.Selection)
{
case CommandIterator.SelectionType.Element:
return(new KeyValuePair <string, object>(this.ElementKey, this.ElementRow));
case CommandIterator.SelectionType.Period:
return(new KeyValuePair <string, object>(this.Period.ToString(), this.Period));
case CommandIterator.SelectionType.Unit:
return(new KeyValuePair <string, object>(this.UnitLabel, this.Unit));
}
//this must be a segment...
Segment segment = this.Segments.Find(seg => seg.DimensionInfo.dimensionId == iterator.SelectionString);
KeyValuePair <string, object> kvpSegment = kvpSegment = new KeyValuePair <string, object>(iterator.SelectionString, segment);
return(kvpSegment);
}
private Dictionary <string, object> GetSelectionMembers(
IEnumerable <CommandIterator> iteratorHierarchy, CommandIterator currentIterator,
out bool hasDefaultMember)
{
hasDefaultMember = false;
Dictionary <string, object> memberValues = null;
switch (currentIterator.Selection)
{
//these axis dictionaries are already in order by presentation
//the biggest challenge comes with the default member when moving data
case CommandIterator.SelectionType.Axis:
if (!this.AxisByPresentation.Contains(currentIterator.AxisName))
{
memberValues = new Dictionary <string, object>();
}
else
{
Segment defaultMember;
memberValues = this.baseReport.GetInUseSegmentDictionary(iteratorHierarchy, currentIterator, out defaultMember);
hasDefaultMember = (defaultMember != null);
}
break;
case CommandIterator.SelectionType.Element:
//memberValues = this.baseReport.GetElementDictionary( currentIterator.Type );
memberValues = this.baseReport.GetInUseElementDictionary(iteratorHierarchy, currentIterator);
break;
case CommandIterator.SelectionType.Period:
memberValues = this.baseReport.GetPeriodDictionary(currentIterator.Type);
break;
case CommandIterator.SelectionType.Unit:
//memberValues = this.baseReport.GetUnitDictionary( currentIterator.Type );
memberValues = this.baseReport.GetInUseUnitDictionary(iteratorHierarchy, currentIterator);
break;
}
return(memberValues);
}
/// <summary>
/// Return the combined label for the given commands.
/// </summary>
/// <param name="iterator">The label pieces.</param>
/// <param name="showDefault">Whether or not to show a default label
/// when one cannot be generated.</param>
/// <returns></returns>
public string GetLabel(CommandIterator iterator, bool showDefault)
{
if (iterator.Style == CommandIterator.StyleType.NoDisplay)
{
return(string.Empty);
}
switch (iterator.Selection)
{
case CommandIterator.SelectionType.Element:
if (this.hiddenObjects.Contains(this.ElementRow))
{
return(string.Empty);
}
else
{
return(this.ElementLabel);
}
case CommandIterator.SelectionType.Period:
if (this.hiddenObjects.Contains(this.Period))
{
return(string.Empty);
}
else
{
return(this.PeriodLabel);
}
case CommandIterator.SelectionType.Unit:
if (this.hiddenObjects.Contains(this.Unit))
{
return(string.Empty);
}
else
{
return(this.UnitLabel);
}
}
if (this.Segments == null || this.Segments.Count == 0)
{
return(string.Empty);
}
int segIdx = this.Segments.FindIndex(
seg =>
{
if (!string.Equals(seg.DimensionInfo.dimensionId, iterator.SelectionString))
{
return(false);
}
if (iterator.Filter == "*")
{
if (seg.IsDefaultForEntity)
{
return(showDefault);
}
else
{
return(true);
}
}
if (!string.Equals(seg.DimensionInfo.Id, iterator.Filter))
{
return(false);
}
if (seg.IsDefaultForEntity)
{
return(showDefault);
}
else
{
return(true);
}
});
if (segIdx == -1)
{
return(string.Empty);
}
else if (this.hiddenObjects.Contains(this.Segments[segIdx]))
{
return(string.Empty);
}
else
{
return(this.SegmentLabels[segIdx]);
}
}
private bool SortByCommands(CommandIterator[] commands)
{
if (commands == null || commands.Length == 0)
{
return(false);
}
CommandIterator.IteratorType type = commands[0].Type;
//sorting may only be performed on rows or columsn. 'Unknown' is not allowed.
if (type == CommandIterator.IteratorType.Unknown)
{
return(false);
}
//sorting may only be performed on items of a consistent type (rows or columns)
if (!Array.TrueForAll(commands, c => c.Type == type))
{
return(false);
}
//collect all of the possible values in command order
List <string>[] commandValueKeys = new List <string> [commands.Length];
CommandIterator[] emptySet = new CommandIterator[0];
for (int i = 0; i < commands.Length; i++)
{
//we can't compare a separator
if (commands[i].Selection == CommandIterator.SelectionType.Separator)
{
commandValueKeys[i] = null;
}
else
{
bool hasDefaultMember;
Dictionary <string, object> tmp = this.GetSelectionMembers(emptySet, commands[i], out hasDefaultMember);
List <string> sortedKeys = new List <string>(tmp.Keys);
commandValueKeys[i] = sortedKeys;
}
}
ItemSorter sorter = (left, right) =>
{
for (int i = 0; i < commands.Length; i++)
{
//we can't compare a separator
if (commands[i].Selection == CommandIterator.SelectionType.Separator)
{
continue;
}
List <string> valueKeys = commandValueKeys[i];
int leftIdx = 0;
int rightIdx = 0;
switch (commands[i].Selection)
{
case CommandIterator.SelectionType.Axis:
string leftSegment = ((Segment)left.EmbedRequirements.GetMemberKeyValue(commands[i]).Value).DimensionInfo.Id;
string rightSegment = ((Segment)right.EmbedRequirements.GetMemberKeyValue(commands[i]).Value).DimensionInfo.Id;
leftIdx = valueKeys.IndexOf(leftSegment);
rightIdx = valueKeys.IndexOf(rightSegment);
break;
case CommandIterator.SelectionType.Element:
leftIdx = valueKeys.IndexOf(left.EmbedRequirements.ElementKey);
rightIdx = valueKeys.IndexOf(right.EmbedRequirements.ElementKey);
break;
case CommandIterator.SelectionType.Period:
leftIdx = valueKeys.IndexOf(left.EmbedRequirements.PeriodLabel);
rightIdx = valueKeys.IndexOf(right.EmbedRequirements.PeriodLabel);
break;
case CommandIterator.SelectionType.Unit:
leftIdx = valueKeys.IndexOf(left.EmbedRequirements.UnitCode);
rightIdx = valueKeys.IndexOf(right.EmbedRequirements.UnitCode);
break;
}
if (leftIdx < rightIdx)
{
return(-1);
}
if (leftIdx > rightIdx)
{
return(1);
}
}
return(0);
};
if (type == CommandIterator.IteratorType.Column)
{
this.InstanceReport.Columns.Sort((left, right) => sorter(left, right));
}
else
{
this.InstanceReport.Rows.Sort((left, right) => sorter(left, right));
}
return(true);
}
private void AddDefaultIterators(InstanceReport embedReport)
{
//period and primary are added in the constructor and Parse() respectively.
//Now we look for any additional segments that are not on the ColumnIterators
//And perhaps also add the units
Dictionary <string, int> uniqueAxisList = new Dictionary <string, int>();
foreach (InstanceReportColumn col in embedReport.Columns)
{
if (col.Segments == null)
{
continue;
}
if (col.Segments.Count == 0)
{
continue;
}
foreach (Segment s in col.Segments)
{
uniqueAxisList[s.ValueType] = 1;
}
}
foreach (string axis in this.selections.Keys)
{
if (uniqueAxisList.ContainsKey(axis))
{
uniqueAxisList.Remove(axis);
}
}
List <string> axisList = new List <string>(uniqueAxisList.Keys);
axisList.Sort(this.AxisSorter);
foreach (string axis in axisList)
{
CommandIterator itr = new CommandIterator
{
Type = CommandIterator.IteratorType.Column,
SelectionString = axis,
Style = CommandIterator.StyleType.Compact,
Filter = "*"
};
this.selections[itr.SelectionString] = itr;
}
if (!this.selections.ContainsKey("primary"))
{
/**
* If the command has no iterator for “primary”, it is assumed that the entire command ends with iterator “row primary compact *”.
**/
this.selections["primary"] = CommandIterator.CreateDefaultPrimary();
}
if (!this.selections.ContainsKey("unit"))
{
/**
* If the command has no iterator for “primary”, it is assumed that the entire command ends with iterator “row primary compact *”.
**/
this.selections["unit"] = CommandIterator.CreateDefaultUnit();
}
}
