public questStatus List(ParameterListViewModel viewModel, out ParameterListViewModel parameterListViewModel)
{
// Initialize
questStatus status = null;
parameterListViewModel = null;
// Get stored procedure parameters
StoredProcedureId storedProcedureId = new StoredProcedureId(viewModel.StoredProcedureId);
List <StoredProcedureParameter> storedProcedureParameterList = null;
StoredProcedureParametersMgr storedProcedureParametersMgr = new StoredProcedureParametersMgr(this.UserSession);
status = storedProcedureParametersMgr.Read(storedProcedureId, out storedProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Sort by display order
// NOTE: ORDER IN DATABASE -SHOULD- BE ORDER IN SPROC.
// Transfer model.
parameterListViewModel = new ParameterListViewModel(this.UserSession, viewModel);
parameterListViewModel.StoredProcedureId = viewModel.StoredProcedureId;
foreach (StoredProcedureParameter storedProcedureParameter in storedProcedureParameterList)
{
ParameterLineItemViewModel parameterLineItemViewModel = new ParameterLineItemViewModel();
BufferMgr.TransferBuffer(storedProcedureParameter, parameterLineItemViewModel);
parameterLineItemViewModel.bRequired = storedProcedureParameter.bRequired ? "Yes" : "No";
parameterListViewModel.Items.Add(parameterLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, StoredProcedureId storedProcedureId, out List <Quest.Functional.MasterPricing.StoredProcedureParameter> storedProcedureParameterList)
{
// Initialize
questStatus status = null;
storedProcedureParameterList = null;
// Perform read
List <Quest.Services.Dbio.MasterPricing.StoredProcedureParameters> _storedProcedureParametersList = null;
status = read((MasterPricingEntities)trans.DbContext, storedProcedureId, out _storedProcedureParametersList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
storedProcedureParameterList = new List <StoredProcedureParameter>();
foreach (Quest.Services.Dbio.MasterPricing.StoredProcedureParameters _storedProcedureParameter in _storedProcedureParametersList)
{
Quest.Functional.MasterPricing.StoredProcedureParameter storedProcedureParameter = new Quest.Functional.MasterPricing.StoredProcedureParameter();
BufferMgr.TransferBuffer(_storedProcedureParameter, storedProcedureParameter);
storedProcedureParameterList.Add(storedProcedureParameter);
}
return(new questStatus(Severity.Success));
}
private questStatus read(MasterPricingEntities dbContext, StoredProcedureId storedProcedureId, out List <Quest.Services.Dbio.MasterPricing.StoredProcedureParameters> storedProcedureParameterList)
{
// Initialize
questStatus status = null;
storedProcedureParameterList = null;
try
{
storedProcedureParameterList = dbContext.StoredProcedureParameters.Where(r => r.StoredProcedureId == storedProcedureId.Id).ToList();
if (storedProcedureParameterList == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
String.Format("StoredProcedureId {0} not found", storedProcedureId.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));
}
private questStatus delete(MasterPricingEntities dbContext, DatabaseId databaseId)
{
// Initialize
questStatus status = null;
try
{
// Read all storedProcedures for this stored.
List <Quest.Services.Dbio.MasterPricing.StoredProcedures> _storedProceduresList = null;
status = read(dbContext, databaseId, out _storedProceduresList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Delete their parameters.
DbStoredProcedureParametersMgr dbStoredProcedureParametersMgr = new DbStoredProcedureParametersMgr(this.UserSession);
foreach (Quest.Services.Dbio.MasterPricing.StoredProcedures _storedProcedure in _storedProceduresList)
{
StoredProcedureId storedProcedureId = new StoredProcedureId(_storedProcedure.Id);
status = dbStoredProcedureParametersMgr.Delete(storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
// Delete the records.
dbContext.StoredProcedures.RemoveRange(_storedProceduresList);
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);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
// Delete storedProcedure
status = _dbStoredProceduresMgr.Delete(trans, storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
// Delete all procedureParameterProcedureParameters in this stored.
status = _dbStoredProcedureParametersMgr.Delete(storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
// Perform delete in this transaction.
status = delete((MasterPricingEntities)trans.DbContext, storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
RollbackTransaction(trans);
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, StoredProcedureId storedProcedureId, out List <Quest.Functional.MasterPricing.StoredProcedureParameter> storedProcedureParameterList)
{
// Initialize
questStatus status = null;
storedProcedureParameterList = null;
// Get stored procedure parameters.
status = _dbStoredProcedureParametersMgr.Read(trans, storedProcedureId, out storedProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, StoredProcedureId storedProcedureId, out StoredProcedure storedProcedure)
{
// Initialize
questStatus status = null;
storedProcedure = null;
// Read storedProcedure
status = _dbStoredProceduresMgr.Read(trans, storedProcedureId, out storedProcedure);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
// Perform delete.
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
status = delete(dbContext, storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
return(new questStatus(Severity.Success));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* StoredProcedures
*---------------------------------------------------------------------------------------------------------------------------------*/
private questStatus create(MasterPricingEntities dbContext, Quest.Functional.MasterPricing.StoredProcedure storedProcedure, out StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
storedProcedureId = null;
// Perform create
try
{
Quest.Services.Dbio.MasterPricing.StoredProcedures _storedProcedures = new Quest.Services.Dbio.MasterPricing.StoredProcedures();
BufferMgr.TransferBuffer(storedProcedure, _storedProcedures);
dbContext.StoredProcedures.Add(_storedProcedures);
dbContext.SaveChanges();
if (_storedProcedures.Id == 0)
{
return(new questStatus(Severity.Error, "Quest.Functional.MasterPricing.StoredProcedure not created"));
}
storedProcedureId = new StoredProcedureId(_storedProcedures.Id);
}
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);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, StoredProcedureId storedProcedureId, out Quest.Functional.MasterPricing.StoredProcedure storedProcedure)
{
// Initialize
questStatus status = null;
storedProcedure = null;
// Perform read
Quest.Services.Dbio.MasterPricing.StoredProcedures _storedProcedures = null;
status = read((MasterPricingEntities)trans.DbContext, storedProcedureId, out _storedProcedures);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
storedProcedure = new Quest.Functional.MasterPricing.StoredProcedure();
BufferMgr.TransferBuffer(_storedProcedures, storedProcedure);
return(new questStatus(Severity.Success));
}
private questStatus delete(MasterPricingEntities dbContext, StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
try
{
// Read the record.
Quest.Services.Dbio.MasterPricing.StoredProcedures _storedProcedures = null;
status = read(dbContext, storedProcedureId, out _storedProcedures);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Delete the record.
dbContext.StoredProcedures.Remove(_storedProcedures);
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);
}
return(new questStatus(Severity.Success));
}
public new questStatus GetStoredProdecureParameters(Quest.Functional.MasterPricing.Database database, string filterProcedureName, out List <FilterProcedureParameter> filterProcedureParameterList)
{
// Initialize
questStatus status = null;
filterProcedureParameterList = null;
// Get stored procedure
DatabaseId databaseId = new DatabaseId(database.Id);
StoredProcedure storedProcedure = null;
StoredProceduresMgr storedProceduresMgr = new StoredProceduresMgr(this.UserSession);
status = storedProceduresMgr.Read(databaseId, filterProcedureName, out storedProcedure);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get stored procedure parameters
StoredProcedureId storedProcedureId = new StoredProcedureId(storedProcedure.Id);
List <StoredProcedureParameter> storedProcedureParameterList = null;
StoredProcedureParametersMgr storedProcedureParametersMgr = new StoredProcedureParametersMgr(this.UserSession);
storedProcedureParametersMgr.Read(storedProcedureId, out storedProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer over to filter procedure.
filterProcedureParameterList = new List <FilterProcedureParameter>();
foreach (StoredProcedureParameter storedProcedureParameter in storedProcedureParameterList)
{
FilterProcedureParameter filterProcedureParameter = new FilterProcedureParameter();
BufferMgr.TransferBuffer(storedProcedureParameter, filterProcedureParameter);
filterProcedureParameterList.Add(filterProcedureParameter);
}
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region LIST
//----------------------------------------------------------------------------------------------------------------------------------
// LIST
//----------------------------------------------------------------------------------------------------------------------------------
public questStatus GetParamerListInfo(ParameterListViewModel viewModel, out ParameterListViewModel parameterListViewModel)
{
// Initialize
questStatus status = null;
parameterListViewModel = null;
DatabaseId databaseId = new DatabaseId(viewModel.DatabaseId);
// Read the database
DatabaseBaseViewModel databaseBaseViewModel = null;
DatabaseBaseModeler databaseBaseModeler = new DatabaseBaseModeler(this.HttpRequestBase, this.UserSession);
status = databaseBaseModeler.GetDatabase(databaseId, out databaseBaseViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read the stored procedure
StoredProceduresListViewModel storedProceduresListViewModel = null;
StoredProceduresListModeler storedProceduresListModeler = new StoredProceduresListModeler(this.HttpRequestBase, this.UserSession);
status = storedProceduresListModeler.List(databaseId, out storedProceduresListViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get stored procedure info
StoredProcedureId storedProcedureId = new StoredProcedureId(viewModel.Id);
// Read the stored procedure info
StoredProcedure storedProcedure = null;
StoredProceduresMgr storedProceduresMgr = new StoredProceduresMgr(this.UserSession);
status = storedProceduresMgr.Read(storedProcedureId, out storedProcedure);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get stored procedure parameters
viewModel.StoredProcedureId = viewModel.Id;
ParameterListViewModel _parameterListViewModel = null;
status = List(viewModel, out _parameterListViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Sort by display order
// NOTE: ORDER IN DATABASE -SHOULD- BE ORDER IN SPROC.
// Transfer model.
parameterListViewModel = new ParameterListViewModel(this.UserSession, viewModel);
parameterListViewModel.DatabaseId = databaseId.Id;
parameterListViewModel.Database = databaseBaseViewModel;
foreach (StoredProcedureLineItemViewModel storedProcedureLineItemViewModel in storedProceduresListViewModel.Items)
{
OptionValuePair opv = new OptionValuePair();
opv.Id = storedProcedureLineItemViewModel.Id.ToString();
opv.Label = storedProcedureLineItemViewModel.Name;
parameterListViewModel.StoredProcedureOptions.Add(opv);
}
parameterListViewModel.ParentEntityType = viewModel.ParentEntityType;
parameterListViewModel.StoredProcedureId = viewModel.StoredProcedureId;
StoredProcedureViewModel storedProcedureViewModel = new StoredProcedureViewModel();
BufferMgr.TransferBuffer(storedProcedure, storedProcedureViewModel);
parameterListViewModel.StoredProcedure = storedProcedureViewModel;
parameterListViewModel.Items = _parameterListViewModel.Items;
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Properties
*=================================================================================================================================*/
#endregion
#region Public Methods
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Create(Quest.Functional.MasterPricing.StoredProcedure storedProcedure, out StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
storedProcedureId = null;
// Data rules.
// Create the storedProcedure
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
status = create(dbContext, storedProcedure, out storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
return(new questStatus(Severity.Success));
}
public questStatus MakeRequired(MakeRequiredViewModel makeRequiredViewModel)
{
// Initialize
questStatus status = null;
Mgr mgr = new Mgr(this.UserSession);
DbMgrTransaction trans = null;
// BEGIN TRANSACTION
status = mgr.BeginTransaction("MakeRequired" + Guid.NewGuid().ToString(), out trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Update every parameter as required or not.
StoredProcedureParametersMgr storedProcedureParametersMgr = new StoredProcedureParametersMgr(this.UserSession);
foreach (BaseId baseId in makeRequiredViewModel.Items)
{
// Get the parameter
StoredProcedureParameterId storedProcedureParameterId = new StoredProcedureParameterId(baseId.Id);
StoredProcedureParameter storedProcedureParameter = null;
status = storedProcedureParametersMgr.Read(trans, storedProcedureParameterId, out storedProcedureParameter);
if (!questStatusDef.IsSuccess(status))
{
mgr.RollbackTransaction(trans);
return(status);
}
// Make sure same stored procedure
if (makeRequiredViewModel.StoredProcedureId != storedProcedureParameter.StoredProcedureId)
{
mgr.RollbackTransaction(trans);
return(new questStatus(Severity.Error, "All parameter Id's must be from the same stored procedure!"));
}
// Set required flag accordingly and update.
storedProcedureParameter.bRequired = true;
status = storedProcedureParametersMgr.Update(trans, storedProcedureParameter);
if (!questStatusDef.IsSuccess(status))
{
mgr.RollbackTransaction(trans);
return(status);
}
}
// Set all the OTHER parameters to false
List <StoredProcedureParameter> storedProcedureParameterList = null;
StoredProcedureId storedProcedureId = new StoredProcedureId(makeRequiredViewModel.StoredProcedureId);
status = storedProcedureParametersMgr.Read(trans, storedProcedureId, out storedProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
foreach (StoredProcedureParameter storedProcedureParameter in storedProcedureParameterList)
{
BaseId baseId = makeRequiredViewModel.Items.Find(delegate(BaseId _baseId) { return(_baseId.Id == storedProcedureParameter.Id); });
if (baseId == null)
{
storedProcedureParameter.bRequired = false;
status = storedProcedureParametersMgr.Update(trans, storedProcedureParameter);
if (!questStatusDef.IsSuccess(status))
{
mgr.RollbackTransaction(trans);
return(status);
}
}
}
// COMMIT TRANSACTION
// THIS HAS TO BE COMMITTED HERE TO AVOID DEADLOCKING ON UPDATING THE FILTERS, NEXT.
status = mgr.CommitTransaction(trans);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
////// BEGIN TRANSACTION
////status = mgr.BeginTransaction("MakeRequired_RefreshFilters" + Guid.NewGuid().ToString(), out trans);
////if (!questStatusDef.IsSuccess(status))
////{
//// return (status);
////}
////// Refresh filters using this sproc.
////List<Quest.Functional.MasterPricing.FilterId> updatedFilterIds = null;
////StoredProceduresMgr storedProceduresMgr = new StoredProceduresMgr(this.UserSession);
////status = storedProceduresMgr.RefreshFilters(storedProcedureId, out updatedFilterIds);
////if (!questStatusDef.IsSuccess(status))
////{
//// mgr.RollbackTransaction(trans);
//// return (status);
////}
////// COMMIT TRANSACTION
////status = mgr.CommitTransaction(trans);
////if (!questStatusDef.IsSuccess(status))
////{
//// return (status);
////}
////// TODO: REFACTOR TO GET ALL-IN-ONE TRANSACTION
////foreach (FilterId filterId in updatedFilterIds)
////{
//// Quest.Functional.MasterPricing.Filter filterWithSQL = null;
//// FilterMgr filterMgr = new FilterMgr(this.UserSession);
//// status = filterMgr.GenerateFilterSQL(filterId, out filterWithSQL);
//// if (!questStatusDef.IsSuccess(status))
//// {
//// return (status);
//// }
//// // Update filter
//// FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
//// status = filtersMgr.Update(filterWithSQL);
//// if (!questStatusDef.IsSuccess(status))
//// {
//// return (status);
//// }
////}
return(new questStatus(Severity.Success));
}
public questStatus RefreshFilters(StoredProcedureId storedProcedureId, out List <FilterId> updatedFilterIds)
{
// Every filter that uses this stored procedure, refresh it to update the 'Make Required' changes.
// Initialize
questStatus status = null;
updatedFilterIds = null;
// Get the database Id of this stored procedure
StoredProcedure storedProcedure = null;
status = _dbStoredProceduresMgr.Read(storedProcedureId, out storedProcedure);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get the tablesets using this database
DatabaseId databaseId = new DatabaseId(storedProcedure.DatabaseId);
List <Tableset> tablesetList = null;
TablesetsMgr tablesetsMgr = new TablesetsMgr(this.UserSession);
status = tablesetsMgr.Read(databaseId, out tablesetList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get the filters using these tablesets. Return the filters we updated.
// TODO: OPTIMIZE THIS FOR THE FILTERS RECORD ONLY. THIS IS A QUICK-FIX IN NEED OF BEING PUBLISHED ASAP.
updatedFilterIds = new List <FilterId>();
FilterMgr filterMgr = new FilterMgr(this.UserSession);
foreach (Tableset tableset in tablesetList)
{
TablesetId tablesetId = new TablesetId(tableset.Id);
List <Filter> filterList = null;
status = filterMgr.Read(tablesetId, out filterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Refresh these filters if not refreshed.
foreach (Filter filter in filterList)
{
// See if previously refreshed.
FilterId filterId = updatedFilterIds.Find(delegate(FilterId fid) { return(fid.Id == filter.Id); });
if (filterId != null)
{
continue;
}
// Update the filter
filterId = new FilterId(filter.Id);
status = filterMgr.Refresh(filterId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Record the Id we updated
filterId = new FilterId(filter.Id);
updatedFilterIds.Add(filterId);
}
}
return(new questStatus(Severity.Success));
}
public questStatus Create(DbMgrTransaction trans, Quest.Functional.MasterPricing.StoredProcedure storedProcedure, out StoredProcedureId storedProcedureId)
{
// Initialize
questStatus status = null;
storedProcedureId = null;
// Data rules.
// Create the storedProcedure in this transaction.
status = create((MasterPricingEntities)trans.DbContext, storedProcedure, out storedProcedureId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
