示例#1
0
        ///--------------------------------------------------------------------------------
        /// <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 AuditPropertyViewModel PasteAuditProperty(AuditPropertyViewModel copyItem, bool savePaste = true)
        {
            AuditProperty newItem = new AuditProperty();

            newItem.ReverseInstance = new AuditProperty();
            newItem.TransformDataFromObject(copyItem.AuditProperty, null, false);
            newItem.PropertyID    = Guid.NewGuid();
            newItem.IsAutoUpdated = false;

            newItem.Solution = Solution;
            newItem.Solution = Solution;
            AuditPropertyViewModel newView = new AuditPropertyViewModel(newItem, Solution);

            newView.ResetModified(true);
            AddAuditProperty(newView);

            // paste children
            if (savePaste == true)
            {
                Solution.AuditPropertyList.Add(newItem);
                newView.OnUpdated(this, null);
                Solution.ResetModified(true);
            }
            return(newView);
        }
示例#2
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method loads AuditProperties 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 LoadAuditProperties(Solution solution, bool loadChildren = true)
 {
     // attach the items
     Items.Clear();
     if (AuditProperties == null)
     {
         AuditProperties = new EnterpriseDataObjectList <AuditPropertyViewModel>();
     }
     if (loadChildren == true)
     {
         foreach (AuditProperty item in solution.AuditPropertyList)
         {
             AuditPropertyViewModel itemView = new AuditPropertyViewModel(item, solution);
             itemView.Updated += new EventHandler(Children_Updated);
             AuditProperties.Add(itemView);
             Items.Add(itemView);
         }
     }
 }
示例#3
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method applies auditproperty updates.</summary>
 ///--------------------------------------------------------------------------------
 public void ProcessEditAuditPropertyPerformed(AuditPropertyEventArgs data)
 {
     try
     {
         bool isItemMatch = false;
         if (data != null && data.AuditProperty != null)
         {
             foreach (AuditPropertyViewModel item in AuditProperties)
             {
                 if (item.AuditProperty.PropertyID == data.AuditProperty.PropertyID)
                 {
                     isItemMatch = true;
                     item.AuditProperty.TransformDataFromObject(data.AuditProperty, null, false);
                     item.OnUpdated(item, null);
                     item.ShowInTreeView();
                     break;
                 }
             }
             if (isItemMatch == false)
             {
                 // add new AuditProperty
                 data.AuditProperty.Solution = Solution;
                 AuditPropertyViewModel newItem = new AuditPropertyViewModel(data.AuditProperty, Solution);
                 newItem.Updated += new EventHandler(Children_Updated);
                 AuditProperties.Add(newItem);
                 Solution.AuditPropertyList.Add(newItem.AuditProperty);
                 Items.Add(newItem);
                 OnUpdated(this, null);
                 newItem.ShowInTreeView();
             }
         }
     }
     catch (Exception ex)
     {
         ShowIssue(ex.Message + ex.StackTrace);
     }
 }
示例#4
0
        ///--------------------------------------------------------------------------------
        /// <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);
            }
        }
示例#5
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method deletes an instance of AuditProperty from the view model.</summary>
 ///
 /// <param name="itemView">The AuditProperty to delete.</param>
 ///--------------------------------------------------------------------------------
 public void DeleteAuditProperty(AuditPropertyViewModel itemView)
 {
     itemView.Updated -= Children_Updated;
     AuditProperties.Remove(itemView);
     Delete(itemView);
 }
示例#6
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method adds an instance of AuditProperty to the view model.</summary>
 ///
 /// <param name="itemView">The AuditProperty to add.</param>
 ///--------------------------------------------------------------------------------
 public void AddAuditProperty(AuditPropertyViewModel itemView)
 {
     itemView.Updated += new EventHandler(Children_Updated);
     AuditProperties.Add(itemView);
     Add(itemView);
 }