static void Filter(IDashboardDefinition template, DevExpress.DashboardCommon.Dashboard dashboard)
{
//var types = template.DashboardTypes.Select(tw => tw.Caption).ToArray();
//for (int i = dashboard.DataSources.Count - 1; i >= 0; i--)
// if (!types.Contains(dashboard.DataSources[i].Name))
// dashboard.DataSources.RemoveAt(i);
}
private static void ConfigureDashboard(IDashboardDefinition dashboardDefinition, RuleMode ruleMode,
IXpandDashboardDataSourceFillService dashboardCollectionDataSourceFillService, DataSourceOptionsContainer options,
Action <DevExpress.DashboardCommon.Dashboard> editParameters,
DashboardDatasourceFilterList datasourceFilterList, DevExpress.DashboardCommon.Dashboard dashboard)
{
var canEditParameters = new[] { ruleMode, RuleMode.Always }.Contains(dashboardDefinition.EditParameters);
if (canEditParameters)
{
editParameters(dashboard);
}
dashboardCollectionDataSourceFillService.FillService.DatasourceCreating += (sender, args) => {
var filter = datasourceFilterList.Filters.LastOrDefault(_ => _.DataSourceName == args.TargetType.Name);
if (filter != null)
{
dashboardCollectionDataSourceFillService.TopReturnedRecords = filter.TopReturnedRecords;
dashboardCollectionDataSourceFillService.ShowPersistentMembersOnly =
filter.ShowPersistentMembersOnly;
}
};
if (options != null)
{
options.ObjectDataSourceLoadingBehavior = DocumentLoadingBehavior.LoadAsIs;
}
}
public static void ApplyModel(this DevExpress.DashboardCommon.Dashboard dashboard, RuleMode ruleMode,
IDashboardDefinition template, IModelApplication model)
{
var dataSources = GetDataSources(dashboard, ruleMode, template, model);
foreach (var adapter in dataSources)
{
if (adapter.ModelDataSource is IModelDashboardDataSourceFilter filter)
{
var criteria = ApplyFilter(filter.Filter, adapter.DataSource.Filter);
adapter.DataSource.Filter = criteria?.ToString();
if (adapter.DataSource is DashboardSqlDataSource dashboardSqlDataSource)
{
foreach (var selectQuery in dashboardSqlDataSource.Queries.OfType <SelectQuery>().Where(query => Regex.IsMatch(query.Name, filter.TableName)))
{
if (filter.TopReturnedRecords > 0)
{
selectQuery.Top = filter.TopReturnedRecords;
}
selectQuery.FilterString = criteria?.ToString();
}
}
}
else if (adapter.ModelDataSource is IModelDashboardDataSourceParameter parameter)
{
parameter.ApplyValue(dashboard.Parameters[parameter.ParameterName]);
}
}
}
public static DevExpress.DashboardCommon.Dashboard CreateDashBoard(this IDashboardDefinition template, IObjectSpace objectSpace, FilterEnabled filterEnabled)
{
var dashboard = new DevExpress.DashboardCommon.Dashboard();
try {
if (!string.IsNullOrEmpty(template.Xml))
{
dashboard = LoadFromXml(template);
dashboard.ApplyModel(filterEnabled, template, objectSpace);
}
foreach (var typeWrapper in template.DashboardTypes.Select(wrapper => new { wrapper.Type, Caption = GetCaption(wrapper) }))
{
var wrapper = typeWrapper;
var dsource = dashboard.DataSources.FirstOrDefault(source => source.Name.Equals(wrapper.Caption));
var objects = objectSpace.CreateDashboardDataSource(wrapper.Type);
if (dsource != null)
{
dsource.Data = objects;
}
else if (!dashboard.DataSources.Contains(ds => ds.Name.Equals(wrapper.Caption)))
{
dashboard.AddDataSource(typeWrapper.Caption, objects);
}
}
}
catch (Exception e) {
dashboard.Dispose();
Tracing.Tracer.LogError(e);
}
return(dashboard);
}
public static DevExpress.DashboardCommon.Dashboard GetDashboard(this IDashboardDefinition dashboardDefinition,
XafApplication application, RuleMode ruleMode, IXpandDashboardDataSourceFillService dashboardDataSourceFillService = null,
DataSourceOptionsContainer options = null, Action <DevExpress.DashboardCommon.Dashboard> editParameters = null, Action modeParametersEdited = null)
{
var dashboard = dashboardDefinition.GetDashboard();
dashboard.ApplyModel(ruleMode, dashboardDefinition, application.Model);
var datasourceFilterList = dashboard.CreateDashboardDatasourceFilterList(dashboardDefinition, ruleMode, application);
var dashboardDatasourceFilter = datasourceFilterList.Filters.FirstOrDefault();
if (modeParametersEdited != null)
{
if (dashboardDatasourceFilter != null)
{
var detailView =
application.CreateDetailView(dashboardDatasourceFilter.ObjectSpace, datasourceFilterList);
detailView.ViewEditMode = ViewEditMode.Edit;
application.ShowViewStrategy.ShowViewInPopupWindow(detailView,
() => {
SaveModel(datasourceFilterList, application);
modeParametersEdited();
});
}
return(dashboard);
}
ConfigureDashboard(dashboardDefinition, ruleMode, dashboardDataSourceFillService, options, editParameters, datasourceFilterList, dashboard);
return(dashboard);
}
static void Filter(IDashboardDefinition template, DevExpress.DashboardCommon.Dashboard dashboard)
{
//var types = template.DashboardTypes.Select(tw => tw.Caption).ToArray();
//for (int i = dashboard.DataSources.Count - 1; i >= 0; i--)
// if (!types.Contains(dashboard.DataSources[i].Name))
// dashboard.DataSources.RemoveAt(i);
}
public static void SynchronizeModel(this DevExpress.DashboardCommon.Dashboard dashboard, IDashboardDefinition template) {
var dataSources = GetDataSources(dashboard, FilterEnabled.Always, template);
foreach (var dataSource in dataSources){
var filter = dataSource.ModelDataSource as IModelDashboardDataSourceFilter;
if (filter != null)
dataSource.DataSource.Filter = filter.SynchronizeFilter(dataSource.DataSource.Filter);
}
}
static DevExpress.DashboardCommon.Dashboard GetDashboard(this IDashboardDefinition dashboardDefinition)
{
var dashboard = dashboardDefinition.ToDashboard();
MigrateDatasourceTypes(dashboard);
AddNewDataSources(dashboardDefinition, dashboard);
return(dashboard);
}
protected override void OnClosed(EventArgs e) {
_editHistory.Changed -= _EditHistory_Changed;
_editHistory = null;
_template = null;
_objectSpace = null;
dashboardDesigner.Dashboard.Dispose();
dashboardDesigner = null;
base.OnClosed(e);
}
public static DevExpress.DashboardCommon.Dashboard CreateDashBoard(this IDashboardDefinition template, FilterEnabled filterEnabled)
{
var dashBoard = CreateDashBoard(template);
if (dashBoard != null)
{
dashBoard.ApplyModel(filterEnabled, template);
}
return(dashBoard);
}
protected override void OnClosed(EventArgs e)
{
_editHistory.Changed -= _EditHistory_Changed;
_editHistory = null;
_template = null;
_objectSpace = null;
_dashboardDesigner.Dashboard.Dispose();
_dashboardDesigner = null;
base.OnClosed(e);
}
public void LoadTemplate(IDashboardDefinition dashboardDefinition, XafApplication application)
{
_template = dashboardDefinition;
dashboardDefinition.GetDashboard(application, RuleMode.DesignTime, null, null, null, () => {});
var dashboardCollectionDataSourceFillService = (IXpandDashboardDataSourceFillService)((XpandDashboardDataProvider)DashboardsModule.DataProvider)
.AttachService(Designer.ServiceContainer, (IDashboardData)dashboardDefinition);
dashboardCollectionDataSourceFillService.FillService.LoadBeforeParameters += (sender, args) =>
args.Handled = new[] { RuleMode.Always, RuleMode.DesignTime }.Contains(dashboardDefinition.EditParameters);
Designer.Dashboard = dashboardDefinition.GetDashboard(application, RuleMode.DesignTime, dashboardCollectionDataSourceFillService, Designer.DataSourceOptions,
dashboard => Designer.DashboardChanged += (sender, args) => Designer.ShowDashboardParametersForm());
_editHistory.Changed += _EditHistory_Changed;
}
static DevExpress.DashboardCommon.Dashboard LoadFromXml(IDashboardDefinition dashboardDefinition) {
var dashboard = new DevExpress.DashboardCommon.Dashboard();
using (var me = new MemoryStream()) {
var sw = new StreamWriter(me);
sw.Write(dashboardDefinition.Xml);
sw.Flush();
me.Seek(0, SeekOrigin.Begin);
dashboard.LoadFromXml(me);
sw.Close();
me.Close();
}
return dashboard;
}
static DevExpress.DashboardCommon.Dashboard LoadFromXml(IDashboardDefinition dashboardDefinition)
{
var dashboard = new DevExpress.DashboardCommon.Dashboard();
using (var me = new MemoryStream()) {
var sw = new StreamWriter(me);
sw.Write(dashboardDefinition.Xml);
sw.Flush();
me.Seek(0, SeekOrigin.Begin);
dashboard.LoadFromXml(me);
sw.Close();
me.Close();
}
return(dashboard);
}
private static void AddNewDataSources(IDashboardDefinition dashboardDefinition, DevExpress.DashboardCommon.Dashboard dashboard)
{
foreach (var typeWrapper in dashboardDefinition.DashboardTypes)
{
var exists = dashboard.DataSources.OfType <DashboardObjectDataSource>()
.Any(source => Equals(source.DataSource, typeWrapper.Type));
if (!exists)
{
var dataSource = new DashboardObjectDataSource {
DataSourceType = typeWrapper.Type,
Name = CaptionHelper.GetClassCaption(typeWrapper.Type.FullName),
ComponentName = typeWrapper.Type.Name
};
dashboard.DataSources.Add(dataSource);
}
}
}
private static void AddNewDataSources(IDashboardDefinition dashboardDefinition, DevExpress.DashboardCommon.Dashboard dashboard)
{
var dashboardTypesCount = dashboardDefinition.DashboardTypes.Count;
if (dashboardTypesCount > 1)
{
throw new UserFriendlyException($"{dashboardDefinition.Name} contains {dashboardTypesCount} dashboard types. Only one dashboard type is supported.");
}
var wrapper = dashboardDefinition.DashboardTypes.First();
var dataSource = new DashboardObjectDataSource {
DataSourceType = wrapper.Type,
Name = nameof(DashboardObjectDataSource),
ComponentName = nameof(DashboardObjectDataSource)
};
dashboard.DataSources.Add(dataSource);
}
private static bool CanApply(IModelDashboardDataSource modelDashboardDataSource, RuleMode ruleMode,
IDashboardDefinition template)
{
if (modelDashboardDataSource.NodeEnabled &&
new[] { RuleMode.Always, ruleMode }.Contains(modelDashboardDataSource.Enabled))
{
if (modelDashboardDataSource is IModelDashboardDataSourceFilter modelDashboardDataSourceFilter)
{
var objectSpace = XPObjectSpace.FindObjectSpaceByObject(template);
var isObjectFitForCriteria = objectSpace.IsObjectFitForCriteria(template,
CriteriaOperator.Parse(modelDashboardDataSourceFilter.DashboardDefinitionCriteria));
return(isObjectFitForCriteria.HasValue && isObjectFitForCriteria.Value);
}
return(true);
}
return(false);
}
public static DevExpress.DashboardCommon.Dashboard ToDashboard(this IDashboardDefinition dashboardDefinition)
{
var dashboard = new DevExpress.DashboardCommon.Dashboard();
if (!string.IsNullOrWhiteSpace(dashboardDefinition.Xml))
{
using (var me = new MemoryStream()){
var sw = new StreamWriter(me);
var xml = dashboardDefinition.Xml;
xml = Regex.Replace(xml,
$"({typeof(ParameterLessProxyCollection).FullName}, {typeof(ParameterLessProxyCollection).Namespace}, Version=)([^,]*)",
"${1}" + XpandAssemblyInfo.Version, RegexOptions.IgnoreCase);
sw.Write(xml);
sw.Flush();
me.Seek(0, SeekOrigin.Begin);
dashboard.LoadFromXml(me);
sw.Close();
me.Close();
}
}
return(dashboard);
}
public static string GetXml(this IDashboardDefinition template, FilterEnabled filterEnabled, IObjectSpace objectSpace)
{
var dashBoard = template.CreateDashBoard(objectSpace, filterEnabled);
using (var memoryStream = new MemoryStream()) {
dashBoard.SaveToXml(memoryStream);
memoryStream.Position = 0;
var document = XDocument.Load(memoryStream);
var dataSourceAdapters = GetDataSources(dashBoard, filterEnabled, template, objectSpace);
foreach (var dataSourceAdapter in dataSourceAdapters)
{
if (document.Root != null)
{
DataSourceAdapter adapter = dataSourceAdapter;
var datasources = document.Root.Descendants("DataSource").Where(element => element.Attribute("Name").Value == adapter.DataSource.Name && !element.Descendants("Filter").Any());
foreach (var datasource in datasources)
{
datasource.Add(new XElement("Filter", dataSourceAdapter.DataSource.Filter));
}
}
}
return(document.ToString());
}
}
public static DevExpress.DashboardCommon.Dashboard CreateDashBoard(this IDashboardDefinition template, IObjectSpace objectSpace, bool filter)
{
var dashboard = new DevExpress.DashboardCommon.Dashboard();
try {
LoadFromXml(template.Xml, dashboard);
foreach (ITypeWrapper typeWrapper in template.DashboardTypes)
{
ITypeWrapper wrapper = typeWrapper;
if (dashboard.DataSources.Contains(ds => ds.Name.Equals(wrapper.Caption)))
{
Type dashBoardObjectType = DashBoardObjectType(template, dashboard, typeWrapper);
if (dashBoardObjectType != null)
{
ITypeWrapper wrapper1 = typeWrapper;
var dataSource = dashboard.DataSources.First(ds => ds.Name.Equals(wrapper1.Caption));
dataSource.Data = GetObjects(objectSpace, dashBoardObjectType);
}
}
else if (!dashboard.DataSources.Contains(ds => ds.Name.Equals(wrapper.Caption)))
{
dashboard.DataSources.Add(new DashboardObjectDataSource(typeWrapper.Caption, GetObjects(objectSpace, typeWrapper.Type)));
}
}
if (filter)
{
Filter(template, dashboard);
}
}
catch (Exception e) {
dashboard.Dispose();
Tracing.Tracer.LogError(e);
}
return(dashboard);
}
public static DashboardDatasourceFilterList CreateDashboardDatasourceFilterList(
this DevExpress.DashboardCommon.Dashboard dashboard, IDashboardDefinition dashboardDefinition,
RuleMode ruleMode, XafApplication application)
{
var objectSpace = application.CreateObjectSpace(typeof(DashboardDatasourceFilter));
var dashboardDatasourceFilterList = new DashboardDatasourceFilterList();
var dataSources = dashboard.GetDataSources(ruleMode, dashboardDefinition, application.Model);
foreach (var item in dataSources.OrderBy(tuple => tuple.ModelDataSource.Index))
{
if (item.ModelDataSource is IModelDashboardDataSourceFilter modelFilter && modelFilter.ShowInPopupView)
{
var filter = objectSpace.CreateObject <DashboardDatasourceFilter>();
filter.ID = item.ModelDataSource.Id();
filter.Filter = modelFilter.Filter;
filter.DataSourceName = item.DataSource.Name;
filter.TopReturnedRecords = modelFilter.TopReturnedRecords;
filter.ShowPersistentMembersOnly = modelFilter.ShowPersistentMembersOnly;
dashboardDatasourceFilterList.Filters.Add(filter);
}
}
return(dashboardDatasourceFilterList);
}
public static IEnumerable <(IDashboardDataSource DataSource, IModelDashboardDataSource ModelDataSource)> GetDataSources(this DevExpress.DashboardCommon.Dashboard dashboard,
RuleMode ruleMode, IDashboardDefinition template, IModelApplication model)
{
var modelDashboardModule =
((IModelDashboardModuleDataSources)((IModelApplicationDashboardModule)model).DashboardModule);
return(modelDashboardModule.DataSources
.Where(source => source.NodeEnabled && CanApply(source, ruleMode, template)).Select(modelDataSource => {
var dataSource = dashboard.DataSources.FirstOrDefault(source =>
Regex.IsMatch(source.Name, modelDataSource.DataSourceName, RegexOptions.IgnoreCase) && Regex.IsMatch(source.GetType().Name, modelDataSource.DatasourceType, RegexOptions.IgnoreCase));
return (DataSource: dataSource, ModelDataSource: modelDataSource);
}).Where(tuple => tuple.DataSource != null && tuple.ModelDataSource != null));
}
public void LoadTemplate(IDashboardDefinition dashboardDefinition)
{
_template = dashboardDefinition;
Designer.Dashboard = _template.CreateDashBoard(FilterEnabled.DesignTime);
_editHistory.Changed += _EditHistory_Changed;
}
public static DevExpress.DashboardCommon.Dashboard LoadFromXml(this IDashboardDefinition dashboardDefinition)
{
throw new NotImplementedException();
}
static Type DashBoardObjectType(IDashboardDefinition template, DevExpress.DashboardCommon.Dashboard dashboard, ITypeWrapper typeWrapper)
{
var wrapper = template.DashboardTypes.FirstOrDefault(type => type.Caption.Equals(dashboard.DataSources.First(ds => ds.Name.Equals(typeWrapper.Caption)).Name));
return wrapper != null ? wrapper.Type : null;
}
public void LoadTemplate(IDashboardDefinition DashboardDefinition) {
_template = DashboardDefinition;
Designer.Dashboard = _template.CreateDashBoard(ObjectSpace, true);
_editHistory.Changed += _EditHistory_Changed;
}
static IEnumerable<DataSourceAdapter> GetDataSources(DevExpress.DashboardCommon.Dashboard dashboard, FilterEnabled filterEnabled, IDashboardDefinition template) {
var modelDashboardModule =
((IModelApplicationDashboardModule)ApplicationHelper.Instance.Application.Model).DashboardModule;
return modelDashboardModule.DataSources.Where(source => source.NodeEnabled && CanApply(source, filterEnabled, template)).Select(modelDataSource => {
var dataSource = dashboard.DataSources.FirstOrDefault(source =>
String.Equals(source.Name.Trim(), modelDataSource.DataSourceName.Trim(), StringComparison.CurrentCultureIgnoreCase));
return new DataSourceAdapter(dataSource, modelDataSource);
}).Where(adapter => adapter.ModelDataSource != null&&adapter.DataSource!=null);
}
public static void SaveDashboard(this DevExpress.DashboardCommon.Dashboard dashboard, IDashboardDefinition template, MemoryStream memoryStream) {
dashboard.SynchronizeModel(template);
dashboard.SaveToXml(memoryStream);
dashboard.ApplyModel(FilterEnabled.Always, template);
}
public void LoadTemplate(IDashboardDefinition dashboardDefinition)
{
_template = dashboardDefinition;
Designer.Dashboard = _template.CreateDashBoard(ObjectSpace, true);
_editHistory.Changed += _EditHistory_Changed;
}
public static void SaveDashboard(this IObjectSpace objectSpace, DevExpress.DashboardCommon.Dashboard dashboard, IDashboardDefinition template, MemoryStream memoryStream)
{
dashboard.SynchronizeModel(objectSpace, template);
dashboard.SaveToXml(memoryStream);
dashboard.ApplyModel(FilterEnabled.Always, template, objectSpace);
}
private static bool CanApply(IModelDashboardDataSource modelDashboardDataSource, FilterEnabled filterEnabled, IDashboardDefinition template, IObjectSpace objectSpace)
{
if (modelDashboardDataSource.NodeEnabled && new[] { FilterEnabled.Always, filterEnabled }.Contains(modelDashboardDataSource.Enabled))
{
var isObjectFitForCriteria = objectSpace.IsObjectFitForCriteria(template, CriteriaOperator.Parse(modelDashboardDataSource.DashboardDefinitionCriteria));
return(isObjectFitForCriteria.HasValue && isObjectFitForCriteria.Value);
}
return(false);
}
static IEnumerable <DataSourceAdapter> GetDataSources(DevExpress.DashboardCommon.Dashboard dashboard, FilterEnabled filterEnabled, IDashboardDefinition template, IObjectSpace objectSpace)
{
var modelDashboardModule =
((IModelApplicationDashboardModule)ApplicationHelper.Instance.Application.Model).DashboardModule;
return(modelDashboardModule.DataSources.Where(source => source.NodeEnabled && CanApply(source, filterEnabled, template, objectSpace)).Select(modelDataSource => {
var dataSource = dashboard.DataSources.FirstOrDefault(source =>
String.Equals(source.Name.Trim(), modelDataSource.DataSourceName.Trim(), StringComparison.CurrentCultureIgnoreCase));
return new DataSourceAdapter(dataSource, modelDataSource);
}).Where(adapter => adapter.ModelDataSource != null));
}
public void LoadTemplate(IDashboardDefinition dashboardDefinition) {
_template = dashboardDefinition;
Designer.Dashboard = _template.CreateDashBoard(ObjectSpace, FilterEnabled.DesignTime);
_editHistory.Changed += _EditHistory_Changed;
}
private static bool CanApply(IModelDashboardDataSource modelDashboardDataSource, FilterEnabled filterEnabled, IDashboardDefinition template) {
if (modelDashboardDataSource.NodeEnabled&&new[]{FilterEnabled.Always,filterEnabled}.Contains(modelDashboardDataSource.Enabled)) {
var objectSpace = XPObjectSpace.FindObjectSpaceByObject(template);
var isObjectFitForCriteria = objectSpace.IsObjectFitForCriteria(template, CriteriaOperator.Parse(modelDashboardDataSource.DashboardDefinitionCriteria));
return isObjectFitForCriteria.HasValue && isObjectFitForCriteria.Value;
}
return false;
}
public static void SynchronizeModel(this DevExpress.DashboardCommon.Dashboard dashboard, IObjectSpace objectSpace, IDashboardDefinition template)
{
var dataSources = GetDataSources(dashboard, FilterEnabled.Always, template, objectSpace);
foreach (var dataSource in dataSources)
{
var filter = dataSource.ModelDataSource as IModelDashboardDataSourceFilter;
if (filter != null)
{
dataSource.DataSource.Filter = filter.SynchronizeFilter(dataSource.DataSource.Filter);
}
}
}
public static void Show(this DashboardViewer dashboardViewer, XafApplication application, IDashboardDefinition dashboardDefinition)
{
var dashboardCollectionDataSourceFillService = (IXpandDashboardDataSourceFillService)((XpandDashboardDataProvider)DashboardsModule.DataProvider)
.AttachViewService(dashboardViewer.ServiceContainer, (IDashboardData)dashboardDefinition);
dashboardCollectionDataSourceFillService.FillService.LoadBeforeParameters += (sender, args) =>
args.Handled = new[] { RuleMode.Always, RuleMode.Runtime }.Contains(dashboardDefinition.EditParameters);
dashboardDefinition.GetDashboard(application, RuleMode.Runtime, dashboardCollectionDataSourceFillService, null, null, () => {});
dashboardViewer.Dashboard = dashboardDefinition.GetDashboard(application, RuleMode.Runtime, dashboardCollectionDataSourceFillService, dashboardViewer.DataSourceOptions,
dashboard => dashboardViewer.DashboardChanged += (_, args) => dashboardViewer.ShowDashboardParametersForm());
}
static Type DashBoardObjectType(IDashboardDefinition template, DevExpress.DashboardCommon.Dashboard dashboard, ITypeWrapper typeWrapper)
{
var wrapper = template.DashboardTypes.FirstOrDefault(type => type.Caption.Equals(dashboard.DataSources.First(ds => ds.Name.Equals(typeWrapper.Caption)).Name));
return(wrapper != null ? wrapper.Type : null);
}
public static void ApplyModel(this DevExpress.DashboardCommon.Dashboard dashboard, FilterEnabled filterEnabled, IDashboardDefinition template) {
var dataSources = GetDataSources(dashboard, filterEnabled, template);
foreach (var adapter in dataSources) {
var filter = adapter.ModelDataSource as IModelDashboardDataSourceFilter;
if (filter != null) adapter.DataSource.Filter = filter.ApplyFilter(adapter.DataSource.Filter);
var parameter = adapter.ModelDataSource as IModelDashboardDataSourceParameter;
if (parameter != null) parameter.ApplyValue(dashboard.Parameters[parameter.ParameterName]);
}
}
public static void ApplyModel(this DevExpress.DashboardCommon.Dashboard dashboard, FilterEnabled filterEnabled, IDashboardDefinition template, IObjectSpace objectSpace)
{
var dataSources = GetDataSources(dashboard, filterEnabled, template, objectSpace);
foreach (var adapter in dataSources)
{
var filter = adapter.ModelDataSource as IModelDashboardDataSourceFilter;
if (filter != null)
{
adapter.DataSource.Filter = filter.ApplyFilter(adapter.DataSource.Filter);
}
var parameter = adapter.ModelDataSource as IModelDashboardDataSourceParameter;
if (parameter != null)
{
parameter.ApplyValue(dashboard.Parameters[parameter.ParameterName]);
}
}
}
