public IFieldMapper Parse(JobParser parser, ParseState state)
{
var dimension = state.ParseDimension();
var keyName = state.AffixName(state.TryGet("KeyName", () => dimension.GetType().Name + "Key"));
var labelName = state.AffixName(state.TryGet("LabelName", () => dimension.GetType().Name + "Label"));
return(new LabeledFieldMapper(new XaFieldMapper(dimension, false, keyName), labelName,
XaLabelProvider.FromDimension(dimension, parser.DefaultLanguage), friendlyName: XaFieldMapper.SuggestFriendlyLabelName(labelName)));
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
return(new SimpleFieldMapper(state.AffixName("ContactId"), scope => scope.Current <IVisitAggregationContext>().TryGet(ctx => ctx.Visit.ContactId), typeof(Guid),
valueKind: "ContactId",
calculatedFields: new[]
{
new CalculatedField {
Name = "Unique visitors",
DaxPattern = string.Format("DISTINCTCOUNT([{0}])", state.AffixName("ContactId")),
ChildDaxPattern = string.Format("CALCULATE(DISTINCTCOUNT(@Parent[{0}]), @TableName)", state.AffixName("ContactId")),
FormatString = CalculatedFieldFormat.Integer
}
}));
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
var selector = state.TryGet("Select", DefaultPath, true);
if (selector.StartsWith("/"))
{
selector = DefaultPath + selector;
}
var getter = parser.CompileGetter(typeof(T), selector);
var name = state.TryGet("Name", DefaultName ?? SuggestName(getter.SuggestedName));
var fieldType = (FieldType)Enum.Parse(typeof(FieldType), state.TryGet("Type", "Dimension"), true);
IFieldMapper mapper = new SimpleFieldMapper(state.AffixName(name),
scope => SelectItem(scope).TryGet(item => getter.Getter(item, scope), getter.DefaultValue),
getter.ValueType, fieldType);
var labelState = state.Select("Labels");
if (labelState != null)
{
var labels = labelState.Keys.ToDictionary(labelState.AffixName, key =>
(ILabelProvider)
new SitecoreFieldLabelProvider(labelState.TryGet <string>(key), parser.DefaultLanguage));
if (labels.Count > 0)
{
return(new LabeledFieldMapper(mapper, labels));
}
}
return(mapper);
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
var testIdString = state.Require <string>("TestId", true);
Guid testId;
if (!Guid.TryParse(testIdString, out testId))
{
throw state.AttributeError("Invalid test id specified ({0})", testIdString);
}
var testSet = TestManager.GetTestSet(testId);
var testMapper = new MvTestFieldMapper(testSet, state.AffixName(state.TryGet("Name", "MvTest")));
if (state.SelectMany("Fields").Any())
{
var splitter = new SplittingFieldMapper(new MvTestSplitter(testId),
postfix =>
state.Postfix(postfix).SelectMany("Fields").Select(parser.ParseFieldMapper).ToArray());
return(new FieldMapperSet(testMapper.Name, true, new IFieldMapper[] { testMapper, splitter }, state.AffixName));
}
return(testMapper);
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
var name = state.AffixName(state.TryGet("Name", "Count", true));
var scopeOffset = Math.Abs(state.TryGet("Scope", 0));
return(new SimpleFieldMapper(name, ctx =>
{
if (scopeOffset == 0)
{
return 1;
}
var p = ctx;
for (var i = 0; i < scopeOffset && p != null; i++)
{
p = p.Parent;
}
if (p != null)
{
return ctx.OncePerScope(p, 1);
}
return 0;
}, typeof(int), FieldType.Fact));
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
var tableName = state.Require <string>("Name");
var inline = state.TryGet("Inline", false);
var fieldState = state.Clone();
var affix = state.TryGet("AffixNames", true);
if (affix)
{
tableName = state.AffixName(tableName);
}
else
{
fieldState = fieldState.ClearAffix();
}
var fieldPrefix = state.TryGet("Prefix", "");
return(new FieldMapperSet(tableName, inline,
fieldState.SelectMany("Fields").Select(parser.ParseFieldMapper), state.AffixName,
fieldNamePrefix: fieldPrefix)
{
Key = state.TryGet("Key", false)
});
}
public IFieldMapper Parse(JobParser parser, ParseState state)
{
var name = state.AffixName(state.TryGet("Name", "Index", true));
var scopeOffset = Math.Abs(state.TryGet("Scope", -1, true));
return(new SimpleFieldMapper(name, ctx =>
{
if (scopeOffset == 0)
{
return ctx.GlobalIndex;
}
var p = ctx;
for (var i = 0; i < scopeOffset && p != null; i++)
{
p = p.Parent;
}
if (p != null)
{
return ctx.Index(p);
}
return 0;
}, typeof(int), FieldType.Dimension));
}
protected override IFieldMapper Parse(Func <ProcessingScope, DateTime?> selector, string defaultName,
JobParser parser, ParseState state)
{
return(new TimeDimension(
state.AffixName(state.TryGet("Name", defaultName + "Time")),
selector,
inlineFields: state.TryGet <bool>("Inline"),
cultureInfo: parser.DefaultLanguage.CultureInfo,
detailLevel: state.TryGet("Resolution", TimeDetailLevel.Hour, true)));
}
protected override IFieldMapper Parse(Func<ProcessingScope, DateTime?> selector, string defaultName,
JobParser parser, ParseState state)
{
return new TimeDimension(
state.AffixName(state.TryGet("Name", defaultName + "Time")),
selector,
inlineFields: state.TryGet<bool>("Inline"),
cultureInfo: parser.DefaultLanguage.CultureInfo,
detailLevel: state.TryGet("Resolution", TimeDetailLevel.Hour, true));
}
protected override IFieldMapper Parse(Func<ProcessingScope, DateTime?> selector, string defaultName,
JobParser parser, ParseState state)
{
return new DateDimension(
state.AffixName(state.TryGet("Name", defaultName)),
selector,
useDateForKey: state.TryGet("DateKey", true),
inlineFields: state.TryGet("Inline", false),
cultureInfo: parser.DefaultLanguage.CultureInfo,
key: state.TryGet("Key", false),
detailLevel:
state.TryGet("Resolution", DateDetailLevel.Date, true));
}
protected override IFieldMapper Parse(Func <ProcessingScope, DateTime?> selector, string defaultName,
JobParser parser, ParseState state)
{
return(new DateDimension(
state.AffixName(state.TryGet("Name", defaultName)),
selector,
useDateForKey: state.TryGet("DateKey", true),
inlineFields: state.TryGet("Inline", false),
cultureInfo: parser.DefaultLanguage.CultureInfo,
key: state.TryGet("Key", false),
detailLevel:
state.TryGet("Resolution", DateDetailLevel.Date, true)));
}
public ITableMapper Parse(JobParser parser, ParseState state)
{
var dimension = state.ParseDimension();
var extraFields = state.SelectMany("Fields").Select(parser.ParseFieldMapper);
var name = state.TryGet("Name", XaTableMapper.SuggestFriendlyTableName(dimension.GetType().Name));
return(new XaTableMapper(dimension,
state.AffixName(name),
state.TryGet <string>("Name"),
state.TryGet <bool>("HashKey", true),
keyName: state.TryGet <string>("KeyName"),
labelName: state.TryGet <string>("LabelName"),
additionalFields: extraFields,
factTypes: XaFactsFieldFactory.ParseFactTypes(state.TryGet("Facts", new string[0])),
labelProvider: XaLabelProvider.FromDimension(dimension, parser.DefaultLanguage)
));
}
public ITableMapper Parse(JobParser parser, ParseState state)
{
var source = state.TryGet <string>("Select", mainParameter: true) ?? "Pages";
var type = state.TryGet("Type", "CoOccurrence");
var name = state.TryGet("Name", source + type);
var selector = Selectors.SelectFromName(source);
Func <ProcessingScope, IEnumerable <Tuple <object, object> > > matrix;
if (type.Equals("cooccurrence", StringComparison.InvariantCultureIgnoreCase))
{
matrix = scope => MatrixTypes.CoOcurrence(selector(scope));
}
else if (type.Equals("links", StringComparison.InvariantCultureIgnoreCase))
{
matrix = scope => MatrixTypes.Links(selector(scope));
}
else
{
throw state.AttributeError("Unkown matrix type '{0}'", type);
}
var facts = state.SelectMany("CommonFields").Select(parser.ParseFieldMapper).ToList();
if (state.Select("CommonFields") == null)
{
facts.Add(new SimpleFieldMapper("Count", s => 1, typeof(int), FieldType.Fact));
}
return(new MatrixTableMapper(state.AffixName(name), matrix, postfix =>
state.Postfix(postfix).SelectMany("Fields", true).Select(parser.ParseFieldMapper).ToArray(), facts));
}
public ITableMapper Parse(JobParser parser, ParseState state)
{
var table = new TableDefinition(state.TryGet("Name", "Funnel"));
var stepDefinitions = new List <FunnelStepDefinition>();
var i = 1;
foreach (var step in state.SelectMany("Steps", true))
{
var def = new FunnelStepDefinition {
Name = step.TryGet("Name", "Step " + i)
};
def.Events = new HashSet <string>(StringComparer.InvariantCultureIgnoreCase);
foreach (var name in step.Require <string[]>("Events"))
{
def.Events.Add(name);
}
stepDefinitions.Add(def);
++i;
}
var helper = new FunnelHelper(stepDefinitions);
table.FieldMappers = new List <IFieldMapper>();
table.FieldMappers.Add(
new SimpleFieldMapper(state.AffixName("StepNumber"), scope => scope.Current <FunnelStep>().Number, typeof(int)));
table.FieldMappers.Add(
new SimpleFieldMapper(state.AffixName("Step"), scope => scope.Current <FunnelStep>().Name, typeof(string), sortBy: state.AffixName("StepNumber")));
table.FieldMappers.Add(
new SimpleFieldMapper(state.AffixName("Continued"), scope => scope.Current <FunnelStep>().Continued, typeof(int), FieldType.Fact,
calculatedFields: new[]
{
new CalculatedField {
Name = state.AffixName("Continued %"),
FormatString = CalculatedFieldFormat.Percentage,
DaxPattern =
String.Format("IF(SUM([{0}])=0,Blank(),SUM([{1}])/SUM([{0}]))", state.AffixName("Potential"), state.AffixName("Continued"))
}
}));
table.FieldMappers.Add(
new SimpleFieldMapper(state.AffixName("Fallout"), scope => scope.Current <FunnelStep>().Fallout, typeof(int), FieldType.Fact,
calculatedFields: new[]
{
new CalculatedField {
Name = state.AffixName("Fallout %"),
FormatString = CalculatedFieldFormat.Percentage,
DaxPattern =
String.Format("IF(SUM([{0}])=0,Blank(),SUM([{1}])/SUM([{0}]))", state.AffixName("Potential"), state.AffixName("Fallout"))
}
}));
table.FieldMappers.Add(
new SimpleFieldMapper(state.AffixName("Potential"), scope => scope.Current <FunnelStep>().Fallout + scope.Current <FunnelStep>().Continued, typeof(int), FieldType.Fact));
foreach (var fm in state.SelectMany("Fields").Select(parser.ParseFieldMapper))
{
table.FieldMappers.Add(fm);
}
return(new SimpleTableMapper(helper.GetSteps, table));
}
