public override object Get(ApiCall call)
{
var view = call.WebSite.SiteDb().Views.Get(call.ObjectId);
if (view == null)
{
view = new View();
view.Body = DefaultView();
}
ViewViewModel viewmodel = new ViewViewModel()
{
Name = view.Name, Body = view.Body
};
viewmodel.DummyLayout = GetDummary(call.WebSite);
var layouts = call.WebSite.SiteDb().Layouts.All();
foreach (var item in layouts)
{
viewmodel.Layouts.Add(item.Name, GetLayoutPositions(item));
}
return(viewmodel);
}
///--------------------------------------------------------------------------------
/// <summary>This method is used to copy/paste a new item.</summary>
///
/// <param name="copyItem">The item to copy/paste.</param>
/// <param name="savePaste">Flag to determine whether to save the results of the paste.</param>
///--------------------------------------------------------------------------------
public ViewViewModel PasteView(ViewViewModel copyItem, bool savePaste = true)
{
View newItem = new View();
newItem.ReverseInstance = new View();
newItem.TransformDataFromObject(copyItem.View, null, false);
newItem.ViewID = Guid.NewGuid();
newItem.IsAutoUpdated = false;
newItem.Solution = Solution;
newItem.Solution = Solution;
ViewViewModel newView = new ViewViewModel(newItem, Solution);
newView.ResetModified(true);
AddView(newView);
// paste children
foreach (ViewPropertyViewModel childView in copyItem.ViewProperties)
{
newView.PasteViewProperty(childView, savePaste);
}
if (savePaste == true)
{
Solution.ViewList.Add(newItem);
newView.OnUpdated(this, null);
Solution.ResetModified(true);
}
return(newView);
}
///--------------------------------------------------------------------------------
/// <summary>This method loads Views into the view model.</summary>
///
/// <param name="solution">The associated solution.</param>
/// <param name="loadChildren">Flag indicating whether to perform a deeper load.</param>
///--------------------------------------------------------------------------------
public void LoadViews(Solution solution, bool loadChildren = true)
{
// attach the items
Items.Clear();
if (Views == null)
{
Views = new EnterpriseDataObjectList <ViewViewModel>();
}
if (loadChildren == true)
{
foreach (View item in solution.ViewList)
{
ViewViewModel itemView = new ViewViewModel(item, solution);
itemView.Updated += new EventHandler(Children_Updated);
Views.Add(itemView);
Items.Add(itemView);
}
}
}
private void InitializeEvents()
{
base.DataContextChanged += (s, e) =>
{
if (base.DataContext != null &&
base.DataContext is ViewViewModel)
{
Model = base.DataContext as ViewViewModel;
}
};
base.PreviewMouseLeftButtonDown += (s, e) =>
{
if (_model != null)
{
_model.MouseLeftButtonDown(e.GetPosition(this).ToPoint2());
}
};
base.PreviewMouseLeftButtonUp += (s, e) =>
{
if (_model != null)
{
_model.MouseLeftButtonUp(e.GetPosition(this).ToPoint2());
}
};
base.PreviewMouseMove += (s, e) =>
{
if (_model != null)
{
_model.MouseMove(e.GetPosition(this).ToPoint2());
}
};
base.PreviewMouseRightButtonDown += (s, e) =>
{
if (_model != null)
{
_model.MouseRightButtonDown(e.GetPosition(this).ToPoint2());
}
};
}
public async Task <IActionResult> Index(ViewViewModel model)
{
if (ModelState.IsValid)
{
// make sure we normalize the name if it's provided
if (model.Filter.Name != null)
{
model.Filter.Name = model.Filter.Name.PrepForDb();
}
// grab the foods that match the filter, ordered by the name
model.Foods = await _foodService.GetFilteredAsync(model.Filter, food => food.Name);
}
else
{
ModelState.AddModelError("", "Invalid input.");
}
return(View(model));
}
public async Task <IActionResult> UpdateView([FromBody] ViewViewModel viewViewModel)
{
try
{
var view = await viewRepository.GetByCouseIdAndDateTime(viewViewModel.CourseId, viewViewModel.DateTime);
if (view == null)
{
View viewMapped = mapper.Map <View>(viewViewModel);
viewMapped.Number = 1;
await viewRepository.Add(viewMapped);
return(Ok(new
{
Results = viewMapped
}));
}
else
{
view.Number += 1;
await viewRepository.Update(view);
return(Ok(new
{
Results = view
}));
}
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
public void InitializeModel(ViewViewModel model)
{
model.IsMouseCaptured = () =>
{
return(this.IsMouseCaptured);
};
model.CaptureMouse = () =>
{
this.CaptureMouse();
};
model.ReleaseMouseCapture = () =>
{
this.ReleaseMouseCapture();
};
model.InvalidateVisual = () =>
{
this.InvalidateVisual();
};
}
public async Task <IActionResult> Update([FromBody] ViewViewModel viewViewModel)
{
try
{
View viewMapped = mapper.Map <View>(viewViewModel);
await viewRepository.Update(viewMapped);
return(Ok(new
{
Results = viewMapped
}));
}
catch (Exception e)
{
Console.WriteLine($"ErrorMesages: {e}");
return(BadRequest(new
{
Errors = new { Code = "InvalidInputParameters", Description = "Invalid Input Parameters!" }
}));
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies view updates.</summary>
///--------------------------------------------------------------------------------
public void ProcessEditViewPerformed(ViewEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.View != null)
{
foreach (ViewViewModel item in Views)
{
if (item.View.ViewID == data.View.ViewID)
{
isItemMatch = true;
item.View.TransformDataFromObject(data.View, null, false);
item.OnUpdated(item, null);
item.ShowInTreeView();
break;
}
}
if (isItemMatch == false)
{
// add new View
data.View.Solution = Solution;
ViewViewModel newItem = new ViewViewModel(data.View, Solution);
newItem.Updated += new EventHandler(Children_Updated);
Views.Add(newItem);
Solution.ViewList.Add(newItem.View);
Items.Add(newItem);
OnUpdated(this, null);
newItem.ShowInTreeView();
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
///--------------------------------------------------------------------------------
/// <summary>This method applies solution deletes.</summary>
///--------------------------------------------------------------------------------
public void ProcessDeleteSolutionPerformed(SolutionEventArgs data)
{
try
{
bool isItemMatch = false;
if (data != null && data.Solution != null)
{
foreach (SolutionViewModel item in Solutions.ToList <SolutionViewModel>())
{
if (item.Solution.SolutionID == data.Solution.SolutionID)
{
// remove item from tabs, if present
WorkspaceEventArgs message = new WorkspaceEventArgs();
message.ItemID = item.Solution.SolutionID;
Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
// delete children
for (int i = item.Items.Count - 1; i >= 0; i--)
{
if (item.Items[i] is ViewViewModel)
{
ViewViewModel child = item.Items[i] as ViewViewModel;
ViewEventArgs childMessage = new ViewEventArgs();
childMessage.View = child.View;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ViewsFolder.ProcessDeleteViewPerformed(childMessage);
}
if (item.Items[i] is DatabaseSourceViewModel)
{
DatabaseSourceViewModel child = item.Items[i] as DatabaseSourceViewModel;
DatabaseSourceEventArgs childMessage = new DatabaseSourceEventArgs();
childMessage.DatabaseSource = child.DatabaseSource;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.SpecificationSourcesFolder.ProcessDeleteDatabaseSourcePerformed(childMessage);
}
if (item.Items[i] is XmlSourceViewModel)
{
XmlSourceViewModel child = item.Items[i] as XmlSourceViewModel;
XmlSourceEventArgs childMessage = new XmlSourceEventArgs();
childMessage.XmlSource = child.XmlSource;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.SpecificationSourcesFolder.ProcessDeleteXmlSourcePerformed(childMessage);
}
if (item.Items[i] is ProjectViewModel)
{
ProjectViewModel child = item.Items[i] as ProjectViewModel;
ProjectEventArgs childMessage = new ProjectEventArgs();
childMessage.Project = child.Project;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ProjectsFolder.ProcessDeleteProjectPerformed(childMessage);
}
if (item.Items[i] is FeatureViewModel)
{
FeatureViewModel child = item.Items[i] as FeatureViewModel;
FeatureEventArgs childMessage = new FeatureEventArgs();
childMessage.Feature = child.Feature;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.FeaturesFolder.ProcessDeleteFeaturePerformed(childMessage);
}
if (item.Items[i] is WorkflowViewModel)
{
WorkflowViewModel child = item.Items[i] as WorkflowViewModel;
WorkflowEventArgs childMessage = new WorkflowEventArgs();
childMessage.Workflow = child.Workflow;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.WorkflowsFolder.ProcessDeleteWorkflowPerformed(childMessage);
}
if (item.Items[i] is ModelViewModel)
{
ModelViewModel child = item.Items[i] as ModelViewModel;
ModelEventArgs childMessage = new ModelEventArgs();
childMessage.Model = child.Model;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.ModelsFolder.ProcessDeleteModelPerformed(childMessage);
}
if (item.Items[i] is DiagramViewModel)
{
DiagramViewModel child = item.Items[i] as DiagramViewModel;
DiagramEventArgs childMessage = new DiagramEventArgs();
childMessage.Diagram = child.Diagram;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.DiagramsFolder.ProcessDeleteDiagramPerformed(childMessage);
}
if (item.Items[i] is AuditPropertyViewModel)
{
AuditPropertyViewModel child = item.Items[i] as AuditPropertyViewModel;
AuditPropertyEventArgs childMessage = new AuditPropertyEventArgs();
childMessage.AuditProperty = child.AuditProperty;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.AuditPropertiesFolder.ProcessDeleteAuditPropertyPerformed(childMessage);
}
if (item.Items[i] is SpecTemplateViewModel)
{
SpecTemplateViewModel child = item.Items[i] as SpecTemplateViewModel;
SpecTemplateEventArgs childMessage = new SpecTemplateEventArgs();
childMessage.SpecTemplate = child.SpecTemplate;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.SpecTemplatesFolder.ProcessDeleteSpecTemplatePerformed(childMessage);
}
if (item.Items[i] is CodeTemplateViewModel)
{
CodeTemplateViewModel child = item.Items[i] as CodeTemplateViewModel;
CodeTemplateEventArgs childMessage = new CodeTemplateEventArgs();
childMessage.CodeTemplate = child.CodeTemplate;
childMessage.SolutionID = item.Solution.SolutionID;
childMessage.Solution = Solution;
childMessage.WorkspaceID = child.WorkspaceID;
item.CodeTemplatesFolder.ProcessDeleteCodeTemplatePerformed(childMessage);
}
}
// delete item
isItemMatch = true;
Solutions.Remove(item);
Items.Remove(item);
OnUpdated(this, null);
break;
}
}
if (isItemMatch == false)
{
ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
}
}
}
catch (Exception ex)
{
ShowIssue(ex.Message + ex.StackTrace);
}
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region LIST
//----------------------------------------------------------------------------------------------------------------------------------
// LIST
//----------------------------------------------------------------------------------------------------------------------------------
public questStatus List(ColumnListViewModel viewModel, out ColumnListViewModel columnListViewModel)
{
// Initialize
questStatus status = null;
columnListViewModel = null;
// Read the database
DatabaseId databaseId = new DatabaseId(viewModel.DatabaseId);
DatabaseBaseViewModel databaseBaseViewModel = null;
DatabaseBaseModeler databaseBaseModeler = new DatabaseBaseModeler(this.HttpRequestBase, this.UserSession);
status = databaseBaseModeler.GetDatabase(databaseId, out databaseBaseViewModel);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Get columns according to parent entity type
ColumnsMgr columnsMgr = new ColumnsMgr(this.UserSession);
List <Column> columnList = null;
Table table = null;
View view = null;
if (String.Equals(viewModel.ParentEntityType, "table", StringComparison.InvariantCultureIgnoreCase))
{
// Get table columns
TableId tableId = new TableId(viewModel.Id);
status = columnsMgr.Read(tableId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read the table info
TablesMgr tablesMgr = new TablesMgr(this.UserSession);
status = tablesMgr.Read(tableId, out table);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
else if (String.Equals(viewModel.ParentEntityType, "view", StringComparison.InvariantCultureIgnoreCase))
{
// Get view columns
ViewId viewId = new ViewId(viewModel.Id);
status = columnsMgr.Read(viewId, out columnList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Read the view info
ViewsMgr viewsMgr = new ViewsMgr(this.UserSession);
status = viewsMgr.Read(viewId, out view);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
}
else
{
return(new questStatus(Severity.Error, String.Format("Invalid ParentEntityType: {0}", viewModel.ParentEntityType)));
}
// Sort by display order
columnList.Sort(delegate(Column i1, Column i2) { return(i1.DisplayOrder.CompareTo(i2.DisplayOrder)); });
// Transfer model.
columnListViewModel = new ColumnListViewModel(this.UserSession, viewModel);
columnListViewModel.DatabaseId = databaseId.Id;
columnListViewModel.Database = databaseBaseViewModel;
columnListViewModel.Id = viewModel.Id;
columnListViewModel.ParentEntityType = viewModel.ParentEntityType;
if (table != null)
{
TableViewModel tableViewModel = new TableViewModel();
BufferMgr.TransferBuffer(table, tableViewModel);
columnListViewModel.Table = tableViewModel;
}
if (view != null)
{
ViewViewModel viewViewModel = new ViewViewModel();
BufferMgr.TransferBuffer(view, viewViewModel);
columnListViewModel.View = viewViewModel;
}
foreach (Column column in columnList)
{
ColumnLineItemViewModel columnLineItemViewModel = new ColumnLineItemViewModel();
BufferMgr.TransferBuffer(column, columnLineItemViewModel);
columnListViewModel.Items.Add(columnLineItemViewModel);
}
return(new questStatus(Severity.Success));
}
///--------------------------------------------------------------------------------
/// <summary>This method deletes an instance of View from the view model.</summary>
///
/// <param name="itemView">The View to delete.</param>
///--------------------------------------------------------------------------------
public void DeleteView(ViewViewModel itemView)
{
itemView.Updated -= Children_Updated;
Views.Remove(itemView);
Delete(itemView);
}
///--------------------------------------------------------------------------------
/// <summary>This method adds an instance of View to the view model.</summary>
///
/// <param name="itemView">The View to add.</param>
///--------------------------------------------------------------------------------
public void AddView(ViewViewModel itemView)
{
itemView.Updated += new EventHandler(Children_Updated);
Views.Add(itemView);
Add(itemView);
}
