/// <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; }