public questStatus Read(DbMgrTransaction trans, DatabaseId databaseId, out List <Quest.Functional.MasterPricing.StoredProcedure> storedProcedureList)
{
// Initialize
questStatus status = null;
storedProcedureList = null;
// Perform read
List <Quest.Services.Dbio.MasterPricing.StoredProcedures> _storedProceduresList = null;
status = read((MasterPricingEntities)trans.DbContext, databaseId, out _storedProceduresList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
storedProcedureList = new List <StoredProcedure>();
foreach (Quest.Services.Dbio.MasterPricing.StoredProcedures _storedProcedure in _storedProceduresList)
{
Quest.Functional.MasterPricing.StoredProcedure storedProcedure = new Quest.Functional.MasterPricing.StoredProcedure();
BufferMgr.TransferBuffer(_storedProcedure, storedProcedure);
storedProcedureList.Add(storedProcedure);
}
return(new questStatus(Severity.Success));
}
public questStatus GetViewInfo(DatabaseId databaseId, TablesetView tablesetView, out View view)
{
// Initialize
questStatus status = null;
view = null;
// Get view
DbViewsMgr dbViewsMgr = new DbViewsMgr(this._userSession);
status = dbViewsMgr.Read(databaseId, tablesetView.Schema, tablesetView.Name, out view);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetView.View = view;
// Get view columns
ViewId viewId = new ViewId(view.Id);
List <Column> columnList = null;
DbColumnsMgr dbColumnsMgr = new DbColumnsMgr(this._userSession);
status = dbColumnsMgr.Read(viewId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
view.ColumnList = columnList;
return(new questStatus(Severity.Success));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus GetDatabase(DatabaseId databaseId, out DatabaseBaseViewModel databaseBaseViewModel)
{
// Initialize
questStatus status = null;
databaseBaseViewModel = null;
// Read the database
Quest.Functional.MasterPricing.Database database = null;
DatabasesMgr databasesMgr = new DatabasesMgr(this.UserSession);
status = databasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer model.
databaseBaseViewModel = new DatabaseBaseViewModel(this.UserSession);
BufferMgr.TransferBuffer(database, databaseBaseViewModel);
databaseBaseViewModel.LastRefresh = database.LastRefresh.HasValue ?
database.LastRefresh.Value.ToString("MM/dd/yyyy HH:mm:ss") : "";
return(new questStatus(Severity.Success));
}
public questStatus GetDatabaseViews(DatabaseId databaseId, out List <BootstrapTreenodeViewModel> dbViewNodeList)
{
// Initialize
questStatus status = null;
dbViewNodeList = null;
// Get db tables
List <DBTable> dbTableList = null;
DatabaseMgr databaseMgr = new DatabaseMgr(this.UserSession);
status = databaseMgr.GetDatabaseTables(databaseId, out dbTableList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Format into bootstrap nodes
dbViewNodeList = new List <BootstrapTreenodeViewModel>();
foreach (DBTable dbTable in dbTableList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(dbTable, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
dbViewNodeList.Add(bootstrapTreenodeViewModel);
}
return(new questStatus(Severity.Success));
}
public Database(DatabaseId id, DatabaseType type, string humanName, string tnsName)
{
Id = id;
Type = type;
HumanName = humanName;
TnsName = tnsName;
}
public questStatus Read(DatabaseId databaseId, out List <Quest.Functional.MasterPricing.Table> tableList)
{
// Initialize
questStatus status = null;
tableList = null;
// Perform read
using (MasterPricingEntities dbContext = new MasterPricingEntities())
{
List <Quest.Services.Dbio.MasterPricing.Tables> _tableList = null;
status = read(dbContext, databaseId, out _tableList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tableList = new List <Table>();
foreach (Quest.Services.Dbio.MasterPricing.Tables _table in _tableList)
{
Quest.Functional.MasterPricing.Table table = new Table();
BufferMgr.TransferBuffer(_table, table);
tableList.Add(table);
}
}
return(new questStatus(Severity.Success));
}
public questStatus GetTableInfo(DatabaseId databaseId, TablesetTable tablesetTable, out Table table)
{
// Initialize
questStatus status = null;
table = null;
// Get table
DbTablesMgr dbTablesMgr = new DbTablesMgr(this._userSession);
status = dbTablesMgr.Read(databaseId, tablesetTable.Schema, tablesetTable.Name, out table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetTable.Table = table;
// Get table columns
TableId tableId = new TableId(table.Id);
List <Column> columnList = null;
DbColumnsMgr dbColumnsMgr = new DbColumnsMgr(this._userSession);
status = dbColumnsMgr.Read(tableId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
table.ColumnList = columnList;
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, DatabaseId databaseId, out List <Quest.Functional.MasterPricing.View> viewList)
{
// Initialize
questStatus status = null;
viewList = null;
// Perform read
List <Quest.Services.Dbio.MasterPricing.Views> _viewList = null;
status = read((MasterPricingEntities)trans.DbContext, databaseId, out _viewList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
viewList = new List <View>();
foreach (Quest.Services.Dbio.MasterPricing.Views _view in _viewList)
{
Quest.Functional.MasterPricing.View view = new View();
BufferMgr.TransferBuffer(_view, view);
viewList.Add(view);
}
return(new questStatus(Severity.Success));
}
public void It_should_be_different_than_new_instance_with_different_ids()
{
var secondInstance = new DatabaseId(new[] { 11L, 22L, 33L });
Assert.That(secondInstance, Is.Not.EqualTo(SubjectUnderTest));
Assert.That(secondInstance.GetHashCode(), Is.Not.EqualTo(SubjectUnderTest.GetHashCode()));
}
private questStatus read(MasterPricingEntities dbContext, DatabaseId databaseId, string schema, string name, out Quest.Services.Dbio.MasterPricing.Tables table)
{
// Initialize
questStatus status = null;
table = null;
try
{
table = dbContext.Tables.Where(r => r.DatabaseId == databaseId.Id && r.Schema == schema && r.Name == name).SingleOrDefault();
if (table == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
String.Format("Schema {0} Name {1} not found", schema, name))));
}
}
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));
}
internal StoreIntegrityCheckJob(DatabaseId databaseId, Guid requestGuid, JobFlags flags, MailboxCorruptionType[] taskIds) : this()
{
this.creationTime = new DateTime?(DateTime.UtcNow.ToLocalTime());
this.flags = flags;
this.tasks = taskIds;
this.timeInServer = null;
}
private questStatus read(MasterPricingEntities dbContext, DatabaseId databaseId, out List <Quest.Services.Dbio.MasterPricing.Tables> tablesList)
{
// Initialize
questStatus status = null;
tablesList = null;
try
{
tablesList = dbContext.Tables.Where(r => r.DatabaseId == databaseId.Id).ToList();
if (tablesList == null)
{
return(new questStatus(Severity.Error, String.Format("ERROR: {0}.{1}: {2}",
this.GetType().Name, MethodBase.GetCurrentMethod().Name,
String.Format("DatabaseId {0} not found", databaseId.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(DatabaseId databaseId, out DatabaseEditorViewModel databaseEditorViewModel)
{
// Initialize
questStatus status = null;
databaseEditorViewModel = null;
// Read
Quest.Functional.MasterPricing.Database database = null;
DatabasesMgr databasesMgr = new DatabasesMgr(this.UserSession);
status = databasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer model.
databaseEditorViewModel = new DatabaseEditorViewModel(this.UserSession);
BufferMgr.TransferBuffer(database, databaseEditorViewModel);
return(new questStatus(Severity.Success));
}
// Token: 0x06000454 RID: 1108 RVA: 0x0000F700 File Offset: 0x0000D900
internal static DatabaseId ConvertDatabaseADObjectToDatabaseId(Database adObject)
{
if (adObject == null)
{
throw new ArgumentNullException("adObject");
}
string serverName = adObject.ServerName;
string text = adObject.Name;
Guid guid = adObject.Guid;
if (adObject.Identity != null)
{
DatabaseId databaseId = MapiTaskHelper.ConvertDatabaseADObjectIdToDatabaseId((ADObjectId)adObject.Identity);
if (string.IsNullOrEmpty(serverName))
{
serverName = databaseId.ServerName;
}
if (string.IsNullOrEmpty(text))
{
text = databaseId.DatabaseName;
}
if (Guid.Empty == guid)
{
guid = databaseId.Guid;
}
}
return(new DatabaseId(null, serverName, text, guid));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region Identifer-based Usage
//
// Identifer-based Usage
//
public questStatus Create(Quest.Functional.MasterPricing.Database database, out DatabaseId databaseId)
{
// Initialize
questStatus status = null;
databaseId = null;
// Create the database
DatabasesMgr databasesMgr = new DatabasesMgr(this.UserSession);
status = databasesMgr.Create(database, out databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Populate the database metadata
status = RefreshSchema(databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Read(DbMgrTransaction trans, DatabaseId databaseId, out List <Quest.Functional.MasterPricing.Tableset> tablesetList)
{
// Initialize
questStatus status = null;
tablesetList = null;
// Perform read
List <Quest.Services.Dbio.MasterPricing.Tablesets> _tablesetList = null;
status = read((MasterPricingEntities)trans.DbContext, databaseId, out _tablesetList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
tablesetList = new List <Quest.Functional.MasterPricing.Tableset>();
foreach (Quest.Services.Dbio.MasterPricing.Tablesets _tableSet in _tablesetList)
{
Quest.Functional.MasterPricing.Tableset tableset = new Tableset();
BufferMgr.TransferBuffer(_tableSet, tableset);
tablesetList.Add(tableset);
}
return(new questStatus(Severity.Success));
}
// TO DO: The number of parameters here is obviously ridiculous... but is consistent with DDD
// principles
public static Customer Create(int customerId, DateTime startDate, DateTime endDate, int statusCodeId, int nominationLevelId,
AccountNumber accountNumber, int customerTypeId, int deliveryTypeId, DUNSNumber dunsNumber, LongName longName,
ShortName shortName, DatabaseId ldcId, int lossTierId, DatabaseId deliveryLocation, int shipperId,
DeliveryPressure deliveryPressure, MDQ mdq, MaxHourlyInterruptible maxHourlyInterruptible,
MaxDailyInterruptible maxDailyInterruptible, HourlyInterruptible hourlyInterruptible,
DailyInterruptible dailyInterruptible, TotalHourlySpecifiedFirm totalHourlySpecifiedFirm,
TotalDailySpecifiedFirm totalDailySpecifiedFirm, InterstateSpecifiedFirm interstateSpecifiedFirm,
IntrastateSpecifiedFirm intrastateSpecifiedFirm, CurrentDemand currentDemand, PreviousDemand previousDemand,
int groupTypeId, int balancingLevelId, NAICSCode naicsCode, SICCode sicCode,
SICCodePercentage sicCodePercentage, DateTime shippersLetterFromDate, DateTime shippersLetterToDate,
bool ss1, bool isFederal, DateTime turnOffDate, DateTime turnOnDate)
{
DebugLog.Log("Entering Customer::Create");
return(new Customer
{
Id = customerId,
AccountNumber = accountNumber,
AlternateCustomerId = null,
BalancingLevelId = balancingLevelId,
BasicPoolId = null,
ContractTypeId = null,
CurrentDemand = null,
CustomerTypeId = customerTypeId,
DailyInterruptible = dailyInterruptible,
DeliveryLocation = deliveryLocation,
DeliveryPressure = deliveryPressure,
DeliveryTypeId = deliveryTypeId,
DUNSNumber = dunsNumber,
EndDate = endDate,
GroupTypeId = groupTypeId,
HourlyInterruptible = hourlyInterruptible,
InterstateSpecifiedFirm = interstateSpecifiedFirm,
IntrastateSpecifiedFirm = intrastateSpecifiedFirm,
IsFederal = isFederal,
LDCId = ldcId,
LongName = longName,
LossTierId = lossTierId,
MaxDailyInterruptible = maxDailyInterruptible,
MaxHourlyInterruptible = maxHourlyInterruptible,
MDQ = mdq,
NAICSCode = naicsCode,
NominationLevelId = nominationLevelId,
PreviousDemand = previousDemand,
StartDate = startDate,
StatusCodeId = statusCodeId,
ShortName = shortName,
ShipperId = shipperId,
ShippersLetterFromDate = shippersLetterFromDate,
ShippersLetterToDate = shippersLetterToDate,
SICCode = sicCode,
SICCodePercentage = sicCodePercentage,
SS1 = ss1,
TotalDailySpecifiedFirm = totalDailySpecifiedFirm,
TotalHourlySpecifiedFirm = totalHourlySpecifiedFirm,
TurnOffDate = turnOffDate,
TurnOnDate = turnOnDate
});
}
private static async Task ProcessImageProcessingMessageAsync(ImageMessage message)
{
var stopwatch = new Stopwatch();
stopwatch.Start();
// keep track of the gallery id so we can work on the gallery after the message batch is processed
lock (_galleryId)
_galleryId = new DatabaseId(message.GalleryId, message.GalleryCategoryId);
// retrieve Image object and bytes
var image = await GetImageAsync(message.ImageId, message.GalleryId);
var imageBytes = await GetImageBytesAsync(image);
// create array of file specs to iterate over
var specs = new List <FileSpec> {
FileSpec.Spec3840, FileSpec.Spec2560, FileSpec.Spec1920, FileSpec.Spec800, FileSpec.SpecLowRes
};
// resize original image file to smaller versions in parallel
//var parallelTasks = specs.Select(spec => ProcessImageAsync(image, imageBytes, spec)).ToList();
//await Task.WhenAll(parallelTasks);
//foreach (var spec in specs)
// await ProcessImageAsync(image, imageBytes, spec);
// This approach is the fastest of the three methods here. I have no idea why.
// 20MB image resized five times (each spec)
// Task.WhenAll: 11785ms average
// Foreach: 8540ms average
// Parallel.Foreach with GetAwaiter/GetResult: 7887ms average
Parallel.ForEach(specs, spec =>
{
ProcessImageAsync(image, imageBytes, spec).GetAwaiter().GetResult();
});
MetadataUtils.ParseAndAssignImageMetadata(image, imageBytes, message.OverwriteImageProperties, _log);
await UpdateImageAsync(image);
// pre-cache the image so it renders instantly for visitors
PreCacheImage(image);
// when uploading images, they don't have a position set, so if one is set when we process it here
// then it's likely it's an existing Image that's having it's image file replaced. If so and the position
// is zero then we want to make sure we update the gallery thumbnail to use the new image files.
if (image.Position == 0)
{
_log.Debug("LB.PhotoGalleries.Worker.Program.ProcessImageProcessingMessageAsync() - Image position = 0, need to update gallery thumbnail...");
var gallery = await GetGalleryAsync(image.GalleryCategoryId, image.GalleryId);
await UpdateGalleryThumbnailAsync(gallery, image.Files);
}
stopwatch.Stop();
_log.Information($"LB.PhotoGalleries.Worker.Program.ProcessImageProcessingMessageAsync() - Processed {image.Id} in {stopwatch.ElapsedMilliseconds}ms");
}
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 override int GetHashCode()
{
unchecked
{
var hashCode = (Host != null ? Host.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (AuthorisationKey != null ? AuthorisationKey.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (DatabaseId != null ? DatabaseId.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (CollectionId != null ? CollectionId.GetHashCode() : 0);
return(hashCode);
}
}
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));
}
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 ReadDatabaseEntities(DatabaseId databaseId, out DatabaseEntities databaseEntities)
{
// Initialize
questStatus status = null;
status = _dbDatabaseMgr.ReadDatabaseEntities(databaseId, out databaseEntities);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus RefreshSchema(DatabaseId databaseId)
{
// Initialize
questStatus status = null;
status = _dbDatabaseMgr.RefreshSchema(databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DatabaseId databaseId)
{
// Initialize
questStatus status = null;
// Delete table
status = _dbTablesMgr.Delete(databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, DatabaseId databaseId)
{
// Initialize
questStatus status = null;
// Delete view
status = _dbViewsMgr.Delete(trans, databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public ActionResult Last(Quest.MasterPricing.Database.Models.TablesListViewModel tablesListViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
tablesListViewModel.questStatus = status;
return(Json(tablesListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(tablesListViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
tablesListViewModel.questStatus = status;
return(Json(tablesListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Get list of items.
*---------------------------------------------------------------------------------------------------------------------------------*/
DatabaseId databaseId = new DatabaseId(tablesListViewModel.DatabaseId);
Quest.MasterPricing.Database.Models.TablesListViewModel tablesetsListViewModelNEW = null;
TablesListModeler tablesListModeler = new TablesListModeler(this.Request, this.UserSession);
status = tablesListModeler.List(databaseId, out tablesetsListViewModelNEW);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
tablesListViewModel.questStatus = status;
return(Json(tablesListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
tablesetsListViewModelNEW.DatabaseId = tablesListViewModel.DatabaseId;
tablesetsListViewModelNEW.questStatus = status;
return(Json(tablesetsListViewModelNEW, JsonRequestBehavior.AllowGet));
}
public questStatus GetDatabaseMetainfo(DatabaseId databaseId, out DatabaseMetaInfo databaseMetaInfo)
{
// Initialize
questStatus status = null;
// Get database metainfo.
status = _dbDatabaseMgr.GetDatabaseMetainfo(databaseId, out databaseMetaInfo);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public questStatus Delete(DbMgrTransaction trans, DatabaseId databaseId)
{
// Initialize
questStatus status = null;
// Delete all procedureProcedures in this procedure.
status = _dbStoredProceduresMgr.Delete(trans, databaseId);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public ActionResult PageNum(Quest.MasterPricing.Database.Models.StoredProceduresListViewModel storedProceduresListViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
storedProceduresListViewModel.questStatus = status;
return(Json(storedProceduresListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(storedProceduresListViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
storedProceduresListViewModel.questStatus = status;
return(Json(storedProceduresListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Get list of items.
*---------------------------------------------------------------------------------------------------------------------------------*/
DatabaseId databaseId = new DatabaseId(storedProceduresListViewModel.DatabaseId);
Quest.MasterPricing.Database.Models.StoredProceduresListViewModel viewsetsListViewModelNEW = null;
StoredProceduresListModeler viewsListModeler = new StoredProceduresListModeler(this.Request, this.UserSession);
status = viewsListModeler.List(databaseId, out viewsetsListViewModelNEW);
if (!questStatusDef.IsSuccess(status))
{
status = new questStatus(Severity.Success);
storedProceduresListViewModel.questStatus = status;
return(Json(storedProceduresListViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return view
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
viewsetsListViewModelNEW.questStatus = status;
return(Json(viewsetsListViewModelNEW, JsonRequestBehavior.AllowGet));
}