///--------------------------------------------------------------------------------
        /// <summary>This method removes a template from the view models (and tree and designer).</summary>
        ///
        /// <param name="templateID">The ID of the template to remove.</param>
        ///--------------------------------------------------------------------------------
        public CodeTemplateViewModel RemoveTemplate(Guid templateID, bool removeFromTabs = true)
        {
            foreach (CodeTemplateViewModel template in Items.OfType <CodeTemplateViewModel>())
            {
                if (template.CodeTemplate.TemplateID == templateID)
                {
                    if (removeFromTabs == true)
                    {
                        // remove item from tabs, if present
                        WorkspaceEventArgs message = new WorkspaceEventArgs();
                        message.ItemID = templateID;
                        Mediator.NotifyColleagues <WorkspaceEventArgs>(MediatorMessages.Command_CloseItemRequested, message);
                    }

                    // remove item from Items and tree
                    Items.Remove(template);
                    template.Updated -= Children_Updated;
                    return(template);
                }
            }
            foreach (CodeTemplatesViewModel folder in Items.OfType <CodeTemplatesViewModel>())
            {
                CodeTemplateViewModel template = folder.RemoveTemplate(templateID, removeFromTabs);
                if (template != null)
                {
                    if (folder.TemplateModelNode != ModelContextTypeCode.Solution.ToString() && folder.Items.Count == 0)
                    {
                        Items.Remove(folder);
                        folder.Updated -= Children_Updated;
                    }
                    return(template);
                }
            }
            return(null);
        }
Exemple #2
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 CodeTemplateViewModel PasteCodeTemplate(CodeTemplateViewModel copyItem, bool savePaste = true)
        {
            CodeTemplate newItem = new CodeTemplate();

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

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

            newView.ResetModified(true);
            AddCodeTemplate(newView);

            // paste children
            if (savePaste == true)
            {
                Solution.CodeTemplateList.Add(newItem);
                newView.OnUpdated(this, null);
                Solution.ResetModified(true);
            }
            return(newView);
        }
Exemple #3
0
        ///--------------------------------------------------------------------------------
        /// <summary>This method applies codetemplate deletes.</summary>
        ///--------------------------------------------------------------------------------
        public void ProcessDeleteCodeTemplatePerformed(CodeTemplateEventArgs data)
        {
            try
            {
                #region protected
                if (data != null && data.CodeTemplate != null)
                {
                    CodeTemplateViewModel template = RemoveTemplate(data.CodeTemplate.TemplateID);
                    if (template != null && System.IO.File.Exists(template.CodeTemplate.FilePath))
                    {
                        // delete file
                        System.IO.File.Delete(template.CodeTemplate.FilePath);

                        // remove from solution
                        Solution.CodeTemplates.Remove(template.CodeTemplate.TemplateKey);
                        Solution.CodeTemplateList.Remove(template.CodeTemplate);
                    }
                    else
                    {
                        ShowIssue(DisplayValues.Issue_DeleteItemNotFound);
                    }
                }
                #endregion protected
            }
            catch (Exception ex)
            {
                ShowIssue(ex.Message + ex.StackTrace);
            }
        }
Exemple #4
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method loads CodeTemplates 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 LoadCodeTemplates(Solution solution, bool loadChildren = true)
 {
     // attach the items
     Items.Clear();
     if (CodeTemplates == null)
     {
         CodeTemplates = new EnterpriseDataObjectList <CodeTemplateViewModel>();
     }
     if (loadChildren == true)
     {
         foreach (CodeTemplate item in solution.CodeTemplateList)
         {
             CodeTemplateViewModel itemView = new CodeTemplateViewModel(item, solution);
             itemView.Updated += new EventHandler(Children_Updated);
             CodeTemplates.Add(itemView);
             Items.Add(itemView);
         }
     }
 }
Exemple #5
0
        ///--------------------------------------------------------------------------------
        /// <summary>This method applies codetemplate updates.</summary>
        ///--------------------------------------------------------------------------------
        public void ProcessEditCodeTemplatePerformed(CodeTemplateEventArgs data)
        {
            try
            {
                #region protected
                try
                {
                    if (data != null && data.CodeTemplate != null)
                    {
                        data.CodeTemplate.SaveTemplateFile();
                        data.CodeTemplate.HasErrors = false;
                        if (!String.IsNullOrEmpty(data.CodeTemplate.TemplateContent))
                        {
                            data.CodeTemplate.ParseContent(false);
                        }
                        if (!String.IsNullOrEmpty(data.CodeTemplate.TemplateOutput))
                        {
                            data.CodeTemplate.ParseOutput(false);
                        }
                        RemoveTemplate(data.CodeTemplate.TemplateID, false);

                        // new template view model
                        CodeTemplateViewModel template = new CodeTemplateViewModel(data.CodeTemplate, Solution);
                        AddTemplate(template);
                        template.ShowInTreeView();
                    }
                }
                catch (System.Exception ex)
                {
                    ShowException(ex);
                }
                #endregion protected
            }
            catch (Exception ex)
            {
                ShowIssue(ex.Message + ex.StackTrace);
            }
        }
        ///--------------------------------------------------------------------------------
        /// <summary>This method adds a template to the view models (and tree).</summary>
        ///
        /// <param name="template">The template to add.</param>
        /// <param name="refresh">Flag whether to refresh view.</param>
        ///--------------------------------------------------------------------------------
        public void AddTemplate(CodeTemplateViewModel template, bool refresh = true)
        {
            ModelContextTypeCode modelContextTypeEnum = ModelContextTypeCode.None;

            Enum.TryParse <ModelContextTypeCode>(template.CodeTemplate.TemplateType, out modelContextTypeEnum);
            switch (TemplateModelNode)
            {
            case "Solution":
                string templateName = String.Empty;
                switch (modelContextTypeEnum)
                {
                case ModelContextTypeCode.AuditProperty:
                    templateName = Resources.DisplayValues.NodeName_Templates_AuditProperty;
                    break;

                case ModelContextTypeCode.Collection:
                    templateName = Resources.DisplayValues.NodeName_Templates_Collection;
                    break;

                case ModelContextTypeCode.Entity:
                    templateName = Resources.DisplayValues.NodeName_Templates_Entity;
                    break;

                case ModelContextTypeCode.EntityReference:
                    templateName = Resources.DisplayValues.NodeName_Templates_EntityReference;
                    break;

                case ModelContextTypeCode.Feature:
                    templateName = Resources.DisplayValues.NodeName_Templates_Feature;
                    break;

                case ModelContextTypeCode.Index:
                    templateName = Resources.DisplayValues.NodeName_Templates_Index;
                    break;

                case ModelContextTypeCode.IndexProperty:
                    templateName = Resources.DisplayValues.NodeName_Templates_IndexProperty;
                    break;

                case ModelContextTypeCode.Method:
                    templateName = Resources.DisplayValues.NodeName_Templates_Method;
                    break;

                case ModelContextTypeCode.Parameter:
                    templateName = Resources.DisplayValues.NodeName_Templates_Parameter;
                    break;

                case ModelContextTypeCode.Project:
                    templateName = Resources.DisplayValues.NodeName_Templates_Project;
                    break;

                case ModelContextTypeCode.Property:
                    templateName = Resources.DisplayValues.NodeName_Templates_Property;
                    break;

                case ModelContextTypeCode.PropertyReference:
                    templateName = Resources.DisplayValues.NodeName_Templates_PropertyReference;
                    break;

                case ModelContextTypeCode.Relationship:
                    templateName = Resources.DisplayValues.NodeName_Templates_Relationship;
                    break;

                case ModelContextTypeCode.RelationshipProperty:
                    templateName = Resources.DisplayValues.NodeName_Templates_RelationshipProperty;
                    break;

                case ModelContextTypeCode.Workflow:
                    templateName = Resources.DisplayValues.NodeName_Templates_Workflow;
                    break;

                case ModelContextTypeCode.View:
                    templateName = Resources.DisplayValues.NodeName_Templates_View;
                    break;

                case ModelContextTypeCode.ViewProperty:
                    templateName = Resources.DisplayValues.NodeName_Templates_ViewProperty;
                    break;

                case ModelContextTypeCode.Stage:
                    templateName = Resources.DisplayValues.NodeName_Templates_Stage;
                    break;

                case ModelContextTypeCode.StageTransition:
                    templateName = Resources.DisplayValues.NodeName_Templates_StageTransition;
                    break;

                case ModelContextTypeCode.Step:
                    templateName = Resources.DisplayValues.NodeName_Templates_Step;
                    break;

                case ModelContextTypeCode.StepTransition:
                    templateName = Resources.DisplayValues.NodeName_Templates_StepTransition;
                    break;

                case ModelContextTypeCode.StateModel:
                    templateName = Resources.DisplayValues.NodeName_Templates_StateModel;
                    break;

                case ModelContextTypeCode.State:
                    templateName = Resources.DisplayValues.NodeName_Templates_State;
                    break;

                case ModelContextTypeCode.StateTransition:
                    templateName = Resources.DisplayValues.NodeName_Templates_StateTransition;
                    break;

                case ModelContextTypeCode.Model:
                    templateName = Resources.DisplayValues.NodeName_Templates_Model;
                    break;

                case ModelContextTypeCode.ModelObject:
                    templateName = Resources.DisplayValues.NodeName_Templates_ModelObject;
                    break;

                case ModelContextTypeCode.ModelProperty:
                    templateName = Resources.DisplayValues.NodeName_Templates_ModelProperty;
                    break;

                case ModelContextTypeCode.Enumeration:
                    templateName = Resources.DisplayValues.NodeName_Templates_Enumeration;
                    break;

                case ModelContextTypeCode.Value:
                    templateName = Resources.DisplayValues.NodeName_Templates_Value;
                    break;

                case ModelContextTypeCode.ObjectInstance:
                    templateName = Resources.DisplayValues.NodeName_Templates_ObjectInstance;
                    break;

                case ModelContextTypeCode.PropertyInstance:
                    templateName = Resources.DisplayValues.NodeName_Templates_PropertyInstance;
                    break;

                default:
                    templateName = Resources.DisplayValues.NodeName_CodeTemplates;
                    break;
                }
                if (modelContextTypeEnum == ModelContextTypeCode.Solution)
                {
                    if (String.IsNullOrEmpty(template.CodeTemplate.CategoryName))
                    {
                        Items.Add(template);
                        template.Updated += new EventHandler(Children_Updated);
                        if (refresh == true)
                        {
                            Items.Sort("Name", SortDirection.Ascending);
                        }
                    }
                    else
                    {
                        bool foundCategory = false;
                        foreach (CodeTemplatesViewModel folder in Items.OfType <CodeTemplatesViewModel>())
                        {
                            if (folder.Name == template.CodeTemplate.CategoryName)
                            {
                                folder.AddTemplate(template, refresh);
                                foundCategory = true;
                            }
                        }
                        if (foundCategory == false)
                        {
                            CodeTemplatesViewModel folder = new CodeTemplatesViewModel(Solution, ModelContextTypeCode.None.ToString());
                            folder.Name = template.CodeTemplate.CategoryName;
                            folder.AddTemplate(template);
                            Items.Add(folder);
                            folder.Updated += new EventHandler(Children_Updated);
                            if (refresh == true)
                            {
                                Items.Sort("Name", SortDirection.Ascending);
                            }
                        }
                    }
                }
                else
                {
                    bool foundFolder = false;
                    foreach (CodeTemplatesViewModel folder in Items.OfType <CodeTemplatesViewModel>())
                    {
                        if (folder.Name == templateName)
                        {
                            folder.AddTemplate(template, refresh);
                            foundFolder = true;
                        }
                    }
                    if (foundFolder == false)
                    {
                        CodeTemplatesViewModel folder = new CodeTemplatesViewModel(Solution, modelContextTypeEnum.ToString());
                        folder.Name = templateName;
                        folder.AddTemplate(template);
                        Items.Add(folder);
                        folder.Updated += new EventHandler(Children_Updated);
                        if (refresh == true)
                        {
                            Items.Sort("Name", SortDirection.Ascending);
                        }
                    }
                }
                break;

            default:
                if (String.IsNullOrEmpty(template.CodeTemplate.CategoryName) || template.CodeTemplate.CategoryName == Name)
                {
                    Items.Add(template);
                    template.Updated += new EventHandler(Children_Updated);
                    if (refresh == true)
                    {
                        Items.Sort("Name", SortDirection.Ascending);
                    }
                }
                else
                {
                    bool foundCategory = false;
                    foreach (CodeTemplatesViewModel folder in Items.OfType <CodeTemplatesViewModel>())
                    {
                        if (folder.Name == template.CodeTemplate.CategoryName)
                        {
                            folder.AddTemplate(template, refresh);
                            foundCategory = true;
                        }
                    }
                    if (foundCategory == false)
                    {
                        CodeTemplatesViewModel folder = new CodeTemplatesViewModel(Solution, modelContextTypeEnum.ToString());
                        folder.Name = template.CodeTemplate.CategoryName;
                        folder.AddTemplate(template);
                        Items.Add(folder);
                        folder.Updated += new EventHandler(Children_Updated);
                        if (refresh == true)
                        {
                            Items.Sort("Name", SortDirection.Ascending);
                        }
                    }
                }
                break;
            }
        }
Exemple #7
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method deletes an instance of CodeTemplate from the view model.</summary>
 ///
 /// <param name="itemView">The CodeTemplate to delete.</param>
 ///--------------------------------------------------------------------------------
 public void DeleteCodeTemplate(CodeTemplateViewModel itemView)
 {
     itemView.Updated -= Children_Updated;
     CodeTemplates.Remove(itemView);
     Delete(itemView);
 }
Exemple #8
0
 ///--------------------------------------------------------------------------------
 /// <summary>This method adds an instance of CodeTemplate to the view model.</summary>
 ///
 /// <param name="itemView">The CodeTemplate to add.</param>
 ///--------------------------------------------------------------------------------
 public void AddCodeTemplate(CodeTemplateViewModel itemView)
 {
     itemView.Updated += new EventHandler(Children_Updated);
     CodeTemplates.Add(itemView);
     Add(itemView);
 }