Sharepoint Space

Enable Sharepoint server side script

2008-07-16T18:28:00Z

Here is the post of how to enable Sharepoint server side script.

http://spsite.wordpress.com/2008/07/16/sharepoint-server-side-script/

Organize and structure Sharepoint solution

2008-07-15T18:34:00Z

Organize and structure Sharepoint solution is important if you are working on a median or large Sharepoint project. Here is a post of some idea

http://spsite.wordpress.com/2008/07/15/organize-your-sharepoint-solution/

Posted on SharePoint Blogs

backup/restore content database

2008-07-14T17:41:00Z

I’ve read some articles of how to backup/restore Sharepoint application. Of course you can use stsadm -o backup&restore to do the job but you can also backup/restore content database from sql server directly. Even this is not recommended by some Sharepoint guru but I believeit is good to know and it might work in your scenario (for example, move production/staging/QA envirnment to your dev envirnment). Ok, here are the steps.

http://spsite.wordpress.com/2008/07/10/backuprestore-sharepoint-content-database/

Posted on SharePoint Blogs

export Keywords/Best Bet for Sharepoint 2007

2008-05-09T21:21:00Z

Sharepoint 2007 save Keywords and Best Bet to the SSP_DB database rather than the content database. If you use stsadm -o backup/restore to perform backup/restore, you will quickly find it does not work for Keywords and Best Bet. My solution to address this issue is to export/import those settings by extending stsadm command. Here is the article of how to extend stsadm from MSDN. http://msdn.microsoft.com/en-us/library/bb417382.aspx

Here is my keywords/best bet xml format:
<?xml version="1.0" encoding="UTF-8"?>
<Keywords>
<Keyword>
  <Term>Test</Term>
  <Synonyms DefaultSeperator=";">
   <Synonym>test<Synonm>
   <Synonym>TEST<Synonm>
  </Synonyms>
  <Definition></Definition>
  <Contact></Contact>
  <StartDate></StartDate>
  <EndDate></EndDate>
  <ReviewDate></ReviewDate>
  <BestBets>
   <BestBet>
    <Title></Title>
    <Url></Url>
    <Description></Description>
   </BestBet>
   <BestBet>
    <Title></Title>
    <Url></Url>
    <Description></Description>
   </BestBet>
  <BestBets>
</Keyword>
</Keywords>

Here is the code to export

        private int ExportKeywords(StringDictionary keyValues, out string output)
        {
            if (!keyValues.ContainsKey("url"))
            {
                throw new InvalidOperationException("The url parameter was not specified.");
            }
            if (!keyValues.ContainsKey("filename"))
            {
                throw new InvalidOperationException("The filename parameter was not specified.");
            }

String url = keyValues["url"];
string filename = keyValues["filename"];

            try
            {
                using (SPSite site = new SPSite(url))
                {
                    //get keyword
                    SearchContext searchContext = SearchContext.GetContext(site);
                    Keywords keywords = new Keywords(searchContext, new Uri(url));
                    //write to xml
                    XmlDocument xmlDoc = new XmlDocument();
                    XmlTextWriter xmlWriter = new XmlTextWriter(filename, System.Text.Encoding.UTF8);
                    xmlWriter.Formatting = Formatting.Indented;
                    xmlWriter.WriteProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
                    xmlWriter.WriteStartElement("Keywords");
                    xmlWriter.Close();
                    xmlDoc.Load(filename);
                    foreach (Keyword thisKeyword in keywords.AllKeywords)
                    {
                        XmlNode root = xmlDoc.DocumentElement;
                        XmlElement node_keyword = xmlDoc.CreateElement("Keyword");
                        root.AppendChild(node_keyword);

CreateElement("Term", thisKeyword.Term, node_keyword, xmlDoc);

                        XmlElement node_Synonyms = xmlDoc.CreateElement("Synonyms");
                        node_keyword.AppendChild(node_Synonyms);
                        foreach (Synonym syn in thisKeyword.Synonyms)
                            CreateElement("Synonym", syn.Term, node_Synonyms, xmlDoc);

                        CreateElement("Definition", thisKeyword.Definition, node_keyword, xmlDoc);

                        CreateElement("Contact", thisKeyword.Contact, node_keyword, xmlDoc);

                        if (thisKeyword.StartDate.Date !=DateTime.MaxValue.Date)
                            CreateElement("StartDate", thisKeyword.StartDate.ToShortDateString(), node_keyword, xmlDoc);
                        else
                            CreateElement("StartDate", "", node_keyword, xmlDoc);

                        if (thisKeyword.EndDate.Date != DateTime.MaxValue.Date)
                            CreateElement("EndDate", thisKeyword.EndDate.ToShortDateString(), node_keyword, xmlDoc);
                        else
                            CreateElement("EndDate", "", node_keyword, xmlDoc);

                        if (thisKeyword.ReviewDate.Date != DateTime.MaxValue.Date)
                            CreateElement("ReviewDate", thisKeyword.ReviewDate.ToShortDateString(), node_keyword, xmlDoc);
                        else
                            CreateElement("ReviewDate", "", node_keyword, xmlDoc);

                        XmlElement node_BestBets = xmlDoc.CreateElement("BestBets");
                        node_keyword.AppendChild(node_BestBets);
                        foreach (BestBet bestBet in thisKeyword.BestBets)
                        {
                            XmlElement node_BestBet = xmlDoc.CreateElement("BestBet");
                            node_BestBets.AppendChild(node_BestBet);
                            CreateElement("Title", bestBet.Title, node_BestBet, xmlDoc);
                            CreateElement("Url", bestBet.Url.ToString(), node_BestBet, xmlDoc);
                            CreateElement("Description", bestBet.Description, node_BestBet, xmlDoc);
                        }
                    }
                    xmlDoc.Save(filename);
                }
            }
            catch (Exception e)
            {
                throw new InvalidOperationException("Error retrieving url '" + url + "'. Please check the format of your url, and ensure that the site exists. Details: " + e.Message);
            }

StringBuilder sb = new StringBuilder();

            output = "";
            return 0;
        }

        private void CreateElement(string elementName, string elementValue, XmlElement parentElement, XmlDocument xmlDoc)
        {
            XmlElement newElement = xmlDoc.CreateElement(elementName);
            XmlText newElementText = xmlDoc.CreateTextNode("");
            newElementText.Value = elementValue;
            parentElement.AppendChild(newElement);
            newElement.AppendChild(newElementText);
        }

After deploy the dll and config the xml, you could export Keyword/bestbet using following command

stsadm -o exportkeywords -url http://yoursite -filename c:\test.xml

This method can also used to export/import search scope, site settings etc.

Posted on SharePoint Blogs

create folder, subfolder in Sharepoint programically

2008-02-14T20:37:00Z

//Create folder:
SPDocumentLibrary docLib = GetYourDocumentLibrary("YourSiteName","Pages");
SPListItem newFolder = docLib.Items.Add("",SPFileSystemObjectType.Folder,"first folder")
newFolder.Update();
//Create subfolder:
SPDocumentLibrary docLib = GetYourDocumentLibrary("YourSiteName","Pages");
SPListItem newFolder = docLib.Items.Add("http://yoursharepointsite/yoursite/pages/first folder",SPFileSystemObjectType.Folder,"first folder")
newFolder.Update();

Only thing needs to mention is Items.Add() function. First parameter is url, when create folder at the root, use "", when create subfolder, you have to provide the full URL including site collection, site, document library name and parent folder name. It took me 1 hour to figure out, hope this post will save your time.

Posted on SharePoint Blogs

export/import site structure using XML

2008-02-07T00:43:00Z

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;
        }

}
}

Posted on SharePoint Blogs