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

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

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

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: est.xml

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

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.

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

    }
}

so….write you own code to do this.

        protected bool PublishPpmContent(SPWeb web)
        {
            try
            {
                SPDocumentLibrary docLibrary = GetLibraryByName("myDocLibName");
                //publish files
                SPListItemCollection docLibItems = docLibrary.Items;
                foreach (SPListItem docLibItem in docLibItems)
                {
                    if (docLibItem["Approval Status"].ToString() != GlobalConst.Approved && docLibItem["Approval Status"].ToString() != GlobalConst.Rejected)//not approved, not rejected
                    {
                        SPFile thisFile = getFileByName(web, docLibItem.Url);
                        if (thisFile != null && thisFile.CheckedOutBy == null)
                        {
                            thisFile.Publish(string.Format("Published by {0} at {1}", web.CurrentUser.Name, DateTime.Now.ToLongDateString()));
                            thisFile.Approve(string.Format("Approved by {0} at {1}", web.CurrentUser.Name, DateTime.Now.ToLongDateString()));
                        }
                    }
                }
                //approve all folders
                SPListItemCollection docFolderCollection = docLibrary.Folders;
                foreach (SPListItem docFolder in docFolderCollection)
                {
                    if (docFolder["Approval Status"].ToString() != GlobalConst.Approved &&
                        docFolder["Approval Status"].ToString() != GlobalConst.Rejected)
                    {
                        SPFolder thisFolder = getFolderByName(web, docFolder.Url);
                        if (thisFolder.Exists)
                        {
                            thisFolder.Item.ModerationInformation.Status = SPModerationStatusType.Approved;
                            thisFolder.Item.Update();
                        }
                    }
                }
                return true;
            }
            catch
            {
                return false;
            }

        }

        private SPDocumentLibrary GetLibraryByName(string libraryName)
        {
            SPSite mySite = new SPSite("Your site url");
            foreach (SPList list in mySite.OpenWeb().Lists)
            {
                if (list.BaseType == SPBaseType.DocumentLibrary && list.Title == libraryName)
                    return (SPDocumentLibrary)list;
            }
            return null;
        }
         public SPFolder getFolderByName(SPWeb web, string folderName)
        {
            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 == GlobalConst.PpmSourceFileLibraryName)
                    {
                        SPListItemCollection docLibFolders = docLibrary.Folders;
                        foreach (SPListItem docLibItem in docLibFolders)
                        {
                            if (docLibItem.Folder.ServerRelativeUrl == "/" + folderName)
                                return docLibItem.Folder;
                        }
                    }
                }
            }
            return null;
        }

Note: 

1. Document library may contains folder, you need approve files and folders when do the entire publish. 
2. GlobalConst has a property Approved = "0", Rejected = "1", Pending = "2", Draft = "3"
3. Only work with VSS 3.0 not for Sharepoint 2003.

1. Project structure and features
Make sure completely understand how feature and solution works in Sharepoint. Understand how to create feature head file and feature detail file. Not necessary to memorize all the element but you must know where and how to find it at msdn. It is also very important to build your file structure properly first, otherwise it will easy comfuse youself later when the project grows. A good practice is create a Sharepoint list using VseWSS and study the structure. Key files to study are: Manifest.xml, setup.bat, feature.xml, instance.xml. You need also has the knowledge to create ddf file for your own projects. You could also implement MSBuild for your project in the future…

2. Make sure follow the rules
Exception from HRESULT: 0×81070201
I got this error message once and really took me long time to fix the problem. Finally, I found the folder name has to be exactly the same you defined in your element.xml. Sounds weird? Ask MS but to make it work, you have to rename the folder name and your ddf file as well.

3. Only Content controls are allowed directly in a content page that contains Content controls.
This error message is also misleading. If you got this message, simply remove the commented line in the AllItems.aspx and the rest .aspx pages. (Who says the commented line does not impact your project??? )

4. Two features for 1 list
When create list or document library, Sharepoint actually wants you to create 2 features for it.
First one is just instance of the list or document library. You might need:
feature.xml and instance.xml
the second actually is the schema and default aspx pages.
For list, this feature by default should contain: AllItems.aspx, DispForm.aspx, EditForm.aspx, NewForm.asxp, schema.xml, elementManifest.xml
For docLib, this feature by default should contains: AllItems.aspx, combine.aspx, dispform.aspx, editdlg.htm, editform.aspx, filedlg.htm, repair.aspx, schema.xml, upload.aspx, webfldr.aspx
The second feature acutally defines the default behavior of the list or docLib.

5. Event receiver
Event receiver defines the event and action during or after certain activity. For example, after the feature activated or after the item added. It is quite useful when you build your installation package and control your list/docLib. This can be defined in your feature.xml. For example:
 <Feature
Title="XXXYYYZZZ"
Id="282A5A9B-465F-4b4d-BB79-B5F6DD2B5A40"
Description="Your description"
Version="1.0.0.0"
Scope="Web"
Hidden="FALSE"
DefaultResourceFile="core"
ReceiverAssembly="MyTest.Sharepoint, Version=1.0.0.0, Culture=neutral, PublicKeyToken=f1cf6b1266b9b906" ReceiverClass="MyTest.Sharepoint.MyTestFeatureEventReceiver"
xmlns="http://schemas.microsoft.com/sharepoint/">

SPSite:
Represents a collection of sites on a virtual server, including a top-level site and all its subsites. Each SPSite object, or site collection, is represented within an SPSiteCollection object that consists of the collection of all site collections on the virtual server.
Note: SPSite is NOT a Collection, in another words, you can not use foreach to loop SPSite. To do this, you have to use SPWebCollection.

SPWebCollection:
Represents a collection of SPWeb objects.

SPWeb:
Represents a SharePoint Web site.

SPFolder:
Represents a folder on a SharePoint Web site. 

The following snipet is copy from a class:

        #region properties
        /// <summary>
        /// site collection url address
        /// </summary>
        public string _RootSiteUrl
        {
            get { return RootSiteUrl; }
            set { RootSiteUrl = value; }
        }
        /// <summary>
        /// Site collection, get SPSite object repsent a "collection"
        /// </summary>
        public SPSite _Sites
        {
            get { return new SPSite(this._RootSiteUrl); }
            set { Sites = value; }
        }
        /// <summary>
        /// Web collection, SPWebCollection, this is the real Collection
        /// </summary>
        public SPWebCollection _Webs
        {
            get { return this._Sites.AllWebs; }
        }

        public string _PPMAspxPageSiteUrl
        {
            get { return this.PPMTargetSiteUrl; }
            set { PPMTargetSiteUrl = value; }
        }

        public SPWeb this[string SiteName] // indexer, represent a SPWeb
        {
            get
            {
                int i = 0;
                foreach (SPWeb web in this._Webs)
                {
                    if (web.Url == SiteName)
                        return this._Webs[ i ];
                    i++;
                }
                return null;
            }
        }

        #endregion

The indexer is quite useful, to get a SPWeb object, simply use mySharePointClass["your site or subsite url"] to access!

Also, this class removed the <style>  section from the html file…

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using Microsoft.SharePoint;
using Microsoft.SharePoint.Publishing;

namespace PPM
{
    class PPMWeb
    {
        private string RootSiteUrl;
        private string PPMTargetSiteUrl;
        private SPSite Sites;

        #region properties
        public string _RootSiteUrl
        {
            get { return RootSiteUrl; }
            set { RootSiteUrl = value; }
        }
        public SPSite _Sites
        {
            get { return new SPSite(this._RootSiteUrl); }
            set { Sites = value; }
        }
        public SPWebCollection _Webs
        {
            get { return this._Sites.AllWebs; }
        }

        public string _PPMAspxPageSiteUrl
        {
            get { return this.PPMTargetSiteUrl; }
            set { PPMTargetSiteUrl = value; }
        }

        public SPWeb this[string SiteName]
        {
            get
            {
                int i = 0;
                foreach (SPWeb web in this._Webs)
                {
                    if (web.Url == SiteName)
                        return this._Webs[ i ] ;
                    i++;
                }
                return null;
            }
        }

        #endregion

        public PPMWeb(string RootSiteUrl, string PPMAspxSiteUrl)
        {
            this._RootSiteUrl = RootSiteUrl;
            this._PPMAspxPageSiteUrl = PPMAspxSiteUrl;
        }

        public void ConvertHtmlToAspx(string HtmlFileFolder, string HtmlFileName, string TargetWeb, PageLayout PPMPageLayout, string PPMContentField)
        {
            foreach (SPWeb web in this._Webs)
            {
                if (web.Url == TargetWeb )
                {
                    PublishingPage AspxPage = GetPublishingPagebyName(HtmlFileName.Replace(".htm", ".aspx"), web);
                    if (AspxPage != null) //if page exists, update content field
                    {
                        UpdateAspxPageContent(web, HtmlFileFolder, HtmlFileName, PPMContentField, false);
                    }
                    else //if page not exists, create page first
                    {
                        PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(web);
                        // Create the new page in the PublishingWeb.
                        PublishingPageCollection pages = publishingWeb.GetPublishingPages();
                        pages.Add(HtmlFileName.Replace(".htm", ".aspx"), PPMPageLayout);
                        // Update content
                        UpdateAspxPageContent(web, HtmlFileFolder, HtmlFileName, PPMContentField, true);
                    }
                }
            }
        }

        public void UpdateAspxPageContent(SPWeb Web, string HtmlFileFolder, string HtmlFileName, string PPMContentField, bool AlreadyCheckedOut)
        {
            PublishingPage AspxPage = GetPublishingPagebyName(HtmlFileName.Replace(".htm", ".aspx"), Web);
            if (AspxPage != null) //if page exists, update content field
            {
                try
                {
                    if (!AlreadyCheckedOut)
                        AspxPage.CheckOut();
                    AspxPage.ListItem[PPMContentField] = GetHtmlContentWithouStyle(HtmlFileFolder, HtmlFileName);
                    AspxPage.Update();
                }
                catch { }
                finally
                {
                    AspxPage.CheckIn("Your comment here…");
                }
            }
        }

        public PublishingPage GetPublishingPagebyName(string AspxFileName, SPWeb TargetWeb)
        {
            PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(TargetWeb);
            PublishingPageCollection pages = publishingWeb.GetPublishingPages();
            foreach (PublishingPage page in pages)
            {
                if (page.Name == AspxFileName)
                {
                    return page;
                }
            }
            return null;
        }

        public string GetHtmlContentWithouStyle(string HtmlFileFolder, string HtmlFileName)
        {
            StreamReader rdr = new StreamReader(HtmlFileFolder + HtmlFileName, System.Text.Encoding.Default);
            // Search through the stream until we reach the end
            bool StyleHeadFound = false;
            bool StyleEndFound = false;
            StringBuilder HtmlContent = new StringBuilder();
            while (!rdr.EndOfStream)
            {
                string line = rdr.ReadLine();
                if (StyleHeadFound && StyleEndFound)
                    HtmlContent.Append(line);
                else
                {

                    if (!StyleHeadFound)
                    {
                        if (line == "<style>")
                        {
                            StyleHeadFound = true;
                            continue;
                        }
                        HtmlContent.Append(line);
                    }
                    else
                    {
                        if (!StyleEndFound)
                        {
                            if (line == "</style>")
                            {
                                StyleEndFound = true;
                                continue;
                            }
                        }
                    }
                }
            }
            return HtmlContent.ToString();
        }

        public PageLayout GetPPMPageLayout(string PPMPageLayoutTitle)
        {
            PublishingSite publishingSite = new PublishingSite(this._Sites);
            foreach (PageLayout pageLayout in publishingSite.PageLayouts)
                if (pageLayout.Title == PPMPageLayoutTitle)
                    return pageLayout;
            return null;
        }

    }
}