public questStatus RemoveTablesetInfoIFDbChanged(DbMgrTransaction trans, Tableset tableset)
{
// Initialize
questStatus status = null;
// If the database was changed, delete the tablset configuration and any filters based on the tableset
TablesetId tablesetId = new TablesetId(tableset.Id);
Quest.Functional.MasterPricing.Tableset _tableset = null;
status = Read(tablesetId, out _tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
if (tableset.DatabaseId != _tableset.DatabaseId)
{
// Remove all tableset filters
status = RemoveTablesetFilters(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Remove all tableset configuration
status = ClearTablesetEntities(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Warning, "Tableset database was changed. All tableset filters were deleted."));
}
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Create(Quest.Functional.MasterPricing.Tableset tableset, out TablesetId tablesetId)
{
// Initialize
questStatus status = null;
tablesetId = null;
// Data rules.
// Create the tableset
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
status = create(dbContext, tableset, out tablesetId);
if (bLogging)
{
TablesetLog tablesetLog = new TablesetLog();
tablesetLog.Database = "Database.Id=" + tableset.DatabaseId.ToString();
tablesetLog.Name = tableset.Name == null ? "(null)" : tableset.Name;
tablesetLog.Event = "CREATE";
tablesetLog.Data = status.ToString();
TablesetLogId tablesetLogId = null;
_dbTablesetLogsMgr.Create(tablesetLog, out tablesetLogId);
}
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Perform delete.
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
status = delete(dbContext, tablesetId);
if (bLogging)
{
FilterLog filterLog = new FilterLog();
filterLog.Database = "";
filterLog.Tableset = "";
filterLog.Name = "Tableset.Id=" + tablesetId.Id.ToString();
filterLog.Event = "DELETE";
filterLog.Data = status.ToString();
FilterLogId filterLogId = null;
_dbFilterLogsMgr.Create(filterLog, out filterLogId);
}
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
return(new questStatus(Severity.Success));
}
public questStatus Read(TablesetId tablesetId, out TablesetEditorViewModel tablesetEditorViewModel)
{
// Initialize
questStatus status = null;
tablesetEditorViewModel = null;
// Read
Quest.Functional.MasterPricing.Tableset tableset = null;
TablesetsMgr tablesetsMgr = new TablesetsMgr(this.UserSession);
status = tablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer model.
tablesetEditorViewModel = new TablesetEditorViewModel(this.UserSession);
BufferMgr.TransferBuffer(tableset, tablesetEditorViewModel);
return(new questStatus(Severity.Success));
}
public questStatus Read(TablesetId tablesetId, out List <Quest.Functional.MasterPricing.TablesetTable> tablesetTableList)
{
// Initialize
questStatus status = null;
tablesetTableList = null;
// Perform read
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
List <Quest.Services.Dbio.MasterPricing.TablesetTables> _tablesetTableList = null;
status = read(dbContext, tablesetId, out _tablesetTableList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetTableList = new List <TablesetTable>();
foreach (Quest.Services.Dbio.MasterPricing.TablesetTables _tablesetTable in _tablesetTableList)
{
Quest.Functional.MasterPricing.TablesetTable tablesetTable = new Quest.Functional.MasterPricing.TablesetTable();
BufferMgr.TransferBuffer(_tablesetTable, tablesetTable);
tablesetTableList.Add(tablesetTable);
}
}
return(new questStatus(Severity.Success));
}
public questStatus ClearTablesetEntities(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
DbMgrTransaction trans = null;
// BEGIN TRANSACTION
status = BeginTransaction("SaveTablesetConfiguration" + Guid.NewGuid().ToString(), out trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
status = ClearTablesetEntities(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
// COMMIT TRANSACTION
status = CommitTransaction(trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Perform delete in this transaction.
status = delete((MasterPricingEntities)trans.DbContext, tablesetId);
if (bLogging)
{
FilterLog filterLog = new FilterLog();
filterLog.Database = "";
filterLog.Tableset = "";
filterLog.Name = "TablesetId.Id=" + tablesetId.Id.ToString();
filterLog.Event = "DELETE";
filterLog.Data = status.ToString();
FilterLogId filterLogId = null;
_dbFilterLogsMgr.Create(filterLog, out filterLogId);
}
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
return(new questStatus(Severity.Success));
}
private questStatus read(MasterPricingEntities dbContext, TablesetId tablesetId, out Quest.Services.Dbio.MasterPricing.Tablesets tableset)
{
// Initialize
questStatus status = null;
tableset = null;
try
{
tableset = dbContext.Tablesets.Where(r => r.Id == tablesetId.Id).SingleOrDefault();
if (tableset == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
String.Format("Id {0} not found", tablesetId.Id))));
}
}
catch (System.Exception ex)
{
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message));
LogException(ex, status);
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, TablesetId tablesetId, out List <Quest.Functional.MasterPricing.Filter> filterList)
{
// Initialize
questStatus status = null;
filterList = null;
// Perform read
List <Quest.Services.Dbio.MasterPricing.Filters> _filtersList = null;
status = read((MasterPricingEntities)trans.DbContext, tablesetId, out _filtersList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
filterList = new List <Filter>();
foreach (Quest.Services.Dbio.MasterPricing.Filters _filter in _filtersList)
{
Quest.Functional.MasterPricing.Filter filter = new Quest.Functional.MasterPricing.Filter();
BufferMgr.TransferBuffer(_filter, filter);
filterList.Add(filter);
}
return(new questStatus(Severity.Success));
}
public ActionResult Entities(DataMgrTablesetViewModel viewModel)
{
questStatus status = null;
DataMgrTablesetViewModel dataMgrTablesetViewModel = null;
UserMessageModeler userMessageModeler = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Redirect to Tablesets if no tablesetId specified.
*---------------------------------------------------------------------------------------------------------------------------------*/
if (viewModel.Id < BaseId.VALID_ID)
{
status = new questStatus(Severity.Error, "Invalid Id value. Must be 1 or greater.");
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset data management info.
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(viewModel.Id);
TablesetDataModeler tablesetDataModeler = new TablesetDataModeler(this.Request, this.UserSession, viewModel);
status = tablesetDataModeler.Read(tablesetId, out dataMgrTablesetViewModel);
if (!questStatusDef.IsSuccess(status))
{
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, viewModel);
dataMgrTablesetViewModel.questStatus = status;
return(View(dataMgrTablesetViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
dataMgrTablesetViewModel.questStatus = status;
return(Json(dataMgrTablesetViewModel, JsonRequestBehavior.AllowGet));
}
public questStatus Delete(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
DbMgrTransaction trans = null;
// BEGIN TRANSACTION
status = BeginTransaction("DeleteTableset_" + Guid.NewGuid().ToString(), out trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
try
{
// Delete tableset filters
FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
status = filtersMgr.Delete(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
// Delete Tableset
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this.UserSession);
status = dbTablesetsMgr.Delete(tablesetId);
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
// COMMIT TRANSACTION
status = CommitTransaction(trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
catch (System.Exception ex)
{
if (trans != null)
{
RollbackTransaction(trans);
}
return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message)));
}
return(new questStatus(Severity.Success));
}
public questStatus ReadTablesetConfiguration(TablesetId tablesetId, out TablesetConfiguration tablesetConfiguration)
{
// Initialize
questStatus status = null;
tablesetConfiguration = null;
// Read tableset configuration
status = _dbTablesetMgr.ReadTablesetConfiguration(tablesetId, out tablesetConfiguration);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read database entities
DatabaseId databaseId = new DatabaseId(tablesetConfiguration.Database.Id);
DatabaseEntities databaseEntities = null;
DatabaseMgr databaseMgr = new DatabaseMgr(this.UserSession);
status = databaseMgr.ReadDatabaseEntities(databaseId, out databaseEntities);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Sort out what's assigned and not assigned to the tableset.
List <Table> nonAssignedTableList = new List <Table>();
List <View> nonAssignedViewList = new List <View>();
foreach (Table table in databaseEntities.TableList)
{
TablesetTable tablesetTable = tablesetConfiguration.TablesetTables.Find(delegate(TablesetTable ts) { return(ts.Schema == table.Schema && ts.Name == table.Name); });
if (tablesetTable == null)
{
nonAssignedTableList.Add(table);
}
}
tablesetConfiguration.DBTableList = nonAssignedTableList;
// Load database views and columns into configuration NOT assigned to tableset.
foreach (View view in databaseEntities.ViewList)
{
TablesetView tablesetView = tablesetConfiguration.TablesetViews.Find(delegate(TablesetView tv) { return(tv.Schema == view.Schema && tv.Name == view.Name); });
if (tablesetView == null)
{
nonAssignedViewList.Add(view);
}
}
tablesetConfiguration.DBViewList = nonAssignedViewList;
return(new questStatus(Severity.Success));
}
public questStatus PerformBulkInsert(BulkInsertRequest bulkInsertRequest)
{
// Initialize
questStatus status = null;
// Execute bulk insert SQL
try
{
// Get tableset
TablesetId tablesetId = new TablesetId(bulkInsertRequest.Filter.TablesetId);
Tableset tableset = null;
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this.UserSession);
status = dbTablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccessOrWarning(status))
{
return(status);
}
// Get database
DatabaseId databaseId = new DatabaseId(tableset.DatabaseId);
Quest.Functional.MasterPricing.Database database = null;
DbDatabasesMgr dbDatabasesMgr = new DbDatabasesMgr(this.UserSession);
status = dbDatabasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccessOrWarning(status))
{
return(status);
}
// Execute sql
using (SqlConnection sqlConnection = new SqlConnection(database.ConnectionString))
{
sqlConnection.Open();
using (SqlCommand cmd = sqlConnection.CreateCommand())
{
cmd.CommandText = bulkInsertRequest.SQL;
cmd.CommandType = CommandType.Text;
int numRows = cmd.ExecuteNonQuery();
if (numRows != bulkInsertRequest.Rows.Count)
{
return(new questStatus(Severity.Error, String.Format("ERROR: Bulk insert SQL execution failed: Rows: {0}", numRows)));
}
}
}
}
catch (System.Exception ex)
{
return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: executing bulk insert SQL {0} SQL: {1}",
bulkInsertRequest.SQL, ex.Message)));
}
return(new questStatus(Severity.Success));
}
public ActionResult Index(DataMgrTablesetViewModel viewModel)
{
questStatus status = null;
DataMgrTablesetViewModel dataMgrTablesetViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, viewModel);
dataMgrTablesetViewModel.questStatus = status;
return(View(dataMgrTablesetViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, viewModel);
dataMgrTablesetViewModel.questStatus = status;
return(View(dataMgrTablesetViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Redirect to Tablesets if no tablesetId specified.
*---------------------------------------------------------------------------------------------------------------------------------*/
if (viewModel.Id < BaseId.VALID_ID)
{
return(RedirectToAction("Index", "DataMgr", PropagateQueryString(Request)));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset data management info.
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(viewModel.Id);
TablesetDataModeler tablesetDataModeler = new TablesetDataModeler(this.Request, this.UserSession, viewModel);
status = tablesetDataModeler.Read(tablesetId, out dataMgrTablesetViewModel);
if (!questStatusDef.IsSuccess(status))
{
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, viewModel);
dataMgrTablesetViewModel.questStatus = status;
return(View(dataMgrTablesetViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
return(View(dataMgrTablesetViewModel));
}
public questStatus List(TablesetId tablesetId, out FilterTableTreeviewViewModel filterTableTreeviewViewModel)
{
// Initialize
filterTableTreeviewViewModel = new FilterTableTreeviewViewModel(this.UserSession, this._dataMgrBaseViewModel);
filterTableTreeviewViewModel.TablesetId = tablesetId.Id;
// TODO
return(new questStatus(Severity.Success));
}
private questStatus delete(MasterPricingEntities dbContext, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
try
{
// Read the record.
Quest.Services.Dbio.MasterPricing.Tablesets _tableset = null;
status = read(dbContext, tablesetId, out _tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Delete the record.
dbContext.Tablesets.Remove(_tableset);
dbContext.SaveChanges();
}
catch (DbEntityValidationException ex)
{
var errorMessages = ex.EntityValidationErrors.SelectMany(x => x.ValidationErrors).Select(x => x.ErrorMessage);
String fullErrorMessage = string.Join("; ", errorMessages);
String exceptionMessage = string.Concat(ex.Message, fullErrorMessage);
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
exceptionMessage));
LogException(ex, status);
return(status);
}
catch (System.Exception ex)
{
status = new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message));
LogException(ex, status);
return(status);
}
status = new questStatus(Severity.Success, "Tableset successfully deleted. TablesetId.Id=" + tablesetId.Id);
if (bLogging)
{
TablesetLog tablesetLog = new TablesetLog();
tablesetLog.Name = "TablesetId.Id=" + tablesetId.Id;
tablesetLog.Event = "DELETE";
tablesetLog.Data = status.ToString();
TablesetLogId tablesetLogId = null;
_dbTablesetLogsMgr.Create(tablesetLog, out tablesetLogId);
}
return(status);
}
public ActionResult Filters(TablesetEditorViewModel viewModel)
{
questStatus status = null;
TablesetsListViewModel tablesetsListViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset data management info.
*---------------------------------------------------------------------------------------------------------------------------------*/
DataMgrBaseViewModel dataMgrBaseViewModel = new DataMgrBaseViewModel(this.UserSession);
BufferMgr.TransferBuffer(viewModel, dataMgrBaseViewModel);
TablesetId tablesetId = new TablesetId(viewModel.Id);
DataMgrTablesetViewModel dataMgrTablesetViewModel = null;
TablesetDataModeler tablesetDataModeler = new TablesetDataModeler(this.Request, this.UserSession, dataMgrBaseViewModel);
status = tablesetDataModeler.Read(tablesetId, out dataMgrTablesetViewModel);
if (!questStatusDef.IsSuccess(status))
{
dataMgrTablesetViewModel = new DataMgrTablesetViewModel(this.UserSession, viewModel);
dataMgrTablesetViewModel.questStatus = status;
return(View(dataMgrTablesetViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
return(View("~/Areas/DataMgr/Views/Tableset/Index.cshtml", dataMgrTablesetViewModel));
}
public ActionResult Database(TablesetEditorViewModel viewModel)
{
questStatus status = null;
TablesetsListViewModel tablesetsListViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset for the database Id
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(viewModel.Id);
TablesetEditorViewModel tablesetEditorViewModel = null;
TablesetEditorModeler tablesetEditorModeler = new TablesetEditorModeler(this.Request, this.UserSession);
status = tablesetEditorModeler.Read(tablesetId, out tablesetEditorViewModel);
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
DatabaseEditorViewModel databaseEditorViewModel = new DatabaseEditorViewModel(this.UserSession, viewModel);
databaseEditorViewModel.Id = tablesetEditorViewModel.DatabaseId;
databaseEditorViewModel.questStatus = new questStatus(Severity.Warning);
return(View("~/Areas/Setup/Views/Database/Index.cshtml", databaseEditorViewModel));
}
public questStatus ClearTablesetEntities(DbMgrTransaction trans, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this.UserSession);
status = dbTablesetsMgr.ClearTablesetEntities(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Delete all filters in this table.
status = _dbFiltersMgr.Delete(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Delete tableset
status = _dbTablesetsMgr.Delete(tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public ActionResult Index(TablesetEditorViewModel editorViewModel)
{
questStatus status = null;
TablesetConfigurationViewModel tablesetConfigurationViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, editorViewModel);
tablesetConfigurationViewModel.questStatus = status;
return(View(tablesetConfigurationViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(editorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, editorViewModel);
tablesetConfigurationViewModel.questStatus = status;
return(View(tablesetConfigurationViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset configuration.
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(editorViewModel.Id);
TablesetConfigurationModeler tablesetConfigurationModeler = new TablesetConfigurationModeler(this.Request, this.UserSession, editorViewModel);
status = tablesetConfigurationModeler.Read(tablesetId, out tablesetConfigurationViewModel);
if (!questStatusDef.IsSuccess(status))
{
if (tablesetConfigurationViewModel == null)
{
tablesetConfigurationViewModel = new TablesetConfigurationViewModel(this.UserSession, editorViewModel);
}
tablesetConfigurationViewModel.questStatus = status;
return(View(tablesetConfigurationViewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
return(View(tablesetConfigurationViewModel));
}
public questStatus Delete(DbMgrTransaction trans, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
// Perform delete in this transaction.
status = delete((MasterPricingEntities)trans.DbContext, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
return(new questStatus(Severity.Success));
}
private questStatus delete(MasterPricingEntities dbContext, TablesetId tablesetId)
{
try
{
dbContext.Filters.RemoveRange(dbContext.Filters.Where(r => r.TablesetId == tablesetId.Id));
dbContext.SaveChanges();
}
catch (System.Exception ex)
{
return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
ex.InnerException != null ? ex.InnerException.Message : ex.Message)));
}
return(new questStatus(Severity.Success));
}
public questStatus Read(TablesetId tablesetId, out Tableset tableset)
{
// Initialize
tableset = null;
questStatus status = null;
// Read tableset
status = _dbTablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus RemoveTablesetFilters(DbMgrTransaction trans, TablesetId tablesetId)
{
// Initialize
questStatus status = null;
DbFilterMgr dbFilterMgr = new DbFilterMgr(this.UserSession);
status = dbFilterMgr.Delete(trans, tablesetId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, TablesetId tablesetId, out List <Quest.Functional.MasterPricing.Filter> filterList)
{
// Initialize
questStatus status = null;
filterList = null;
// Read filter
status = _dbFiltersMgr.Read(trans, tablesetId, out filterList);
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 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 ActionResult Configuration(TablesetEditorViewModel viewModel)
{
questStatus status = null;
TablesetsListViewModel tablesetsListViewModel = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Read tableset configuration.
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetConfigurationViewModel tablesetConfigurationViewModel = null;
TablesetId tablesetId = new TablesetId(viewModel.Id);
TablesetConfigurationModeler tablesetConfigurationModeler = new TablesetConfigurationModeler(this.Request, this.UserSession, viewModel);
status = tablesetConfigurationModeler.Read(tablesetId, out tablesetConfigurationViewModel);
if (!questStatusDef.IsSuccess(status))
{
tablesetsListViewModel = new TablesetsListViewModel(this.UserSession, viewModel);
tablesetsListViewModel.questStatus = status;
return(View("Index", viewModel));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view.
*---------------------------------------------------------------------------------------------------------------------------------*/
return(View("~/Areas/Setup/Views/TablesetConfiguration/Index.cshtml", tablesetConfigurationViewModel));
}
