private ObservableCollection <CrmSolution> HandleMappings(ObservableCollection <CrmSolution> sItems)
        {
            try
            {
                string  projectName = ConnPane.SelectedProject.Name;
                Project project     = GetProjectByName(projectName);
                if (project == null)
                {
                    return(new ObservableCollection <CrmSolution>());
                }

                var path = Path.GetDirectoryName(project.FullName);
                if (!SharedConfigFile.ConfigFileExists(project))
                {
                    _logger.WriteToOutputWindow("Error Updating Mapping In Config File: Missing CRMDeveloperExtensions.config File", Logger.MessageType.Error);
                    return(new ObservableCollection <CrmSolution>());
                }

                XmlDocument doc = new XmlDocument();
                doc.Load(path + "\\CRMDeveloperExtensions.config");

                List <string> projectNames = new List <string>();
                foreach (Project p in ConnPane.Projects)
                {
                    projectNames.Add(p.Name.ToUpper());
                }

                XmlNodeList    solutionNodes = doc.GetElementsByTagName("Solution");
                List <XmlNode> nodesToRemove = new List <XmlNode>();

                foreach (CrmSolution sItem in sItems)
                {
                    foreach (XmlNode solutionNode in solutionNodes)
                    {
                        XmlNode orgIdNode = solutionNode["OrgId"];
                        if (orgIdNode == null)
                        {
                            continue;
                        }
                        if (orgIdNode.InnerText.ToUpper() != ConnPane.SelectedConnection.OrgId.ToUpper())
                        {
                            continue;
                        }

                        XmlNode solutionId = solutionNode["SolutionId"];
                        if (solutionId == null)
                        {
                            continue;
                        }
                        if (solutionId.InnerText.ToUpper() != sItem.SolutionId.ToString().ToUpper())
                        {
                            continue;
                        }

                        XmlNode projectNameNode = solutionNode["ProjectName"];
                        if (projectNameNode == null)
                        {
                            continue;
                        }

                        if (!projectNames.Contains(projectNameNode.InnerText.ToUpper()))
                        {
                            //Remove mappings for projects that might have been deleted from the solution
                            nodesToRemove.Add(projectNameNode);
                        }
                        else
                        {
                            sItem.BoundProject = projectNameNode.InnerText;
                        }

                        XmlNode downloadManagedNode = solutionNode["DownloadManaged"];
                        bool    downloadManaged     = false;
                        bool    hasDownloadManaged  = downloadManagedNode != null && bool.TryParse(downloadManagedNode.InnerText, out downloadManaged);
                        sItem.DownloadManagedSolution = hasDownloadManaged && downloadManaged;
                    }
                }

                //Remove mappings for solutions that might have been deleted from CRM
                solutionNodes = doc.GetElementsByTagName("Solution");
                foreach (XmlNode solution in solutionNodes)
                {
                    XmlNode orgIdNode = solution["OrgId"];
                    if (orgIdNode == null)
                    {
                        continue;
                    }
                    if (orgIdNode.InnerText.ToUpper() != ConnPane.SelectedConnection.OrgId.ToUpper())
                    {
                        continue;
                    }

                    XmlNode solutionId = solution["SolutionId"];
                    if (solutionId == null)
                    {
                        continue;
                    }

                    var count = sItems.Count(s => s.SolutionId.ToString().ToUpper() == solutionId.InnerText.ToUpper());
                    if (count == 0)
                    {
                        nodesToRemove.Add(solution);
                    }
                }

                //Remove the invalid mappings
                if (nodesToRemove.Count <= 0)
                {
                    return(sItems);
                }

                XmlNode projects = nodesToRemove[0].ParentNode;
                foreach (XmlNode xmlNode in nodesToRemove)
                {
                    if (projects != null && projects.ParentNode != null)
                    {
                        projects.RemoveChild(xmlNode);
                    }
                }

                if (SharedConfigFile.IsConfigReadOnly(path + "\\CRMDeveloperExtensions.config"))
                {
                    FileInfo file = new FileInfo(path + "\\CRMDeveloperExtensions.config")
                    {
                        IsReadOnly = false
                    };
                }

                doc.Save(path + "\\CRMDeveloperExtensions.config");
            }
            catch (Exception ex)
            {
                _logger.WriteToOutputWindow("Error Updating Mappings In Config File: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
            }

            return(sItems);
        }
Ejemplo n.º 2
0
        private ObservableCollection <AssemblyItem> HandleMappings(ObservableCollection <AssemblyItem> aItems)
        {
            try
            {
                string  projectName = ConnPane.SelectedProject.Name;
                Project project     = GetProjectByName(projectName);
                if (project == null)
                {
                    return(new ObservableCollection <AssemblyItem>());
                }

                var path = Path.GetDirectoryName(project.FullName);
                if (!SharedConfigFile.ConfigFileExists(project))
                {
                    _logger.WriteToOutputWindow("Error Updating Mapping In Config File: Missing CRMDeveloperExtensions.config File", Logger.MessageType.Error);
                    return(new ObservableCollection <AssemblyItem>());
                }

                XmlDocument doc = new XmlDocument();
                doc.Load(path + "\\CRMDeveloperExtensions.config");

                List <string> projectNames = new List <string>();
                foreach (Project p in ConnPane.Projects)
                {
                    projectNames.Add(p.Name.ToUpper());
                }

                XmlNodeList    assemblyNodes = doc.GetElementsByTagName("Assembly");
                List <XmlNode> nodesToRemove = new List <XmlNode>();

                foreach (AssemblyItem aItem in aItems)
                {
                    foreach (XmlNode assemblyNode in assemblyNodes)
                    {
                        XmlNode orgIdNode = assemblyNode["OrgId"];
                        if (orgIdNode == null)
                        {
                            continue;
                        }
                        if (orgIdNode.InnerText.ToUpper() != ConnPane.SelectedConnection.OrgId.ToUpper())
                        {
                            continue;
                        }

                        XmlNode assemblyId = assemblyNode["AssemblyId"];
                        if (assemblyId == null)
                        {
                            continue;
                        }
                        if (assemblyId.InnerText.ToUpper() != aItem.AssemblyId.ToString().ToUpper())
                        {
                            continue;
                        }

                        XmlNode projectNameNode = assemblyNode["ProjectName"];
                        if (projectNameNode == null)
                        {
                            continue;
                        }

                        if (!projectNames.Contains(projectNameNode.InnerText.ToUpper()))
                        {
                            //Remove mappings for projects that might have been deleted from the solution
                            nodesToRemove.Add(projectNameNode);
                        }
                        else
                        {
                            aItem.BoundProject = projectNameNode.InnerText;
                        }
                    }
                }

                //Remove mappings for assemblies that might have been deleted from CRM
                assemblyNodes = doc.GetElementsByTagName("Assembly");
                foreach (XmlNode assembly in assemblyNodes)
                {
                    XmlNode orgIdNode = assembly["OrgId"];
                    if (orgIdNode == null)
                    {
                        continue;
                    }
                    if (orgIdNode.InnerText.ToUpper() != ConnPane.SelectedConnection.OrgId.ToUpper())
                    {
                        continue;
                    }

                    XmlNode assemblyId = assembly["AssemblyId"];
                    if (assemblyId == null)
                    {
                        continue;
                    }

                    var count = aItems.Count(a => a.AssemblyId.ToString().ToUpper() == assemblyId.InnerText.ToUpper());
                    if (count == 0)
                    {
                        nodesToRemove.Add(assembly);
                    }
                }

                //Remove the invalid mappings
                if (nodesToRemove.Count <= 0)
                {
                    return(aItems);
                }

                XmlNode projects = nodesToRemove[0].ParentNode;
                foreach (XmlNode xmlNode in nodesToRemove)
                {
                    if (projects != null && projects.ParentNode != null)
                    {
                        projects.RemoveChild(xmlNode);
                    }
                }

                if (SharedConfigFile.IsConfigReadOnly(path + "\\CRMDeveloperExtensions.config"))
                {
                    FileInfo file = new FileInfo(path + "\\CRMDeveloperExtensions.config")
                    {
                        IsReadOnly = false
                    };
                }

                doc.Save(path + "\\CRMDeveloperExtensions.config");
            }
            catch (Exception ex)
            {
                _logger.WriteToOutputWindow("Error Updating Mappings In Config File: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
            }

            return(aItems);
        }
        private void AddOrUpdateMapping(CrmSolution solution)
        {
            try
            {
                var path = Path.GetDirectoryName(ConnPane.SelectedProject.FullName);
                if (!SharedConfigFile.ConfigFileExists(ConnPane.SelectedProject))
                {
                    _logger.WriteToOutputWindow("Error Updating Mappings In Config File: Missing CRMDeveloperExtensions.config File", Logger.MessageType.Error);
                    return;
                }

                XmlDocument doc = new XmlDocument();
                doc.Load(path + "\\CRMDeveloperExtensions.config");

                //Update or delete existing mapping
                XmlNodeList solutionNodes = doc.GetElementsByTagName("Solution");
                if (solutionNodes.Count > 0)
                {
                    foreach (XmlNode node in solutionNodes)
                    {
                        bool    changed = false;
                        XmlNode orgId   = node["OrgId"];
                        if (orgId != null && orgId.InnerText.ToUpper() != ConnPane.SelectedConnection.OrgId.ToUpper())
                        {
                            continue;
                        }

                        XmlNode projectNameNode = node["ProjectName"];
                        if (projectNameNode != null && projectNameNode.InnerText.ToUpper() != solution.BoundProject.ToUpper())
                        {
                            continue;
                        }

                        if (string.IsNullOrEmpty(solution.BoundProject) || solution.SolutionId == Guid.Empty)
                        {
                            //Delete
                            var parentNode = node.ParentNode;
                            if (parentNode != null)
                            {
                                parentNode.RemoveChild(node);
                                changed = true;
                            }
                        }
                        else
                        {
                            //Update
                            XmlNode solutionIdNode = node["SolutionId"];
                            if (solutionIdNode != null)
                            {
                                string oldSolutionId = solutionIdNode.InnerText;
                                if (oldSolutionId != solution.SolutionId.ToString())
                                {
                                    solutionIdNode.InnerText = solution.SolutionId.ToString();
                                    changed = true;
                                }
                            }
                            XmlNode downloadManagedNode = node["DownloadManaged"];
                            if (downloadManagedNode != null)
                            {
                                string oldDownloadManaged   = downloadManagedNode.InnerText;
                                string downloadManagedValue = (solution.DownloadManagedSolution) ? "true" : "false";
                                if (oldDownloadManaged != downloadManagedValue)
                                {
                                    downloadManagedNode.InnerText = downloadManagedValue;
                                    changed = true;
                                }
                            }
                        }

                        if (!changed)
                        {
                            return;
                        }

                        if (SharedConfigFile.IsConfigReadOnly(path + "\\CRMDeveloperExtensions.config"))
                        {
                            FileInfo file = new FileInfo(path + "\\CRMDeveloperExtensions.config")
                            {
                                IsReadOnly = false
                            };
                        }

                        doc.Save(path + "\\CRMDeveloperExtensions.config");
                        return;
                    }
                }

                //Create new mapping
                XmlNodeList projects = doc.GetElementsByTagName("Solutions");
                if (projects.Count <= 0)
                {
                    return;
                }

                XmlNode solutionNode = doc.CreateElement("Solution");
                XmlNode org          = doc.CreateElement("OrgId");
                org.InnerText = ConnPane.SelectedConnection.OrgId;
                solutionNode.AppendChild(org);
                XmlNode projectNameNode2 = doc.CreateElement("ProjectName");
                projectNameNode2.InnerText = solution.BoundProject;
                solutionNode.AppendChild(projectNameNode2);
                XmlNode solutionId = doc.CreateElement("SolutionId");
                solutionId.InnerText = solution.SolutionId.ToString();
                solutionNode.AppendChild(solutionId);
                XmlNode downloadManaged = doc.CreateElement("DownloadManaged");
                downloadManaged.InnerText = (DownloadManaged.IsChecked == true) ? "true" : "false";
                solutionNode.AppendChild(downloadManaged);
                projects[0].AppendChild(solutionNode);

                if (SharedConfigFile.IsConfigReadOnly(path + "\\CRMDeveloperExtensions.config"))
                {
                    FileInfo file = new FileInfo(path + "\\CRMDeveloperExtensions.config")
                    {
                        IsReadOnly = false
                    };
                }

                doc.Save(path + "\\CRMDeveloperExtensions.config");
            }
            catch (Exception ex)
            {
                _logger.WriteToOutputWindow("Error Updating Mappings In Config File: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
            }
        }
Ejemplo n.º 4
0
        private Guid GetMapping(ProjectItem projectItem, CrmConn selectedConnection)
        {
            try
            {
                Project project     = projectItem.ContainingProject;
                var     projectPath = Path.GetDirectoryName(project.FullName);
                if (projectPath == null)
                {
                    return(Guid.Empty);
                }
                var boundName = projectItem.FileNames[1].Replace(projectPath, String.Empty).Replace("\\", "/");

                if (!File.Exists(projectItem.FileNames[1]))
                {
                    return(Guid.Empty);
                }

                var path = Path.GetDirectoryName(project.FullName);
                if (!SharedConfigFile.ConfigFileExists(project))
                {
                    _logger.WriteToOutputWindow("Error Getting Mapping: Missing CRMDeveloperExtensions.config File", Logger.MessageType.Error);
                    return(Guid.Empty);
                }

                XmlDocument doc = new XmlDocument();
                doc.Load(path + "\\CRMDeveloperExtensions.config");

                if (string.IsNullOrEmpty(selectedConnection.ConnectionString))
                {
                    return(Guid.Empty);
                }
                if (string.IsNullOrEmpty(selectedConnection.OrgId))
                {
                    return(Guid.Empty);
                }

                var  props        = _dte.Properties["CRM Developer Extensions", "Web Resource Deployer"];
                bool allowPublish = (bool)props.Item("AllowPublishManagedWebResources").Value;

                //Get the mapped file info
                XmlNodeList mappedFiles = doc.GetElementsByTagName("File");
                foreach (XmlNode file in mappedFiles)
                {
                    XmlNode orgIdNode = file["OrgId"];
                    if (orgIdNode == null)
                    {
                        continue;
                    }
                    if (orgIdNode.InnerText.ToUpper() != selectedConnection.OrgId.ToUpper())
                    {
                        continue;
                    }

                    XmlNode pathNode = file["Path"];
                    if (pathNode == null)
                    {
                        continue;
                    }
                    if (pathNode.InnerText.ToUpper() != boundName.ToUpper())
                    {
                        continue;
                    }

                    XmlNode isManagedNode = file["IsManaged"];
                    if (isManagedNode == null)
                    {
                        continue;
                    }

                    bool isManaged;
                    bool isBool = Boolean.TryParse(isManagedNode.InnerText, out isManaged);
                    if (!isBool)
                    {
                        continue;
                    }
                    if (isManaged && !allowPublish)
                    {
                        return(Guid.Empty);
                    }

                    XmlNode webResourceIdNode = file["WebResourceId"];
                    if (webResourceIdNode == null)
                    {
                        return(Guid.Empty);
                    }

                    Guid webResourceId;
                    bool isGuid = Guid.TryParse(webResourceIdNode.InnerText, out webResourceId);
                    if (!isGuid)
                    {
                        return(Guid.Empty);
                    }

                    return(webResourceId);
                }

                return(Guid.Empty);
            }
            catch (Exception ex)
            {
                _logger.WriteToOutputWindow("Error Getting Mapping: " + ex.Message + Environment.NewLine + ex.StackTrace, Logger.MessageType.Error);
                return(Guid.Empty);
            }
        }