/// <summary>
/// Retrieves fluent configuration wrapper for form field
/// </summary>
/// <typeparam name="TData">Field type</typeparam>
/// <param name="field">Field expression</param>
/// <returns>Formwatch field configuration builder</returns>
public FormWatchFieldBuilder <TData> Field <TData>(Expression <Func <TFormViewModel, TData> > field)
{
var prop = LambdaHelpers.ParsePropertyLambda(field);
AssureFieldConfiguration <TData>(prop);
return((FormWatchFieldBuilder <TData>)_fieldsConfig[prop.Name]);
}
/// <summary>
/// Filters specified target table field with form field treated as ValueFilter.
/// Warning! ValueFilter should be configured for column
/// </summary>
/// <param name="expr">Property expression</param>
/// <param name="af">Filter</param>
public static void FilterValueExpr <TCol, TForm>(this FormWatchAutofilterConfiguration <TCol, TForm> af, LambdaExpression expr)
{
af.Update(new FormWatchFilteringsMappings()
{
FilterType = 0,
FieldKeys = new[] { LambdaHelpers.ParsePropertyLambda(expr).Name }
});
}
/// <summary>
/// Filters specified target table field with form field treated as Range Filter.
/// In this case field is list or array (e.g. mapped to multiple select)
/// Warning! SelectFilter with multiple options should be configured for column
/// </summary>
/// <param name="field">Fields that will be merged into multiple filter values</param>
public static void FilterMultiple <TCol, TForm>(this FormWatchAutofilterConfiguration <TCol, TForm> af, Expression <Func <TForm, IEnumerable <TCol> > > field)
{
af.Update(new FormWatchFilteringsMappings()
{
FilterType = 2,
FieldKeys = new [] { LambdaHelpers.ParsePropertyLambda(field).Name }
});
}
/// <summary>
/// Filters specified target table field with form field treated as Range Filter.
/// Warning! SelectFilter with multiple options should be configured for column
/// </summary>
/// <param name="fields">Fields that will be merged into multiple filter values</param>
public static void FilterMultiple <TCol, TForm>(this FormWatchAutofilterConfiguration <TCol, TForm> af, params Expression <Func <TForm, TCol> >[] fields)
{
af.Update(new FormWatchFilteringsMappings()
{
FilterType = 2,
FieldKeys = fields.Select(c => LambdaHelpers.ParsePropertyLambda(c).Name).ToArray()
});
}
/// <summary>
/// Filters specified target table field with form field treated as Range Filter.
/// Warning! RangeFilter should be configured for column
/// </summary>
/// <param name="from">Field containig from value</param>
/// <param name="to">Field containing to value</param>
public static void FilterRange <TCol, TForm>(this FormWatchAutofilterConfiguration <TCol, TForm> af, Expression <Func <TForm, IEnumerable <TCol?> > > values)
where TCol : struct
{
af.Update(new FormWatchFilteringsMappings()
{
FilterType = 1,
FieldKeys = new[] { LambdaHelpers.ParsePropertyLambda(values).Name }
});
}
/// <summary>
/// Filters specified target table field with form field treated as Range Filter.
/// Warning! RangeFilter should be configured for column
/// </summary>
/// <param name="expr">Property expression</param>
/// <param name="af">Filter</param>
public static void FilterRangeExpr <TCol, TForm>(this FormWatchAutofilterConfiguration <TCol, TForm> af, LambdaExpression from, LambdaExpression to)
{
af.Update(new FormWatchFilteringsMappings()
{
FilterType = 1,
FieldKeys = new[] { LambdaHelpers.ParsePropertyLambda(from).Name,
LambdaHelpers.ParsePropertyLambda(to).Name, }
});
}
/// <summary>
/// Adds client total calculator function to totals
/// Calculator function type: (data:IClientDataResults)=>any
/// data: data prepared on client side. Consists of 4 collections: Source, Filtered, Ordered, Displaying all of type any[] containing corresponding JSONed TTableData
/// </summary>
/// <param name="column">Table column to provide total with</param>
/// <param name="function">Client calculator function</param>
/// <returns></returns>
public TotalCalculatorBuilder <TSourceData, TTableData> AddClientCalculator <TTableColumn>(
Expression <Func <TTableData, TTableColumn> > column,
string function
)
{
var name = LambdaHelpers.ParsePropertyLambda(column).Name;
_clientCalculators.Add(name, function);
return(this);
}
/// <summary>
/// Adds only template for total cell
/// </summary>
/// <param name="column">Table column to provide total with</param>
/// <param name="templateBuilder">Template builder like for usual column, but here is only self reference ('{@}') available </param>
/// <returns></returns>
public TotalCalculatorBuilder <TSourceData, TTableData> AddTemplate <TTableColumn>(
Expression <Func <TTableData, TTableColumn> > column,
Action <CellTemplateBuilder> templateBuilder
)
{
var name = LambdaHelpers.ParsePropertyLambda(column).Name;
CellTemplateBuilder ctb = new CellTemplateBuilder(null);
templateBuilder(ctb);
_valueFunctions.Add(name, ctb.Build());
return(this);
}
/// <summary>
/// Adds total calculator to table
/// </summary>
/// <param name="column">Table column to provide total with</param>
/// <param name="calculator">Total calculator consuming ready-to-send table data and producing some value</param>
/// <param name="valueFunction">Function that will be used to format total in the table.
/// Function type is (v:any) => string
/// v: value that you have calculated previously
/// </param>
/// <returns></returns>
public TotalCalculatorBuilder <TSourceData, TTableData> AddTotal <TTableColumn, TTotalType>(
Expression <Func <TTableData, TTableColumn> > column,
Func <PowerTablesData <TSourceData, TTableData>, TTotalType> calculator,
string valueFunction = null
)
{
var name = LambdaHelpers.ParsePropertyLambda(column).Name;
_calculators.Add(name, calculator);
_valueFunctions.Add(name, valueFunction);
return(this);
}
/// <summary>
/// Exclude specified column
/// </summary>
/// <typeparam name="TTableColumn"></typeparam>
/// <param name="column">Column</param>
/// <returns>Fluent</returns>
public ColumnListBuilder <TSourceData, TTableData> Except <TTableColumn>(
Expression <Func <TTableData, TTableColumn> > column)
{
var info = LambdaHelpers.ParsePropertyLambda(column);
if (!_colNames.Contains(info.Name))
{
return(this);
}
_colNames.Remove(info.Name);
return(this);
}
/// <summary>
/// Retrieves column configurator
/// </summary>
/// <typeparam name="TColType">Column type</typeparam>
/// <param name="column">Column</param>
/// <returns>Corresponding column configurator</returns>
public ColumnUsage <TSourceData, TTableData, TColType> Column <TColType>(Expression <Func <TTableData, TColType> > column)
{
var targetProperty = LambdaHelpers.ParsePropertyLambda(column);
targetProperty = _tableColumnsDictionary[targetProperty.Name];
if (_configurators.ContainsKey(targetProperty))
{
return((ColumnUsage <TSourceData, TTableData, TColType>)_configurators[targetProperty]);
}
ColumnUsage <TSourceData, TTableData, TColType> usage = new ColumnUsage <TSourceData, TTableData, TColType>(this, column, GetColumnConfiguration(targetProperty));
_configurators[targetProperty] = usage;
return(usage);
}
/// <summary>
/// Adds client total calculator that produces count of rows
/// </summary>
/// <param name="conf">Configuration</param>
/// <param name="column">Table column to provide total with</param>
/// <param name="clientDataSet">Client data set to perform calculations on</param>
/// <param name="template">Tempalte for total cell</param>
/// <returns></returns>
public static TotalCalculatorBuilder <TSourceData, TTableData> AddClientCount <TSourceData, TTableData, TTableColumn>(
this TotalCalculatorBuilder <TSourceData, TTableData> conf,
Expression <Func <TTableData, TTableColumn> > column,
ClientDataSet clientDataSet,
Action <CellTemplateBuilder> template = null
) where TTableData : new()
{
var name = LambdaHelpers.ParsePropertyLambda(column).Name;
var function = string.Format("function(v){{ return v.{0}.length; }}", clientDataSet);
conf.ClientCalculators.Add(name, function);
if (template != null)
{
conf.AddTemplate(column, template);
}
return(conf);
}
/// <summary>
/// Adds client total calculator that produces maximum of supplied row values
/// </summary>
/// <param name="conf">Configuration</param>
/// <param name="column">Table column to provide total with</param>
/// <param name="expression">`{@}`-syntax expression minimum of which will be found</param>
/// <param name="clientDataSet">Client data set to perform calculations on</param>
/// <param name="template">Tempalte for total cell</param>
/// <returns></returns>
public static TotalCalculatorBuilder <TSourceData, TTableData> AddClientMax <TSourceData, TTableData, TTableColumn>(
this TotalCalculatorBuilder <TSourceData, TTableData> conf,
Expression <Func <TTableData, TTableColumn> > column,
string expression,
ClientDataSet clientDataSet,
Action <CellTemplateBuilder> template = null
) where TTableData : new()
{
var name = LambdaHelpers.ParsePropertyLambda(column).Name;
var function = CreateExtremumFunction(expression, true, clientDataSet);
conf.ClientCalculators.Add(name, function);
if (template != null)
{
conf.AddTemplate(column, template);
}
return(conf);
}
/// <summary>
/// Places select checkboxes within every row
/// </summary>
/// <typeparam name="TSourceData"></typeparam>
/// <typeparam name="TTableData"></typeparam>
/// <typeparam name="TTableColumn"></typeparam>
/// <param name="conf">Table configuration</param>
/// <param name="column">Column that will be used as ID provider for select checkbox</param>
/// <param name="selectAllBehavior">Behavior for "Select All" button</param>
/// <param name="ui">UI configuration</param>
/// <returns></returns>
public static Configurator <TSourceData, TTableData> Checkboxify <TSourceData, TTableData, TTableColumn>(
this Configurator <TSourceData, TTableData> conf,
Expression <Func <TTableData, TTableColumn> > column,
SelectAllBehavior selectAllBehavior = SelectAllBehavior.OnlyIfAllDataVisible,
Action <PluginConfigurationWrapper <CheckboxifyClientConfig> > ui = null
) where TTableData : new()
{
var targetProp = LambdaHelpers.ParsePropertyLambda(column);
var colName = targetProp.Name;
CheckboxifyClientConfig ccc = new CheckboxifyClientConfig
{
SelectionColumnName = colName
};
switch (selectAllBehavior)
{
case SelectAllBehavior.Disabled:
ccc.EnableSelectAll = false;
break;
case SelectAllBehavior.CurrentPage:
//ccc.ResetOnReload = true;
ccc.EnableSelectAll = true;
break;
case SelectAllBehavior.OnlyIfAllDataVisible:
ccc.EnableSelectAll = true;
ccc.SelectAllOnlyIfAllData = true;
break;
case SelectAllBehavior.AllLocal:
ccc.EnableSelectAll = true;
ccc.SelectAllSelectsClientUndisplayedData = true;
break;
case SelectAllBehavior.InvolveServer:
try
{
var p = typeof(TSourceData).GetProperty(colName);
if (p.PropertyType != targetProp.PropertyType)
{
throw new Exception();
}
}
catch (Exception ex)
{
throw new Exception(
String.Format(
"In case of using SelectAllBehavior.InvolveServer, please assure that property {0} exists on both {1} and {2} types and represents same data",
colName, typeof(TSourceData).FullName, typeof(TTableData).FullName));
}
ccc.EnableSelectAll = true;
ccc.SelectAllSelectsServerUndisplayedData = true;
conf.RegisterCommandHandler <CheckboxifyCommandHandler>("checkboxify_all");
break;
}
conf.TableConfiguration.ReplacePluginConfig(PluginId, ccc);
conf.TableConfiguration.UpdatePluginConfig(PluginId, ui);
return(conf);
}
internal ColumnUsage(Configurator <TSourceData, TTableData> configurator, Expression <Func <TTableData, TTableColumn> > tableColumnExpression, ColumnConfiguration columnConfiguration)
{
_columnProperty = LambdaHelpers.ParsePropertyLambda(tableColumnExpression);
_configurator = configurator;
_columnConfiguration = columnConfiguration;
}
