public ActionResult Cancel(FilterEditorViewModel viewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
// TODO
throw new Exception("LogOperation failed");
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
// TODO
throw new Exception("Authorize failed");
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Direct user to list
*---------------------------------------------------------------------------------------------------------------------------------*/
return(RedirectToAction("Index", "DataMgr", PropagateQueryString(Request)));
}
public ActionResult Run(FilterEditorViewModel viewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
RunFilterRequest runFilterRequest = new RunFilterRequest();
runFilterRequest.FilterId.Id = viewModel.FilterId;
runFilterRequest.RowLimit = viewModel._ResultsOptions.RowLimit;
runFilterRequest.ColLimit = viewModel._ResultsOptions.ColLimit;
FilterRunViewModel filterRunViewModel = null;
FilterPanelModeler filterPanelModeler = new FilterPanelModeler(Request, this.UserSession, viewModel);
status = filterPanelModeler.Run(runFilterRequest, out filterRunViewModel);
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success, "Filter successfully run");
filterRunViewModel.questStatus = status;
return(Json(filterRunViewModel, JsonRequestBehavior.AllowGet));
}
public ActionResult Tables(FilterEditorViewModel filterEditorViewModel)
{
// Initialize
questStatus status = null;
UserMessageModeler userMessageModeler = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(filterEditorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Get tableset tables.
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(filterEditorViewModel.TablesetId);
FilterTableTreeviewViewModel filterTableTreeviewViewModel = null;
TablesetModeler tablesetModeler = new TablesetModeler(this.Request, this.UserSession, filterEditorViewModel);
status = tablesetModeler.List(tablesetId, out filterTableTreeviewViewModel);
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return data.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
filterTableTreeviewViewModel.questStatus = status;
return(Json(filterTableTreeviewViewModel, JsonRequestBehavior.AllowGet));
}
public ActionResult Read(FilterEditorViewModel viewModel)
{
questStatus status = 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));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
FilterId filterId = new FilterId(viewModel.Id);
FilterEditorViewModel filterEditorViewModel = null;
FilterEditorModeler filterEditorModeler = new FilterEditorModeler(this.Request, this.UserSession);
status = filterEditorModeler.Read(filterId, out filterEditorViewModel);
if (!questStatusDef.IsSuccess(status))
{
userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success);
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
public ActionResult Save(FilterEditorViewModel filterEditorViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(filterEditorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
bool bInitialCreation = filterEditorViewModel.Id < BaseId.VALID_ID ? true : false;
FilterEditorModeler filterEditorModeler = new FilterEditorModeler(this.Request, this.UserSession);
status = filterEditorModeler.Save(filterEditorViewModel);
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success, "Filter successfully" + (bInitialCreation ? " created" : " updated"));
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
public ActionResult ProcedureOptions(FilterEditorViewModel filterEditorViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
UserMessageModeler userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler.UserMessage, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(filterEditorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
UserMessageModeler userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler.UserMessage, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
TablesetId tablesetId = new TablesetId(filterEditorViewModel.TablesetId);
List <OptionValuePair> optionValuePairList = null;
FilterProcedureModeler filterProcedureModeler = new FilterProcedureModeler(this.Request, this.UserSession);
status = filterProcedureModeler.GetFilterProcedureOptions(tablesetId, out optionValuePairList, filterEditorViewModel.FilterId.ToString());
if (!questStatusDef.IsSuccess(status))
{
UserMessageModeler userMessageModeler = new UserMessageModeler(status);
return(Json(userMessageModeler.UserMessage, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Respond
*---------------------------------------------------------------------------------------------------------------------------------*/
return(Json(optionValuePairList, JsonRequestBehavior.AllowGet));
}
public ActionResult Delete(FilterEditorViewModel filterEditorViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
// TODO
throw new Exception("LogOperation failed");
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(filterEditorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
// TODO
throw new Exception("Authorize failed");
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
FilterId filterId = new FilterId(filterEditorViewModel.Id);
FilterEditorModeler filterEditorModeler = new FilterEditorModeler(this.Request, this.UserSession);
status = filterEditorModeler.Delete(filterId);
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success, "Filter successfully deleted");
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus Save(FilterEditorViewModel filterEditorViewModel)
{
// Initialize
questStatus status = null;
// Validate
if (filterEditorViewModel.TablesetId < BaseId.VALID_ID)
{
return(new questStatus(Severity.Error, "Invalid Tableset Id"));
}
// Transfer model
Quest.Functional.MasterPricing.Filter filter = new Functional.MasterPricing.Filter();
BufferMgr.TransferBuffer(filterEditorViewModel, filter);
// Determine if this is a create or update
FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
if (filterEditorViewModel.Id < BaseId.VALID_ID)
{
// Create
FilterId filterId = null;
status = filtersMgr.Create(filter, out filterId);
if (!questStatusDef.IsSuccess(status))
{
FormatErrorMessage(status, filterEditorViewModel);
return(status);
}
filterEditorViewModel.Id = filterId.Id;
}
else
{
// Update
status = filtersMgr.Update(filter);
if (!questStatusDef.IsSuccess(status))
{
FormatErrorMessage(status, filterEditorViewModel);
return(status);
}
}
return(new questStatus(Severity.Success));
}
public ActionResult Save(FilterEditorViewModel filterEditorViewModel)
{
questStatus status = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(filterEditorViewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
// TODO
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Warning, "Not implemented");
filterEditorViewModel.questStatus = status;
return(Json(filterEditorViewModel, JsonRequestBehavior.AllowGet));
}
public questStatus Read(FilterId filterId, out FilterEditorViewModel filterEditorViewModel)
{
// Initialize
questStatus status = null;
filterEditorViewModel = null;
// Read filter
Quest.Functional.MasterPricing.Filter filter = null;
FilterMgr filterMgr = new FilterMgr(this.UserSession);
status = filterMgr.GetFilter(filterId, out filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Transfer model
filterEditorViewModel = new FilterEditorViewModel();
BufferMgr.TransferBuffer(filter, filterEditorViewModel);
foreach (FilterTable filterTable in filter.FilterTableList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(filterTable, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
filterEditorViewModel.Entities.Add(bootstrapTreenodeViewModel);
}
foreach (FilterView filterView in filter.FilterViewList)
{
BootstrapTreenodeViewModel bootstrapTreenodeViewModel = null;
status = FormatBootstrapTreeviewNode(filterView, out bootstrapTreenodeViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
filterEditorViewModel.Entities.Add(bootstrapTreenodeViewModel);
}
foreach (FilterItem filterItem in filter.FilterItemList)
{
FilterItemViewModel filterItemViewModel = new FilterItemViewModel();
filterItemViewModel.Id = filterItem.Id;
////filterItemViewModel.Name = filterItem.TablesetColumn.Name;
filterItemViewModel.Name = filterItem.FilterColumn.TablesetColumn.Column.Name;
filterItemViewModel.Label = filterItem.Label;
filterItemViewModel.ParameterName = filterItem.ParameterName;
filterItemViewModel.bHidden = filterItem.bHidden;
filterItemViewModel.bBulkUpdateValueRequired = filterItem.bBulkUpdateValueRequired;
filterItemViewModel.Entity.type = "column"; // TODO: ALL THAT'S SUPPORTED RIGHT NOW.
filterItemViewModel.Entity.Schema = null;
filterItemViewModel.Entity.Name = filterItem.FilterColumn.TablesetColumn.Column.Name;
BufferMgr.TransferBuffer(filterItem.FilterColumn.TablesetColumn.Column, filterItemViewModel.Entity.Column);
filterItemViewModel.ParentEntity.type = filterItem.FilterColumn.ParentEntityType.type;
filterItemViewModel.ParentEntity.Schema = filterItem.FilterColumn.ParentEntityType.Schema;
filterItemViewModel.ParentEntity.Name = filterItem.FilterColumn.ParentEntityType.Name;
// Joins
foreach (FilterItemJoin filterItemJoin in filterItem.JoinList)
{
FilterItemJoinViewModel filterItemJoinViewModel = new FilterItemJoinViewModel();
BufferMgr.TransferBuffer(filterItemJoin, filterItemJoinViewModel);
filterItemJoinViewModel.Identifier = '[' + filterItemJoin.TargetSchema + "].[" + filterItemJoin.TargetEntityName + "].[" + filterItemJoin.TargetColumnName + "]";
filterItemViewModel.Joins.Add(filterItemJoinViewModel);
}
// Operations
foreach (FilterOperation filterOperation in filterItem.OperationList)
{
FilterOperationViewModel filterOperationViewModel = new FilterOperationViewModel();
filterOperationViewModel.Id = filterOperation.Id;
filterOperationViewModel.Operator = filterOperation.FilterOperatorId;
// Views
foreach (FilterValue filterValue in filterOperation.ValueList)
{
FilterValueViewModel filterValueViewModel = new FilterValueViewModel();
filterValueViewModel.Id = filterValue.Id;
filterValueViewModel.Value = filterValue.Value;
filterOperationViewModel.Values.Add(filterValueViewModel);
}
filterItemViewModel.Operations.Add(filterOperationViewModel);
}
// Lookup
if (filterItem.LookupId.HasValue)
{
FilterItemLookupViewModel filterItemLookupViewModel = new FilterItemLookupViewModel();
filterItemLookupViewModel.Id = filterItem.Lookup.Id;
filterItemLookupViewModel.Name = filterItem.Lookup.Name;
filterItemViewModel.Lookup = filterItemLookupViewModel;
}
// TypeList
if (filterItem.TypeListId.HasValue)
{
FilterItemTypeListViewModel filterItemTypeListViewModel = new FilterItemTypeListViewModel();
filterItemTypeListViewModel.Id = filterItem.TypeList.Id;
filterItemTypeListViewModel.Name = filterItem.TypeList.Name;
filterItemViewModel.TypeList = filterItemTypeListViewModel;
}
filterEditorViewModel.Items.Add(filterItemViewModel);
}
foreach (FilterProcedure filterProcedure in filter.FilterProcedureList)
{
FilterProcedureViewModel filterProcedureViewModel = new FilterProcedureViewModel();
BufferMgr.TransferBuffer(filterProcedure, filterProcedureViewModel);
foreach (FilterProcedureParameter filterProcedureParameter in filterProcedure.ParameterList)
{
FilterProcedureParameterViewModel filterProcedureParameterViewModel = new FilterProcedureParameterViewModel();
BufferMgr.TransferBuffer(filterProcedureParameter, filterProcedureParameterViewModel, true);
filterProcedureParameterViewModel.Precision = filterProcedureParameter.Precision[0];
filterProcedureParameterViewModel.Scale = filterProcedureParameter.Scale[0];
filterProcedureViewModel.Parameters.Add(filterProcedureParameterViewModel);
}
filterEditorViewModel.Procedures.Add(filterProcedureViewModel);
}
return(new questStatus(Severity.Success));
}
public ActionResult Save(FilterPanelViewModel viewModel)
{
questStatus status = null;
JavaScriptSerializer javaScriptSerializer = null;
/*----------------------------------------------------------------------------------------------------------------------------------
* Log Operation
*---------------------------------------------------------------------------------------------------------------------------------*/
status = LogOperation();
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Authorize
*---------------------------------------------------------------------------------------------------------------------------------*/
status = Authorize(viewModel._ctx);
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Perform operation.
*---------------------------------------------------------------------------------------------------------------------------------*/
bool bHaveEditor = false;
if (viewModel.Entities.Count == 0)
{
if (Request.Form["Entities"] != null)
{
string entities = Request.Form["Entities"].ToString();
javaScriptSerializer = javaScriptSerializer != null ? javaScriptSerializer : new JavaScriptSerializer();
List <BootstrapTreenodeViewModel> entitiesList = javaScriptSerializer.Deserialize <List <BootstrapTreenodeViewModel> >(entities);
viewModel.Entities = entitiesList;
}
if (Request.Form["Editor"] != null)
{
string editor = Request.Form["Editor"].ToString();
javaScriptSerializer = javaScriptSerializer != null ? javaScriptSerializer : new JavaScriptSerializer();
FilterEditorViewModel _editor = javaScriptSerializer.Deserialize <FilterEditorViewModel>(editor);
viewModel.Editor = _editor;
bHaveEditor = true;
}
}
if (viewModel.Items.Count == 0)
{
if (Request.Form["Items"] != null)
{
string items = Request.Form["Items"].ToString();
javaScriptSerializer = javaScriptSerializer != null ? javaScriptSerializer : new JavaScriptSerializer();
List <FilterItemViewModel> itemsList = javaScriptSerializer.Deserialize <List <FilterItemViewModel> >(items);
viewModel.Items = itemsList;
}
if (Request.Form["Editor"] != null)
{
if (!bHaveEditor)
{
string editor = Request.Form["Editor"].ToString();
javaScriptSerializer = javaScriptSerializer != null ? javaScriptSerializer : new JavaScriptSerializer();
FilterEditorViewModel _editor = javaScriptSerializer.Deserialize <FilterEditorViewModel>(editor);
viewModel.Editor = _editor;
}
}
}
FilterPanelModeler filterPanelModeler = new FilterPanelModeler(Request, this.UserSession, viewModel);
status = filterPanelModeler.Save(viewModel);
if (!questStatusDef.IsSuccess(status))
{
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
/*----------------------------------------------------------------------------------------------------------------------------------
* Return result.
*---------------------------------------------------------------------------------------------------------------------------------*/
status = new questStatus(Severity.Success, "Filter saved");
viewModel.questStatus = status;
return(Json(viewModel, JsonRequestBehavior.AllowGet));
}
