/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus List(UserId userId, out TablesetListViewModel tablesetListViewModel)
{
// Initialize
questStatus status = null;
tablesetListViewModel = null;
// Set up query options.
// TEMPORARY: OPTIMIZE THIS
List <SearchField> searchFieldList = new List <SearchField>();
SearchField searchField = new SearchField();
searchField.Name = "bEnabled";
searchField.SearchOperation = SearchOperation.Equal;
searchField.Type = typeof(bool);
searchField.Value = "1".ToString();
searchFieldList.Add(searchField);
SearchOptions searchOptions = new SearchOptions();
searchOptions.SearchFieldList = searchFieldList;
QueryOptions queryOptions = new QueryOptions(100, 1);
queryOptions.SearchOptions = searchOptions;
QueryResponse queryResponse = null;
// Get DataMgr tablesets
List <Tableset> tablesetList = null;
TablesetMgr tablesetMgr = new TablesetMgr();
status = tablesetMgr.List(queryOptions, out tablesetList, out queryResponse);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Sort by name
tablesetList.Sort(delegate(Tableset i1, Tableset i2) { return(i1.Name.CompareTo(i2.Name)); });
// Build model
tablesetListViewModel = new TablesetListViewModel(this.UserSession);
foreach (Tableset tableset in tablesetList)
{
TablesetLineItemViewModel tablesetLineItemViewModel = new TablesetLineItemViewModel();
BufferMgr.TransferBuffer(tableset, tablesetLineItemViewModel);
tablesetListViewModel.Items.Add(tablesetLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Delete the tableset configuration
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.ClearTablesetEntities(tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Delete
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.Delete(tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(TablesetId tablesetId, out TablesetConfigurationViewModel tablesetConfigurationViewModel)
{
// Initialize
questStatus status = null;
tablesetConfigurationViewModel = null;
// If no tablesetId, return empty view model
if (tablesetId.Id < BaseId.VALID_ID)
{
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, this._setupBaseViewModel);
return(new questStatus(Severity.Success));
}
// Read
TablesetConfiguration tablesetConfiguration = null;
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.ReadTablesetConfiguration(tablesetId, out tablesetConfiguration);
if (!questStatusDef.IsSuccess(status))
{
// Return what we can of the configuration, but with the error status.
if (tablesetConfiguration != null)
{
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, this._setupBaseViewModel);
BufferMgr.TransferBuffer(tablesetConfiguration, tablesetConfigurationViewModel, true);
if (this._tablesetEditorViewModel != null)
{
tablesetConfigurationViewModel.Id = this._tablesetEditorViewModel.Id;
tablesetConfigurationViewModel.TablesetId = this._tablesetEditorViewModel.Id;
}
else if (this._tablesetConfigurationViewModel != null)
{
tablesetConfigurationViewModel.Id = this._tablesetConfigurationViewModel.Id;
tablesetConfigurationViewModel.TablesetId = this._tablesetConfigurationViewModel.Id;
}
}
if (status.Message.Contains("DbDatabasesMgr") && (status.Message.Contains("not found")))
{
status = new questStatus(Severity.Error, "Database not found for this table set.");
}
return(status);
}
// Transfer model.
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, this._setupBaseViewModel);
BufferMgr.TransferBuffer(tablesetConfiguration, tablesetConfigurationViewModel, true);
tablesetConfigurationViewModel.Id = tablesetConfiguration.Tableset.Id;
tablesetConfigurationViewModel.TablesetId = tablesetConfiguration.Tableset.Id;
// Tables
foreach (TablesetTable tablesetTable in tablesetConfiguration.TablesetTables)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(tablesetTable.Table, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetConfigurationViewModel.TableList.Add(bootstrapTreenodeViewModel);
}
foreach (Table dbTable in tablesetConfiguration.DBTableList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(dbTable, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetConfigurationViewModel.DBTableList.Add(bootstrapTreenodeViewModel);
}
// Views
foreach (TablesetView tablesetView in tablesetConfiguration.TablesetViews)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(tablesetView.View, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetConfigurationViewModel.ViewList.Add(bootstrapTreenodeViewModel);
}
foreach (View dbView in tablesetConfiguration.DBViewList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(dbView, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetConfigurationViewModel.DBViewList.Add(bootstrapTreenodeViewModel);
}
return(new questStatus(Severity.Success));
}
public questStatus Save(TablesetConfigurationViewModel tablesetConfigurationViewModel)
{
// Initialize
questStatus status = null;
TablesetId tablesetId = null;
// Validate: must have a valid TablesetId
if (tablesetConfigurationViewModel.Tableset.Id < BaseId.VALID_ID)
{
return(new questStatus(Severity.Error, "Invalid Tableset identity"));
}
tablesetId = new TablesetId(tablesetConfigurationViewModel.Tableset.Id);
Tableset tableset = null;
TablesetsMgr tablesetsMgr = new TablesetsMgr(this.UserSession);
status = tablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccess(status))
{
return(new questStatus(Severity.Error, String.Format("Tableset identity not found: {0}", tablesetId.Id)));
}
// Transfer model
if (tablesetConfigurationViewModel.TableList == null)
{
tablesetConfigurationViewModel.TableList = new List <BootstrapTreenodeViewModel>();
}
TablesetConfiguration tablesetConfiguration = new TablesetConfiguration();
BufferMgr.TransferBuffer(tablesetConfigurationViewModel, tablesetConfiguration, true);
foreach (BootstrapTreenodeViewModel _table in tablesetConfigurationViewModel.TableList)
{
TablesetTable tablesetTable = new TablesetTable();
string[] parts = _table.text.Split(new[] { '[', '.', ']' }, StringSplitOptions.RemoveEmptyEntries);
tablesetTable.Schema = parts[0];
tablesetTable.Name = parts[1];
tablesetConfiguration.TablesetTables.Add(tablesetTable);
}
foreach (BootstrapTreenodeViewModel _view in tablesetConfigurationViewModel.ViewList)
{
TablesetView tablesetView = new TablesetView();
string[] parts = _view.text.Split(new[] { '[', '.', ']' }, StringSplitOptions.RemoveEmptyEntries);
tablesetView.Schema = parts[0];
tablesetView.Name = parts[1];
tablesetConfiguration.TablesetViews.Add(tablesetView);
}
// Save
tablesetId = null;
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.SaveTablesetConfiguration(tablesetConfiguration, out tablesetId);
if (!questStatusDef.IsSuccess(status))
{
FormatErrorMessage(status, tablesetConfigurationViewModel);
return(status);
}
tablesetConfigurationViewModel.Tableset.Id = tablesetId.Id;
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Read(TablesetId tablesetId, out DataMgrTablesetViewModel dataMgrTablesetViewModel)
{
// Initialize
questStatus status = null;
dataMgrTablesetViewModel = null;
// Read tableset data management.
TablesetDataManagement tablesetDataManagement = null;
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.ReadTablesetDataManagement(tablesetId, out tablesetDataManagement);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// List lookups
DatabaseId databaseId = new DatabaseId(tablesetDataManagement.TablesetConfiguration.Database.Id);
List <BootstrapTreenodeViewModel> lookupNodeList = null;
status = ListLookups(databaseId, out lookupNodeList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// List TypeLists
List <BootstrapTreenodeViewModel> typeListNodeList = null;
status = ListTypeLists(databaseId, out typeListNodeList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Load all folders
FolderId folderId = null;
List <FilterFolder> filterFolderList = null;
FilterFoldersMgr filterFoldersMgr = new FilterFoldersMgr(this.UserSession);
status = filterFoldersMgr.Load(folderId, out filterFolderList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Build model
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, this._dataMgrBaseViewModel);
dataMgrTablesetViewModel.TablesetId = tablesetId.Id;
BufferMgr.TransferBuffer(tablesetDataManagement.TablesetConfiguration.Tableset, dataMgrTablesetViewModel.Tableset);
if (dataMgrTablesetViewModel.Tableset.Summary == null)
{
dataMgrTablesetViewModel.Tableset.Summary = "";
}
dataMgrTablesetViewModel.Tableset.LastRefresh = "";
dataMgrTablesetViewModel.Tableset.LastRefresh = tablesetDataManagement.TablesetConfiguration.Tableset.LastRefresh.HasValue ?
tablesetDataManagement.TablesetConfiguration.Tableset.LastRefresh.Value.ToString("MM/dd/yyyy HH:mm:ss") : "";
foreach (TablesetTable tablesetTable in tablesetDataManagement.TablesetConfiguration.TablesetTables)
{
tablesetTable.bColumnsSelectable = false;
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(tablesetTable, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
dataMgrTablesetViewModel.TableList.Add(bootstrapTreenodeViewModel);
}
foreach (TablesetView tablesetView in tablesetDataManagement.TablesetConfiguration.TablesetViews)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(tablesetView, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
dataMgrTablesetViewModel.ViewList.Add(bootstrapTreenodeViewModel);
}
dataMgrTablesetViewModel.Lookups = lookupNodeList;
dataMgrTablesetViewModel.TypeLists = typeListNodeList;
foreach (FilterFolder filterFolder in filterFolderList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(filterFolder, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
dataMgrTablesetViewModel.Folders.Add(bootstrapTreenodeViewModel);
}
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Save(FilterPanelViewModel filterPanelViewModel)
{
// Initialize
questStatus status = null;
Quest.Functional.MasterPricing.Filter filter = null;
FilterId filterId = null;
// Validate
if (filterPanelViewModel.Editor.TablesetId < BaseId.VALID_ID)
{
return(new questStatus(Severity.Error, "Invalid Tableset Id"));
}
if (filterPanelViewModel.Editor.FilterId < BaseId.VALID_ID)
{
// For headless agents that want to save all-in-one, not via the Filters panel.
filter = new Functional.MasterPricing.Filter();
BufferMgr.TransferBuffer(filterPanelViewModel.Editor, filter);
filterId = null;
FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
status = filtersMgr.Create(filter, out filterId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
filterPanelViewModel.Editor.Id = filterId.Id;
filterPanelViewModel.Editor.FilterId = filterId.Id;
}
// Read tableset configuration
TablesetId tablesetId = new TablesetId(filterPanelViewModel.Editor.TablesetId);
TablesetDataManagement tablesetDataManagement = null;
TablesetMgr tablesetMgr = new TablesetMgr(this.UserSession);
status = tablesetMgr.ReadTablesetDataManagement(tablesetId, out tablesetDataManagement);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
#region Transfer filter entities
//
// Transfer filter entities
//
filter = new Functional.MasterPricing.Filter();
filter.TablesetId = filterPanelViewModel.Editor.TablesetId;
filter.Id = filterPanelViewModel.Editor.Id;
foreach (BootstrapTreenodeViewModel filterEntity in filterPanelViewModel.Entities)
{
if (filterEntity.type == "table")
{
FilterTable filterTable = new FilterTable();
filterTable.FilterId = filterPanelViewModel.Editor.Id;
filterTable.Schema = filterEntity.Schema;
filterTable.Name = filterEntity.Name;
filter.FilterTableList.Add(filterTable);
}
else if (filterEntity.type == "view")
{
FilterView filterView = new FilterView();
filterView.FilterId = filterPanelViewModel.Editor.Id;
filterView.Schema = filterEntity.Schema;
filterView.Name = filterEntity.Name;
filter.FilterViewList.Add(filterView);
}
else if (filterEntity.type == "column")
{
FilterColumn filterColumn = new FilterColumn();
filterColumn.FilterId = filterPanelViewModel.Editor.Id;
filterColumn.Name = filterEntity.Name;
filterColumn.TablesetEntityId = filterEntity.ParentId;
if (filterEntity.parentType == "table")
{
TablesetTable parentTablesetTable = tablesetDataManagement.TablesetConfiguration.TablesetTables.Find(delegate(TablesetTable tt) { return(tt.Id == filterEntity.ParentId); });
if (parentTablesetTable == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: column filter entity \"{0}\" (Id {1}) table parent Id {2} not found.",
filterEntity.text, filterEntity.Id, filterEntity.ParentId)));
}
filterColumn.FilterEntityTypeId = FilterEntityType.Table;
// If column table not in filter entities, add it.
BootstrapTreenodeViewModel filterColumnTable = filterPanelViewModel.Entities.Find(delegate(BootstrapTreenodeViewModel n) { return(n.type == "table" && n.Id == filterEntity.ParentId); });
if (filterColumnTable == null)
{
FilterTable filterTable = filter.FilterTableList.Find(delegate(FilterTable t) { return(filterEntity.ParentId == t.TablesetTable.Id); });
if (filterTable == null)
{
filterTable = new FilterTable();
filterTable.FilterId = filterPanelViewModel.Editor.Id;
filterTable.TablesetTable = parentTablesetTable;
filterTable.Schema = parentTablesetTable.Schema;
filterTable.Name = parentTablesetTable.Name;
filter.FilterTableList.Add(filterTable);
}
}
}
else if (filterEntity.parentType == "view")
{
TablesetView parentTablesetView = tablesetDataManagement.TablesetConfiguration.TablesetViews.Find(delegate(TablesetView tv) { return(tv.Id == filterEntity.ParentId); });
if (parentTablesetView == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: column filter entity \"{0}\" (Id {1}) view parent Id {2} not found.",
filterEntity.text, filterEntity.Id, filterEntity.ParentId)));
}
filterColumn.FilterEntityTypeId = FilterEntityType.View;
// If column view not in filter entities, add it.
BootstrapTreenodeViewModel filterColumnView = filterPanelViewModel.Entities.Find(delegate(BootstrapTreenodeViewModel n) { return(n.type == "view" && n.Id == filterEntity.ParentId); });
if (filterColumnView == null)
{
FilterView filterView = filter.FilterViewList.Find(delegate(FilterView v) { return(filterEntity.ParentId == v.TablesetView.Id); });
if (filterView == null)
{
filterView = new FilterView();
filterView.FilterId = filterPanelViewModel.Editor.Id;
filterView.TablesetView = parentTablesetView;
filterView.Schema = parentTablesetView.Schema;
filterView.Name = parentTablesetView.Name;
filter.FilterViewList.Add(filterView);
}
}
}
else
{
return(new questStatus(Severity.Error, String.Format("ERROR: column filter entity \"{0}\" (Id {1}) unknown parent parent type: {2}",
filterEntity.text, filterEntity.Id, filterEntity.ParentId, (filterEntity.parentType == null ? "null" : filterEntity.parentType))));
}
filter.FilterColumnList.Add(filterColumn);
}
else
{
return(new questStatus(Severity.Error, String.Format("Invalid filter entity type: {0}", filterEntity.type)));
}
}
#endregion
#region Transfer filter items
//
// Transfer filter items
//
foreach (FilterItemViewModel filterItemViewModel in filterPanelViewModel.Items)
{
// Filter Item
FilterItem filterItem = new FilterItem();
filterItem.FilterId = filterPanelViewModel.Editor.FilterId;
if (filterItemViewModel.Entity.type == "table")
{
filterItem.FilterEntityTypeId = FilterEntityType.Table;
}
if (filterItemViewModel.Entity.type == "view")
{
filterItem.FilterEntityTypeId = FilterEntityType.View;
}
else if (filterItemViewModel.Entity.type == "column")
{
filterItem.FilterEntityTypeId = FilterEntityType.Column;
}
filterItem.TablesetColumnId = filterItemViewModel.Entity.Id;
filterItem.Label = filterItemViewModel.Label;
filterItem.ParameterName = filterItemViewModel.ParameterName;
filterItem.bHidden = filterItemViewModel.bHidden;
filterItem.bBulkUpdateValueRequired = filterItemViewModel.bBulkUpdateValueRequired;
// Joins
foreach (FilterItemJoinViewModel filterItemJoinViewModel in filterItemViewModel.Joins)
{
FilterItemJoin filterItemJoin = new FilterItemJoin();
filterItemJoin.ColumnId = filterItemJoinViewModel.ColumnId;
filterItemJoin.JoinType = filterItemJoinViewModel.JoinType;
filterItemJoin.Identifier = filterItemJoinViewModel.Identifier;
filterItem.JoinList.Add(filterItemJoin);
}
// Operations
foreach (FilterOperationViewModel filterOperationViewModel in filterItemViewModel.Operations)
{
FilterOperation filterOperation = new FilterOperation();
filterOperation.FilterOperatorId = filterOperationViewModel.Operator;
// Values
foreach (FilterValueViewModel filterValueViewModel in filterOperationViewModel.Values)
{
FilterValue filterValue = new FilterValue();
filterValue.Value = filterValueViewModel.Value;
filterOperation.ValueList.Add(filterValue);
}
filterItem.OperationList.Add(filterOperation);
}
// Lookup
if (filterItemViewModel.Lookup.Id >= BaseId.VALID_ID)
{
filterItem.LookupId = filterItemViewModel.Lookup.Id;
}
// TypeList
if (filterItemViewModel.TypeList.Id >= BaseId.VALID_ID)
{
filterItem.TypeListId = filterItemViewModel.TypeList.Id;
}
filter.FilterItemList.Add(filterItem);
}
#endregion
#region Transfer filter procedures
//
// Transfer filter procedures
//
foreach (FilterProcedureViewModel filterProcedureViewModel in filterPanelViewModel.Procedures)
{
if (filterProcedureViewModel.Id > BaseId.INVALID_ID)
{
FilterProcedure filterProcedure = new FilterProcedure();
BufferMgr.TransferBuffer(filterProcedureViewModel, filterProcedure);
filterProcedure.FilterId = filterPanelViewModel.Editor.FilterId;
filter.FilterProcedureList.Add(filterProcedure);
}
}
#endregion
#region Save filter
//
// Save filter
//
filterId = new FilterId(filterPanelViewModel.Editor.FilterId);
FilterMgr filterMgr = new FilterMgr(this.UserSession);
status = filterMgr.Save(filterId, filter);
if (!questStatusDef.IsSuccess(status))
{
if (questStatusDef.IsWarning(status))
{
return(status);
}
return(new questStatus(status.Severity, String.Format("Error saving filter items: {0}", status.Message)));
}
#endregion
#region Return procedure parameters
//
// Return procedure parameters
//
// Get filter database
Quest.Functional.MasterPricing.Database database = null;
filterMgr.GetFilterDatabase(filterId, out database);
if (filter.FilterProcedureList.Count > 0)
{
foreach (FilterProcedureViewModel filterProcedureViewModel in filterPanelViewModel.Procedures)
{
if ((filterProcedureViewModel.Id == BaseId.INVALID_ID) || (string.IsNullOrEmpty(filterProcedureViewModel.Name)))
{
continue;
}
// Get procedure parameters
List <Quest.Functional.MasterPricing.FilterProcedureParameter> filterProcedureParameterList = null;
status = filterMgr.GetStoredProdecureParameters(database, filterProcedureViewModel.Name, out filterProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
foreach (FilterProcedureParameter filterProcedureParameter in filterProcedureParameterList)
{
FilterProcedureParameterViewModel filterProcedureParameterViewModel = new FilterProcedureParameterViewModel();
BufferMgr.TransferBuffer(filterProcedureParameter, filterProcedureParameterViewModel, true);
filterProcedureParameterViewModel.Precision = filterProcedureParameter.Precision[0];
filterProcedureParameterViewModel.Scale = filterProcedureParameter.Scale[0];
filterProcedureViewModel.Parameters.Add(filterProcedureParameterViewModel);
}
}
}
#endregion
// Return warning if no items in filter.
if (filter.FilterItemList.Count == 0)
{
return(new questStatus(Severity.Warning, "Filter successfully saved, but has no items"));
}
return(new questStatus(Severity.Success));
}
