The following class can import/export entire sharepoint site structure, page library folder, content types to XML. Format like
<?xml version="1.0" encoding="UTF-8"?>
<Root>
<Web>
<SiteUrl>en-ca/PPM</SiteUrl>
<SiteTitle>PPM</SiteTitle>
<SiteDescription>
</SiteDescription>
<Pages>
<Folders>
<Folder>Folder1</Folder>
<Folder>Folder2</Folder>
</Folders>
</Pages>
</Web>
<Web>
<SiteUrl>en-ca/tetsdasdfs</SiteUrl>
<SiteTitle>ddd</SiteTitle>
<SiteDescription>
</SiteDescription>
<Pages>
<ContentTypes>
<ContentType>Page</ContentType>
<ContentType>Article Page</ContentType>
<ContentType>Welcome Page</ContentType>
</ContentTypes>
<Folders>
<Folder>Folder1</Folder>
<Folder>Folder2</Folder>
</Folders>
</Pages>
</Web>
</Root>
When import, it will create each web and create folder to the page library, also, it will try match the content type and assign it to the page library. Class also has a delegate to indicate the progress if necessary.
If you having hundreds of site to create, this might be a good approach. Hope help.
using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
using Microsoft.SharePoint;
using System.Xml;
using System.IO;
using System.Windows;
using System.Threading;
namespace Sharepoint.SetupWizard
{
public delegate void DelegateHandle(object sender, CustomeEvetnArgs e);
public class CustomeEvetnArgs : EventArgs
{
string name = "";
public CustomeEvetnArgs()
{ }
public string SiteName
{
get { return this.name; }
set { this.name = value; }
}
}
class SiteStructure
{
private string _SourceUrl;
private string _ExportPath;
private string _DestinationUrl;
private bool _doSiteStructure;
private bool _doPpmFolder;
private bool _doPageLibraryContentType;
private Hashtable _SitesTable = new Hashtable();
public string SourceUrl
{
get { return _SourceUrl; }
set { _SourceUrl = value; }
}
public string ExportPath
{
get { return _ExportPath; }
set { _ExportPath = value; }
}
public string DestinationUrl
{
get { return _DestinationUrl; }
set { _DestinationUrl = value; }
}
public bool DoSiteStructure
{
get { return _doSiteStructure; }
set { _doSiteStructure = value; }
}
public bool DoPpmFolder
{
get { return _doPpmFolder; }
set { _doPpmFolder = value; }
}
public bool DoPageLibraryContentType
{
get { return _doPageLibraryContentType; }
set { _doPageLibraryContentType = value; }
}
public Hashtable SitesTable
{
get { return _SitesTable; }
set { _SitesTable = value; }
}
public struct SiteInfo
{
internal string _SiteUrl;
internal string _SiteTitle;
internal string _SiteDescription;
internal string[] _PpmFolder;
internal string[] _ContentTypeNames;
internal SPContentTypeCollection _ContentTypes;
}
public SiteInfo[] PpmSiteInfoCollection;
public event DelegateHandle CreateSite;
public PpmSiteStructure(string PpmSourceSitesUrl,string ExportPath)
{
_SourceUrl = PpmSourceSitesUrl;
_ExportPath = ExportPath;
_doSiteStructure = true;
_doPpmFolder = true;
_doPageLibraryContentType = true;
}
public void export()
{
if (_SourceUrl != null)
{
try
{
SPSite PpmSites = new SPSite(this._SourceUrl);
if (PpmSites != null)
{
PpmSiteInfoCollection = new SiteInfo[PpmSites.AllWebs.Count - 1];
for (int i = 0; i < PpmSites.AllWebs.Count - 2; i++)
{
PpmSiteInfoCollection
._SiteUrl = PpmSites.AllWebs[i + 1].Url.Replace(this._SourceUrl + "/", "");
PpmSiteInfoCollection._SiteTitle = PpmSites.AllWebs[i + 1].Title;
PpmSiteInfoCollection._SiteDescription = PpmSites.AllWebs[i + 1].Description;
PpmSiteInfoCollection._PpmFolder = GetPpmFolder(PpmSites.AllWebs[i + 1]);
PpmSiteInfoCollection._ContentTypes = GetPagesLibraryContentTypes(PpmSites.AllWebs[i + 1]);
SitesTable.Add(i, PpmSiteInfoCollection);
}
}
WriteXML();
}
catch (Exception ex)
{
throw (ex);
}
}
}
private string[] GetPpmFolder(SPWeb web)
{
SPDocumentLibrary docLibrary = GetLibraryByName(web.Url.Replace(this._SourceUrl + "/", ""),"Pages");
if (docLibrary != null)
{
int approvedFolderCount = 0;
for (int i = 0; i < docLibrary.Folders.Count; i++)
{
if (docLibrary.Folders["Approval Status"].ToString() == "0")
{
approvedFolderCount++;
}
}
string[] ppmFolderlists = new string[approvedFolderCount];
for (int i = 0; i < docLibrary.Folders.Count ; i++)
{
if (docLibrary.Folders["Approval Status"].ToString() == "0")//only export approved folder
{
ppmFolderlists = docLibrary.Folders.Name;
}
}
return ppmFolderlists;
}
else
return null;
}
private SPContentTypeCollection GetPagesLibraryContentTypes(SPWeb web)
{
SPDocumentLibrary docLibrary = GetLibraryByName(web.Url.Replace(this._SourceUrl + "/", ""), "Pages");
return docLibrary.ContentTypes;
}
private SPDocumentLibrary GetLibraryByName(string siteStr, string libraryName)
{
SPSite ppmSite = new SPSite(this.SourceUrl);
foreach (SPList list in ppmSite.OpenWeb(siteStr).Lists)
{
if (list.BaseType == SPBaseType.DocumentLibrary && list.Title == libraryName)
return (SPDocumentLibrary)list;
}
return null;
}
private void WriteXML()
{
string filename = "PPMSiteStructure" + DateTime.Now.Date.Year.ToString()
+ DateTime.Now.Date.Month.ToString() + DateTime.Now.Date.Day.ToString() + ".xml";
XmlDocument xmlDoc = new XmlDocument();
XmlTextWriter xmlWriter = new XmlTextWriter(this.ExportPath + "\\" + filename, System.Text.Encoding.UTF8);
xmlWriter.Formatting = Formatting.Indented;
xmlWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
xmlWriter.WriteStartElement("Root");
xmlWriter.Close();
xmlDoc.Load(this.ExportPath+"\\"+filename);
for (int i = 0; i < this.SitesTable.Count - 1; i++)
{
XmlNode root = xmlDoc.DocumentElement;
XmlElement webNode = xmlDoc.CreateElement("Web");
XmlElement urlNode = xmlDoc.CreateElement("SiteUrl");
XmlElement titleNode = xmlDoc.CreateElement("SiteTitle");
XmlElement descriptionNode = xmlDoc.CreateElement("SiteDescription");
XmlText textNodeUrl = xmlDoc.CreateTextNode("");
XmlText textNodeTitle = xmlDoc.CreateTextNode("");
XmlText textNodeDescription = xmlDoc.CreateTextNode("");
root.AppendChild(webNode);
webNode.AppendChild(urlNode);
textNodeUrl.Value = ((SiteInfo)SitesTable)._SiteUrl;
urlNode.AppendChild(textNodeUrl);
webNode.AppendChild(titleNode);
textNodeTitle.Value = ((SiteInfo)SitesTable)._SiteTitle;
titleNode.AppendChild(textNodeTitle);
webNode.AppendChild(descriptionNode);
textNodeDescription.Value = ((SiteInfo)SitesTable)._SiteDescription;
descriptionNode.AppendChild(textNodeDescription);
if (DoPpmFolder || DoPageLibraryContentType)
{
XmlElement pagesNode = xmlDoc.CreateElement("Pages");
webNode.AppendChild(pagesNode);
if (DoPpmFolder)
{
if (((SiteInfo)SitesTable)._PpmFolder.Length > 0)
{
XmlElement ppmFolderNode = xmlDoc.CreateElement("Folders");
pagesNode.AppendChild(ppmFolderNode);
for (int j = 0; j < ((SiteInfo)SitesTable)._PpmFolder.Length; j++)
{
XmlElement folderNode = xmlDoc.CreateElement("Folder");
XmlText textNodeFolder = xmlDoc.CreateTextNode("");
textNodeFolder.Value = ((SiteInfo)SitesTable)._PpmFolder[j];
ppmFolderNode.AppendChild(folderNode);
folderNode.AppendChild(textNodeFolder);
}
}
}
if (DoPageLibraryContentType)
{
if (((SiteInfo)SitesTable)._ContentTypes.Count > 0)
{
XmlElement pagesContentTypeNode = xmlDoc.CreateElement("ContentTypes");
pagesNode.AppendChild(pagesContentTypeNode);
for (int j = 0; j < ((SiteInfo)SitesTable)._ContentTypes.Count; j++)
{
XmlElement contentTypeNode = xmlDoc.CreateElement("ContentType");
XmlText textNodeContentType = xmlDoc.CreateTextNode("");
textNodeContentType.Value = ((SiteInfo)SitesTable)._ContentTypes[j].Name;
pagesContentTypeNode.AppendChild(contentTypeNode);
contentTypeNode.AppendChild(textNodeContentType);
}
}
}
}
}
xmlDoc.Save(this.ExportPath + "\\" + filename);
}
private void WriteNode(XmlTextWriter xmlWriter)
{
for (int i = 0; i < this.SitesTable.Count - 1; i++)
{
xmlWriter.WriteStartElement("Web");
xmlWriter.WriteElementString("SiteUrl", ((SiteInfo)SitesTable)._SiteUrl);
xmlWriter.WriteElementString("SiteTitle", ((SiteInfo)SitesTable)._SiteTitle);
xmlWriter.WriteElementString("SiteDescription", ((SiteInfo)SitesTable)._SiteDescription);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndDocument();
}
private void ReadXML(string fileName)
{
this.SitesTable.Clear();
XmlDocument doc = new XmlDocument();
try
{
doc.Load(fileName);
}
catch (FileNotFoundException ex)
{
throw (ex);
}
XmlNodeList webList = doc.GetElementsByTagName("Web");
foreach (XmlNode node in webList)
{
XmlElement webElement = (XmlElement)node;
SiteInfo xmlSiteInfo = new SiteInfo();
xmlSiteInfo._SiteUrl = webElement.GetElementsByTagName("SiteUrl")[0].InnerText;
xmlSiteInfo._SiteTitle = webElement.GetElementsByTagName("SiteTitle")[0].InnerText;
xmlSiteInfo._SiteDescription = webElement.GetElementsByTagName("SiteDescription")[0].InnerText;
XmlNodeList pagesList = webElement.GetElementsByTagName("Pages");
foreach (XmlNode pagesNode in pagesList)
{
//reading Folders
XmlElement foldersElement = (XmlElement)pagesNode;
XmlNodeList foldersList = foldersElement.GetElementsByTagName("Folders");
foreach (XmlNode folder in foldersList)
{
XmlElement folderElement = (XmlElement)folder;
XmlNodeList folderList = folderElement.GetElementsByTagName("Folder");
xmlSiteInfo._PpmFolder = new string[folderList.Count];
for (int i = 0; i < folderList.Count; i++)
xmlSiteInfo._PpmFolder = folderElement.GetElementsByTagName("Folder").InnerText;
}
//reading ContentTypes
XmlElement contentTypesElement = (XmlElement)pagesNode;
XmlNodeList contentTypesList = foldersElement.GetElementsByTagName("ContentTypes");
foreach (XmlNode contentType in contentTypesList)
{
XmlElement contentTypeElement = (XmlElement)contentType;
XmlNodeList contentTypeList = contentTypeElement.GetElementsByTagName("ContentType");
xmlSiteInfo._ContentTypeNames = new string[contentTypeList.Count];
for (int i = 0; i < contentTypeList.Count; i++)
{
xmlSiteInfo._ContentTypeNames = contentTypeElement.GetElementsByTagName("ContentType").InnerText;
}
}
}
this.SitesTable.Add(this.SitesTable.Count, xmlSiteInfo);
}
}
private SPContentType GetContentTypeByName(SPWeb web,string contentTypeName)
{
foreach (SPContentType contentType in web.ContentTypes)
{
if (contentType.Name == contentTypeName)
return contentType;
}
return null;
}
public void import(string fileName)
{
if (CreateSite != null)
{
try
{
ReadXML(fileName);
SPSite Sites = new SPSite(this._SourceUrl);
for (int i = 0; i < this.SitesTable.Count; i++)
{
Thread.Sleep(10);
CustomeEvetnArgs e = new CustomeEvetnArgs();
e.SiteName = _SourceUrl+"/"+((SiteInfo)SitesTable)._SiteUrl;
CreateSite(this, e);
if (DoSiteStructure)
{
if (!Sites.OpenWeb(((SiteInfo)SitesTable)._SiteUrl).Exists)
{
Sites.AllWebs.Add(((SiteInfo)SitesTable)._SiteUrl);
SPWeb newWeb = Sites.OpenWeb(((SiteInfo)SitesTable)._SiteUrl);
newWeb.Title = ((SiteInfo)SitesTable)._SiteTitle;
newWeb.Description = ((SiteInfo)SitesTable)._SiteDescription;
newWeb.Update();
}
}
if (DoPpmFolder)
{
if (Sites.OpenWeb(((SiteInfo)SitesTable)._SiteUrl).Exists)
{
SPDocumentLibrary docLibrary = GetLibraryByName(((SiteInfo)SitesTable)._SiteUrl, "Pages");
if (((SiteInfo)SitesTable)._PpmFolder != null)
{
for (int j = 0; j < ((SiteInfo)SitesTable)._PpmFolder.Length; j++)
{
if (!GetPageLibraryFolderByName(docLibrary, "/" + ((SiteInfo)SitesTable)._SiteUrl + "/Pages/" + ((SiteInfo)SitesTable)._PpmFolder[j]))
{
SPListItem newFolder = docLibrary.Items.Add("", SPFileSystemObjectType.Folder, ((SiteInfo)SitesTable)._PpmFolder[j]);
newFolder.Update();
SPFolder thisFolder = getFolderByName(Sites.OpenWeb(((SiteInfo)SitesTable)._SiteUrl), "/" + ((SiteInfo)SitesTable)._SiteUrl + "/Pages/" + ((SiteInfo)SitesTable)._PpmFolder[j], "Pages");
thisFolder.Item.ModerationInformation.Status = SPModerationStatusType.Approved;
thisFolder.Item.Update();
}
}
}
}
}
if (DoPageLibraryContentType)
{
if (Sites.OpenWeb(((SiteInfo)SitesTable)._SiteUrl).Exists)
{
if (((SiteInfo)SitesTable)._ContentTypeNames != null)
{
SPDocumentLibrary docLibrary = GetLibraryByName(((SiteInfo)SitesTable)._SiteUrl, "Pages");
foreach (string xmlContentTypeName in ((SiteInfo)SitesTable)._ContentTypeNames)
if (!IsContentTypeExists(docLibrary, xmlContentTypeName))
{
SPContentType newType = GetContentTypeByName(Sites.OpenWeb(), xmlContentTypeName);
if (newType != null)
{
docLibrary.ContentTypes.Add(newType);
docLibrary.Update();
}
}
}
}
}
}
}
catch (Exception ex)
{
throw (ex);
}
}
}
private bool IsContentTypeExists(SPDocumentLibrary docLib, string contentTypeName)
{
foreach (SPContentType contentType in docLib.ContentTypes)
if (contentType.Name == contentTypeName)
return true;
return false;
}
private bool GetPageLibraryContentType(SPDocumentLibrary pageLibrary, SPContentTypeCollection contentTypes)
{
foreach (SPContentType contentType in pageLibrary.ContentTypes)
{
foreach (SPContentType xmlContentType in contentTypes)
if (xmlContentType == contentType)
return true;
}
return false;
}
private bool GetPageLibraryFolderByName(SPDocumentLibrary docLib, string folderName)
{
foreach (SPListItem item in docLib.Folders)
if (item.Folder.ServerRelativeUrl == folderName)
return true;
return false;
}
private SPFolder getFolderByName(SPWeb web, string folderServerRelativeUrl, string libName)
{
SPListCollection lists = web.Lists;
foreach (SPList list in lists)
{
if (list.BaseType == SPBaseType.DocumentLibrary)
{
SPDocumentLibrary docLibrary = (SPDocumentLibrary)list;
if (!docLibrary.IsCatalog &&
list.BaseTemplate != SPListTemplateType.XMLForm &&
docLibrary.Title == libName)
{
SPListItemCollection docLibFolders = docLibrary.Folders;
foreach (SPListItem docLibItem in docLibFolders)
{
if (docLibItem.Folder.ServerRelativeUrl == folderServerRelativeUrl)
return docLibItem.Folder;
}
}
}
}
return null;
}
}
}