SharePoint Automation Gary Lapointe – Founding Partner, Aptillon, Inc.

   1: public override int Run(string command, System.Collections.Specialized.StringDictionary keyValues, out string output)

   2: {

   3:  output = string.Empty;

   4:  

   5:  InitParameters(keyValues);

   6:  

   7:  string url = Params["url"].Value.TrimEnd('/');

   8:  

   9:  using (SPSite site = new SPSite(url))

  10:  {

  11:   using (SPWeb web = site.AllWebs[Utilities.GetServerRelUrlFromFullUrl(url)])

  12:   {

  13:    PublishingWeb pubweb = PublishingWeb.GetPublishingWeb(web);

  14:  

  15:    if (Params["showsubsites"].UserTypedIn)

  16:     pubweb.IncludeSubSitesInNavigation = bool.Parse(Params["showsubsites"].Value);

  17:  

  18:    if (Params["showpages"].UserTypedIn)

  19:     pubweb.IncludePagesInNavigation = bool.Parse(Params["showpages"].Value);

  20:  

  21:    OrderingMethod sortMethod = pubweb.NavigationOrderingMethod;

  22:    if (Params["sortmethod"].UserTypedIn)

  23:    {

  24:     sortMethod = (OrderingMethod)Enum.Parse(typeof (OrderingMethod), Params["sortmethod"].Value, true);

  25:     pubweb.NavigationOrderingMethod = sortMethod;

  26:    }

  27:  

  28:    if (sortMethod != OrderingMethod.Manual)

  29:    {

  30:     if (Params["autosortmethod"].UserTypedIn)

  31:      pubweb.NavigationAutomaticSortingMethod = (AutomaticSortingMethod)Enum.Parse(typeof(AutomaticSortingMethod), Params["autosortmethod"].Value, true);

  32:     if (Params["sortascending"].UserTypedIn)

  33:      pubweb.NavigationSortAscending = bool.Parse(Params["sortascending"].Value);

  34:    }

  35:    else

  36:    {

  37:     if (Params["autosortmethod"].UserTypedIn)

  38:      Console.WriteLine("WARNING: parameter autosortmethod is incompatible with sortmethod {0}.  The parameter will be ignored.", sortMethod);

  39:     if (Params["sortascending"].UserTypedIn)

  40:      Console.WriteLine("WARNING: parameter sortascending is incompatible with sortmethod {0}.  The parameter will be ignored.", sortMethod);

  41:    }

  42:  

  43:    if (Params["inheritglobalnav"].UserTypedIn)

  44:     pubweb.InheritGlobalNavigation = bool.Parse(Params["inheritglobalnav"].Value);

  45:  

  46:    if (Params["currentnav"].UserTypedIn)

  47:    {

  48:     CurrentNavSettingsEnum currentNav = (CurrentNavSettingsEnum)Enum.Parse(typeof (CurrentNavSettingsEnum), Params["currentnav"].Value, true);

  49:     if (currentNav == CurrentNavSettingsEnum.InheritParent)

  50:     {

  51:      pubweb.InheritCurrentNavigation = true;

  52:      pubweb.NavigationShowSiblings = false;

  53:     }

  54:     else if (currentNav == CurrentNavSettingsEnum.CurrentSiteAndSiblings)

  55:     {

  56:      pubweb.InheritCurrentNavigation = true;

  57:      pubweb.NavigationShowSiblings = true;

  58:     }

  59:     else if (currentNav == CurrentNavSettingsEnum.CurrentSiteOnly)

  60:     {

  61:      pubweb.InheritCurrentNavigation = false;

  62:      pubweb.NavigationShowSiblings = false;

  63:     }

  64:    }

  65:  

  66:    pubweb.Update();

  67:   }

  68:  }

  69:  

  70:  return 1;

  71: }

  72:  

  73: internal enum CurrentNavSettingsEnum

  74: {

  75:  InheritParent,

  76:  CurrentSiteAndSiblings,

  77:  CurrentSiteOnly

  78: }

   1: /// <summary>

   2: /// Sets the navigation.

   3: /// </summary>

   4: /// <param name="web">The web site.</param>

   5: /// <param name="xmlDoc">The XML doc containing the navigation nodes.</param>

   6: /// <param name="showSubSites">if set to <c>true</c> [show sub sites].</param>

   7: /// <param name="showPages">if set to <c>true</c> [show pages].</param>

   8: /// <param name="deleteExistingGlobal">if set to <c>true</c> [delete existing global nodes].</param>

   9: /// <param name="deleteExistingCurrent">if set to <c>true</c> [delete existing current nodes].</param>

  10: public static void SetNavigation(SPWeb web, XmlDocument xmlDoc, bool showSubSites, bool showPages, bool deleteExistingGlobal, bool deleteExistingCurrent)

  11: {

  12:     PublishingWeb pubweb = PublishingWeb.GetPublishingWeb(web);

  13:  

  14:     // First need to set whether or not we show sub-sites and pages

  15:     pubweb.IncludeSubSitesInNavigation = showSubSites;

  16:     pubweb.IncludePagesInNavigation = showPages;

  17:     pubweb.Update();

  18:  

  19:     List<SPNavigationNode> existingGlobalNodes = new List<SPNavigationNode>();

  20:     List<SPNavigationNode> existingCurrentNodes = new List<SPNavigationNode>();

  21:     // We can't delete the navigation items until we've added the new ones so store the existing 

  22:     // ones for later deletion (note that we don't have to store all of them - just the top level).

  23:     // I have no idea why this is the case - but when I tried to clear everything out first I got

  24:     // all kinds of funky errors that just made no sense to me - this works so....

  25:     foreach (SPNavigationNode node in pubweb.GlobalNavigationNodes)

  26:         existingGlobalNodes.Add(node);

  27:     foreach (SPNavigationNode node in pubweb.CurrentNavigationNodes)

  28:         existingCurrentNodes.Add(node);

  29:  

  30:     XmlNodeList newGlobalNodes = xmlDoc.SelectNodes("//Navigation/Global/Node");

  31:     XmlNodeList newCurrentNodes = xmlDoc.SelectNodes("//Navigation/Current/Node");

  32:  

  33:  

  34:     // If we've got global or current nodes in the xml then the intent is to reset those elements.

  35:     // If we've also specified to delete any existing elements then we need to first hide all the

  36:     // sub-sites and pages (you can't delete them because they don't exist as a node).  Note that

  37:     // we are only doing this if showSubSites is true - if it's false we don't see them so no point

  38:     // in hiding them.  Any non-sub-site or non-page will be deleted after we've added the new nodes.

  39:     if (newGlobalNodes.Count > 0 && deleteExistingGlobal && showSubSites)

  40:     {

  41:         // Initialize the sub-sites (forces the provided XML to specify whether any should be visible)

  42:         foreach (SPWeb tempWeb in pubweb.Web.Webs)

  43:         {

  44:             pubweb.ExcludeFromNavigation(true, tempWeb.ID);

  45:         }

  46:         pubweb.Update();

  47:     }

  48:     if (newCurrentNodes.Count > 0 && deleteExistingCurrent && showSubSites)

  49:     {

  50:         foreach (SPWeb tempWeb in pubweb.Web.Webs)

  51:         {

  52:             pubweb.ExcludeFromNavigation(false, tempWeb.ID);

  53:         }

  54:         pubweb.Update();

  55:     }

  56:  

  57:     // Now we need to add all the global nodes (if any - if the collection is empty the following will just return and do nothing)

  58:     AddNodes(pubweb, true, pubweb.GlobalNavigationNodes, newGlobalNodes);

  59:     // Update the web as the above may have made modifications

  60:     pubweb.Update();

  61:  

  62:     // Now delete all the previously existing global nodes.

  63:     if (newGlobalNodes.Count > 0 && deleteExistingGlobal)

  64:     {

  65:         foreach (SPNavigationNode node in existingGlobalNodes)

  66:         {

  67:             node.Delete();

  68:         }

  69:     }

  70:  

  71:     // Now we need to add all the current nodes (if any)

  72:     AddNodes(pubweb, false, pubweb.CurrentNavigationNodes, newCurrentNodes);

  73:     // Update the web as the above may have made modifications

  74:     pubweb.Update();

  75:  

  76:     // Now delete all the previously existing current nodes.

  77:     if (newCurrentNodes.Count > 0 && deleteExistingCurrent)

  78:     {

  79:         foreach (SPNavigationNode node in existingCurrentNodes)

  80:         {

  81:             node.Delete();

  82:         }

  83:     }

  84: }

  85:  

  86:  

  87: /// <summary>

  88: /// Adds the nodes.

  89: /// </summary>

  90: /// <param name="pubWeb">The publishing web.</param>

  91: /// <param name="isGlobal">if set to <c>true</c> [is global].</param>

  92: /// <param name="existingNodes">The existing nodes.</param>

  93: /// <param name="newNodes">The new nodes.</param>

  94: private static void AddNodes(PublishingWeb pubWeb, bool isGlobal, SPNavigationNodeCollection existingNodes, XmlNodeList newNodes)

  95: {

  96:     if (newNodes.Count == 0)

  97:         return;

  98:  

  99:     for (int i = 0; i < newNodes.Count; i++)

 100:     {

 101:         XmlElement newNodeXml = (XmlElement)newNodes[i];

 102:         string url = newNodeXml.SelectSingleNode("Url").InnerText;

 103:         string title = newNodeXml.GetAttribute("Title");

 104:         NodeTypes type = NodeTypes.None;

 105:         if (newNodeXml.SelectSingleNode("NodeType") != null && !string.IsNullOrEmpty(newNodeXml.SelectSingleNode("NodeType").InnerText))

 106:             type = (NodeTypes)Enum.Parse(typeof(NodeTypes), newNodeXml.SelectSingleNode("NodeType").InnerText);

 107:  

 108:         bool isVisible = true;

 109:         if (!string.IsNullOrEmpty(newNodeXml.GetAttribute("IsVisible")))

 110:             isVisible = bool.Parse(newNodeXml.GetAttribute("IsVisible"));

 111:  

 112:         if (type == NodeTypes.Area)

 113:         {

 114:             // You can't just add an "Area" node (which represents a sub-site) to the current web if the

 115:             // url does not correspond with an actual sub-site (the code will appear to work but you won't

 116:             // see anything when you load the page).  So we need to check and see if the node actually

 117:             // points to a sub-site - if it does not then change it to "AuthoredLinkToWeb".

 118:             SPWeb web = null;

 119:             string name = url.Trim('/');

 120:             if (name.Length != 0 && name.IndexOf("/") > 0)

 121:             {

 122:                 name = name.Substring(name.LastIndexOf('/') + 1);

 123:             }

 124:             try

 125:             {

 126:                 // Note that pubWeb.Web.Webs[] does not return null if the item doesn't exist - it simply throws an exception (I hate that!)

 127:                 web = pubWeb.Web.Webs[name];

 128:             }

 129:             catch (ArgumentException)

 130:             {

 131:             }

 132:             if (web == null || !web.Exists || web.ServerRelativeUrl.ToLower() != url.ToLower())

 133:             {

 134:                 // The url doesn't correspond with a sub-site for the current web so change the node type.

 135:                 // This is most likely due to copying navigation elements from another site

 136:                 type = NodeTypes.AuthoredLinkToWeb;

 137:             }

 138:             else if (web.Exists && web.ServerRelativeUrl.ToLower() == url.ToLower())

 139:             {

 140:                 // We did find a matching sub-site so now we need to set the visibility

 141:                 if (isVisible)

 142:                     pubWeb.IncludeInNavigation(isGlobal, web.ID);

 143:                 else

 144:                     pubWeb.ExcludeFromNavigation(isGlobal, web.ID);

 145:             }

 146:  

 147:         }

 148:         else if (type == NodeTypes.Page)

 149:         {

 150:             // Adding links to pages has the same limitation as sub-sites (Area nodes) so we need to make

 151:             // sure it actually exists and if it doesn't then change the node type.

 152:             PublishingPage page = null;

 153:             try

 154:             {

 155:                 // Note that GetPublishingPages()[] does not return null if the item doesn't exist - it simply throws an exception (I hate that!)

 156:                 page = pubWeb.GetPublishingPages()[url];

 157:             }

 158:             catch (ArgumentException)

 159:             {

 160:             }

 161:             if (page == null)

 162:             {

 163:                 // The url doesn't correspond with a page for the current web so change the node type.

 164:                 // This is most likely due to copying navigation elements from another site

 165:                 type = NodeTypes.AuthoredLinkToPage;

 166:                 url = pubWeb.Web.Site.MakeFullUrl(url);

 167:             }

 168:             else

 169:             {

 170:                 // We did find a matching page so now we need to set the visibility

 171:                 if (isVisible)

 172:                     pubWeb.IncludeInNavigation(isGlobal, page.ListItem.UniqueId);

 173:                 else

 174:                     pubWeb.ExcludeFromNavigation(isGlobal, page.ListItem.UniqueId);

 175:             }

 176:         }

 177:  

 178:         // If it's not a sub-site or a page that's part of the current web and it's set to

 179:         // not be visible then just move on to the next (there is no visibility setting for

 180:         // nodes that are not of type Area or Page).

 181:         if (!isVisible && type != NodeTypes.Area && type != NodeTypes.Page)

 182:             continue;

 183:  

 184:         // Finally, can add the node to the collection.

 185:         SPNavigationNode node = SPNavigationSiteMapNode.CreateSPNavigationNode(

 186:             title, url, type, existingNodes);

 187:  

 188:        

 189:         // Now we need to set all the other properties

 190:         foreach (XmlElement property in newNodeXml.ChildNodes)

 191:         {

 192:             // We've already set these so don't set them again.

 193:             if (property.Name == "Url" || property.Name == "Node" || property.Name == "NodeType")

 194:                 continue;

 195:  

 196:             // CreatedDate and LastModifiedDate need to be the correct type - all other properties are strings

 197:             if (property.Name == "CreatedDate" && !string.IsNullOrEmpty(property.InnerText))

 198:             {

 199:                 node.Properties["CreatedDate"] = DateTime.Parse(property.InnerText);

 200:                 continue;

 201:             }

 202:             if (property.Name == "LastModifiedDate" && !string.IsNullOrEmpty(property.InnerText))

 203:             {

 204:                 node.Properties["LastModifiedDate"] = DateTime.Parse(property.InnerText);

 205:                 continue;

 206:             }

 207:  

 208:             node.Properties[property.Name] = property.InnerText;

 209:         }

 210:         // If we didn't have a CreatedDate or LastModifiedDate then set them to now.

 211:         if (node.Properties["CreatedDate"] == null)

 212:             node.Properties["CreatedDate"] = DateTime.Now;

 213:         if (node.Properties["LastModifiedDate"] == null)

 214:             node.Properties["LastModifiedDate"] = DateTime.Now;

 215:  

 216:         // Save our changes to the node.

 217:         node.Update();

 218:         node.MoveToLast(existingNodes); // Should already be at the end but I prefer to make sure  

 219:         

 220:         XmlNodeList childNodes = newNodeXml.SelectNodes("Node");

 221:  

 222:         // If we have child nodes then make a recursive call passing in the current nodes Children property as the collection to add to.

 223:         if (childNodes.Count > 0)

 224:             AddNodes(pubWeb, isGlobal, node.Children, childNodes);

 225:     }

 226: }

   1: <Node Title="Sub Sites" IsVisible="True">

   2:   <Url>/</Url>

   3:   <UrlFragment></UrlFragment>

   4:   <vti_navsequencechild>true</vti_navsequencechild>

   5:   <CreatedDate>10/15/2007 6:28:01 PM</CreatedDate>

   6:   <UrlQueryString></UrlQueryString>

   7:   <NodeType>Heading</NodeType>

   8:   <Audience></Audience>

   9:   <Target></Target>

  10:   <Description></Description>

  11:   <LastModifiedDate>10/15/2007 6:28:01 PM</LastModifiedDate>

  12:   <BlankUrl>True</BlankUrl>

  13:   <AutoAddSubSites />

  14: </Node>

   1: XmlDocument xmlDoc;

   2: // Get the XML from our source site.

   3: using (SPSite sourceSite = new SPSite(sourceurl))

   4: using (SPWeb sourceWeb = sourceSite.OpenWeb())

   5: {

   6:     PublishingWeb sourcePubWeb = PublishingWeb.GetPublishingWeb(sourceWeb);

   7:     xmlDoc = EnumNavigation.GetNavigationAsXml(sourcePubWeb);

   8: }

   9:  

  10: // If the user only wants to copy the global or current then remove the other element

  11: if (currentOnly)

  12:     xmlDoc.SelectSingleNode("//Navigation/Global").RemoveAll();

  13: if (globalOnly)

  14:     xmlDoc.SelectSingleNode("//Navigation/Current").RemoveAll();

  15:  

  16: // Set the navigation using the XML we got from the source.

  17: using (SPSite targetSite = new SPSite(targeturl))

  18: using (SPWeb targetWeb = targetSite.OpenWeb())

  19: {

  20:     if (keyValues.ContainsKey("backuptarget"))

  21:     {

  22:         PublishingWeb targetPubWeb = PublishingWeb.GetPublishingWeb(targetWeb);

  23:         XmlDocument xmlBackupDoc = EnumNavigation.GetNavigationAsXml(targetPubWeb);

  24:         xmlBackupDoc.Save(keyValues["backuptarget"]);

  25:     }

  26:     SetNavigationNodes.SetNavigation(targetWeb, xmlDoc, showSubSites, showPages, deleteExistingGlobal, deleteExistingCurrent);

  27: }