Showing posts with label Upload files. Show all posts
Showing posts with label Upload files. Show all posts

Wednesday, November 14, 2007

Upload a File to a SharePoint Document Library - Part II

In Part I I posted code that used the SharePoint lists service to help in uploading files with meta data to a sharepoint document library. Here is another variation, this time using FrontPage Server Extensions and RPC. Note that this code won't create more than one new folder - if this is a problem you may want to ensure the full folder path with code like that from the first article.

Update: You can download a comprehensive c# class library to automate RPC calls - including uploading files to a SharePoint document library. See this blog post for more information.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Net;
using System.Web;
 
namespace DevHoleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, object> properties = new Dictionary<string, object>();
            properties.Add("Title", "Test Title");
            //Create or overwrite text file test.txt in 'Docs' document library creating folder 'Test Folder' as required.
            DocLibHelper.Upload("http://localhost/Docs/Test Folder/test.txt", System.Text.Encoding.ASCII.GetBytes("Test text."), properties);
        }
    }
 
    static class DocLibHelper
    {
        static string EncodeMetaInfo(Dictionary<string, object> metaInfo)
        {
            if (metaInfo == null) return "";
            StringBuilder sb = new StringBuilder();
            foreach (KeyValuePair<string, object> kvp in metaInfo)
            {
                if (kvp.Value != null)
                {
                    string fieldName = kvp.Key; // note: field names are case sensitive
                    switch (fieldName)
                    {
                        case "Title":
                            fieldName = "vti_title";
                            break;
                    }
                    string data = EscapeVectorChars(kvp.Value.ToString());
                    string dataTypeCode = "S";
                    switch (kvp.Value.GetType().FullName)
                    {
                        case "System.Boolean":
                            dataTypeCode = "B";
                            break;
                        case "System.DateTime":
                            data = ((DateTime)kvp.Value).ToString("s") + "Z";
                            break;
                    }
                    sb.AppendFormat("{0};{1}W|{2};", fieldName, dataTypeCode, data);
                }
            }
            return HttpUtility.UrlEncode(sb.ToString().TrimEnd(';'));
        }
 
        static string EscapeVectorChars(string value)
        {
            StringBuilder sb = new StringBuilder();
            foreach (char c in value)
            {
                switch (c)
                {
                    case ';':
                    case '|':
                    case '[':
                    case ']':
                    case '\\':
                        sb.Append("\\");
                        break;
                }
                sb.Append(c);
            }
            return sb.ToString();
        }
 
        public static string GetWebURL(string url)
        {
            try
            {
                url = url.Substring(0, url.LastIndexOf("/"));
                try
                {
                    using (WebClient webClient = new WebClient())
                    {
                        webClient.Credentials = CredentialCache.DefaultCredentials;
                        webClient.Headers.Add("Content-Type", "application/x-vermeer-urlencoded");
                        webClient.Headers.Add("X-Vermeer-Content-Type", "application/x-vermeer-urlencoded");
                        byte[] data = Encoding.UTF8.GetBytes("method=open+service%3a12.0.4518.1016&service_name=%2f");
                        string result = Encoding.UTF8.GetString(webClient.UploadData(url + "/_vti_bin/_vti_aut/author.dll", "POST", data));
                        if (result.IndexOf("\n<li>status=327684") == -1)
                            return url;
                        throw new Exception();
                    }
                }
                catch
                {
                    return GetWebURL(url);
                }
            }
            catch
            {
                return null;
            }
        }
 
        public static bool Upload(string destinationUrl, byte[] bytes, Dictionary<string, object> metaInfo)
        {
            string result = "";
            string webUrl = GetWebURL(destinationUrl);
            string documentName = destinationUrl.Substring(webUrl.Length + 1);
            return Upload(webUrl, documentName, bytes, metaInfo, out result);
        }
 
        public static bool Upload(string webUrl, string documentName, byte[] bytes, Dictionary<string, object> metaInfo, out string result)
        {
            string putOption = "overwrite,createdir,migrationsemantics"// see http://msdn2.microsoft.com/en-us/library/ms455325.aspx
            string comment = null;
            bool keepCheckedOut = false;
            string method = "method=put+document%3a12.0.4518.1016&service_name=%2f&document=[document_name={0};meta_info=[{1}]]&put_option={2}&comment={3}&keep_checked_out={4}\n";
            method = String.Format(method, documentName, EncodeMetaInfo(metaInfo), putOption, HttpUtility.UrlEncode(comment), keepCheckedOut.ToString().ToLower());
            List<byte> data = new List<byte>();
            data.AddRange(Encoding.UTF8.GetBytes(method));
            data.AddRange(bytes);
            try
            {
                using (WebClient webClient = new WebClient())
                {
                    webClient.Credentials = CredentialCache.DefaultCredentials;
                    webClient.Headers.Add("Content-Type", "application/x-vermeer-urlencoded");
                    webClient.Headers.Add("X-Vermeer-Content-Type", "application/x-vermeer-urlencoded");
                    result = Encoding.UTF8.GetString(webClient.UploadData(webUrl + "/_vti_bin/_vti_aut/author.dll", "POST", data.ToArray()));
                    if (result.IndexOf("\n<p>message=successfully") < 0)
                        throw new Exception(result);
                }
            }
            catch (Exception ex)
            {
                result = ex.Message;
                return false;
            }
            return true;
        }
    }
}
 

Tuesday, October 23, 2007

Upload a File to a SharePoint Document Library - Part I

The following helper class demonstrates a few techniques that allow documents to be uploaded to a SharePoint document library programmatically without using the API or a custom web service. You don't need to specify a document library name, and it will create any folders specified in the URL as required. File meta data will be updated if any properties are passed.

To use this code add a reference to the SharePoint Lists service (/_vti_bin/Lists.asmx) and name it ‘ListsService’. The code was written against MOSS 2007.

To download files use the GetItem method of the SharePoint Copy service (/_vti_bin/Copy.asmx). While it’s possible to upload files using the CopyIntoItems method of this service, it won’t create folders as needed, and you’d probably want to remove the copy link that is created.

It's also possible to use Front Page Server Extensions and RPC calls to upload files with meta data - the code for which is a bit more efficient as it doesn't require web service calls. Using RPC calls is covered in Part II.

Update: You can download a comprehensive c# class library to automate RPC calls - including uploading files to a SharePoint document library. See this blog post for more information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.IO;
using System.Xml;
 
namespace DevHoleDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            DocLibHelper docLibHelper = new DocLibHelper();
            Dictionary<string, object> properties = new Dictionary<string, object>();
            properties.Add("Title", "Test Title");
            //Create or overwrite text file test.txt in 'Docs' document library creating folder 'Test Folder' as required.
            docLibHelper.Upload("http://localhost/Docs/Test Folder/test.txt", System.Text.Encoding.ASCII.GetBytes("Test text."), properties);
        }
    }
 
    public class DocLibHelper
    {
        ListsService.Lists m_listService;
        ICredentials m_credentials;
        ListInfoCollection m_lists;
 
        public DocLibHelper()
        {
            m_credentials = CredentialCache.DefaultCredentials;
            m_listService = new ListsService.Lists();
            m_listService.Credentials = m_credentials;
            m_lists = new ListInfoCollection(m_listService);
        }
 
        public class ListInfo
        {
            public string m_rootFolder;
            public string m_listName;
            public string m_version;
            public string m_webUrl;
            public ListInfo(XmlNode listResponse)
            {
                m_rootFolder = listResponse.Attributes["RootFolder"].Value + "/";
                m_listName = listResponse.Attributes["ID"].Value;
                m_version = listResponse.Attributes["Version"].Value;
            }
            public bool IsMatch(string url)
            {
                try
                {
                    url += "/";
                    return url.Substring(0, m_rootFolder.Length) == m_rootFolder;
                }
                catch { }
                return false;
            }
        }
 
        public class ListInfoCollection : IEnumerable<ListInfo>
        {
            ListsService.Lists m_listService;
            Dictionary<string, ListInfo> m_lists = new Dictionary<string, ListInfo>();
            public ListInfoCollection(ListsService.Lists listService)
            {
                m_listService = listService;
            }
            public IEnumerator<ListInfo> GetEnumerator()
            {
                return m_lists.Values.GetEnumerator();
            }
            IEnumerator IEnumerable.GetEnumerator()
            {
                return this.GetEnumerator();
            }
            public ListInfo Find(FileInfo fileInfo)
            {
                if (m_lists.ContainsKey(fileInfo.LookupName))
                    return m_lists[fileInfo.LookupName];
                foreach (ListInfo li in m_lists.Values)
                    if (li.IsMatch(fileInfo.LookupName)) return li;
                string webUrl = fileInfo.m_URL;
                if (fileInfo.m_listInfo != null && !string.IsNullOrEmpty(fileInfo.m_listInfo.m_listName))
                {
                    ListInfo listInfo = new ListInfo(CallService(ref webUrl, delegate { return m_listService.GetList(fileInfo.LookupName); }));
                    listInfo.m_webUrl = webUrl;
                    return listInfo;
                }
                else
                {
                    XmlNode lists = CallService(ref webUrl, delegate { return m_listService.GetListCollection(); });
                    if (lists == null) throw new Exception("Could not find web.");
                    //Find list by RootFolder (which doesn't seem to be populated in GetListCollection response so must iterate GetList response)
                    foreach (XmlNode list in lists.ChildNodes)
                    {
                        ListInfo listInfo = new ListInfo(m_listService.GetList(list.Attributes["Name"].Value));
                        listInfo.m_webUrl = webUrl;
                        m_lists.Add(listInfo.m_listName, listInfo);
                        if (listInfo.IsMatch(fileInfo.LookupName))
                            return listInfo;
                    }
                }
                throw new Exception("Could not find list.");
            }
            private delegate XmlNode ServiceOperation();
            private XmlNode CallService(ref string webURL, ServiceOperation serviceOperation)
            {
                try
                {
                    webURL = webURL.Substring(0, webURL.LastIndexOf("/"));
                    try
                    {
                        m_listService.Url = webURL + "/_vti_bin/Lists.asmx";
                        return serviceOperation();
                    }
                    catch
                    {
                        return CallService(ref webURL, serviceOperation);
                    }
                }
                catch
                {
                    webURL = null;
                    return null;
                }
            }
        }
 
        public class FileInfo
        {
            public string m_URL;
            public byte[] m_bytes;
            public Dictionary<string, object> m_properties;
            public ListInfo m_listInfo;
            public bool m_ensureFolders = true;
            private Uri m_uri;
            public bool HasProperties
            {
                get { return m_properties != null && m_properties.Count > 0; }
            }
            public string RelativeFilePath
            {
                get { return m_URL.Substring(m_URL.IndexOf(m_listInfo.m_rootFolder) + 1); }
            }
            public Uri URI
            {
                get
                {
                    if (m_uri == null) m_uri = new Uri(m_URL);
                    return m_uri;
                }
            }
            public string LookupName
            {
                get
                {
                    if (m_listInfo != null && !string.IsNullOrEmpty(m_listInfo.m_listName))
                        return m_listInfo.m_listName;
                    return URI.LocalPath;
                }
            }
            public FileInfo(string url, byte[] bytes, Dictionary<string, object> properties)
            {
                m_URL = url.Replace("%20", " ");
                m_bytes = bytes;
                m_properties = properties;
            }
        }
 
        public bool Upload(string destinationUrl, byte[] bytes, Dictionary<string, object> properties)
        {
            return Upload(new FileInfo(destinationUrl, bytes, properties));
        }
 
        public bool Upload(FileInfo fileInfo)
        {
            if (fileInfo.HasProperties)
                fileInfo.m_listInfo = m_lists.Find(fileInfo);
            bool result = TryToUpload(fileInfo);
            if (!result && fileInfo.m_ensureFolders)
            {
                string root = fileInfo.URI.AbsoluteUri.Replace(fileInfo.URI.AbsolutePath, "");
                for (int i = 0; i < fileInfo.URI.Segments.Length - 1; i++)
                {
                    root += fileInfo.URI.Segments[i];
                    if (i > 1) CreateFolder(root);
                }
                result = TryToUpload(fileInfo);
            }
            return result;
        }
 
        private bool TryToUpload(FileInfo fileInfo)
        {
            try
            {
                WebRequest request = WebRequest.Create(fileInfo.m_URL);
                request.Credentials = m_credentials;
                request.Method = "PUT";
                byte[] buffer = new byte[1024];
                using (Stream stream = request.GetRequestStream())
                using (MemoryStream ms = new MemoryStream(fileInfo.m_bytes))
                    for (int i = ms.Read(buffer, 0, buffer.Length); i > 0; i = ms.Read(buffer, 0, buffer.Length))
                        stream.Write(buffer, 0, i);
                WebResponse response = request.GetResponse();
                response.Close();
                if (fileInfo.HasProperties)
                {
                    StringBuilder sb = new StringBuilder();
                    sb.Append("<Method ID='1' Cmd='Update'><Field Name='ID'/>");
                    sb.AppendFormat("<Field Name='FileRef'>{0}</Field>", fileInfo.m_URL);
                    foreach (KeyValuePair<string, object> property in fileInfo.m_properties)
                        sb.AppendFormat("<Field Name='{0}'>{1}</Field>", property.Key, property.Value);
                    sb.Append("</Method>");
                    System.Xml.XmlElement updates = (new System.Xml.XmlDocument()).CreateElement("Batch");
                    updates.SetAttribute("OnError", "Continue");
                    updates.SetAttribute("ListVersion", fileInfo.m_listInfo.m_version);
                    updates.SetAttribute("PreCalc", "TRUE");
                    updates.InnerXml = sb.ToString();
                    m_listService.Url = fileInfo.m_listInfo.m_webUrl + "/_vti_bin/Lists.asmx";
                    XmlNode updatesResponse = m_listService.UpdateListItems(fileInfo.m_listInfo.m_listName, updates);
                    if (updatesResponse.FirstChild.FirstChild.InnerText != "0x00000000")
                        throw new Exception("Could not update properties.");
                }
                return true;
            }
            catch (WebException)
            {
                return false;
            }
        }
 
        private bool CreateFolder(string folderURL)
        {
            try
            {
                WebRequest request = WebRequest.Create(folderURL);
                request.Credentials = m_credentials;
                request.Method = "MKCOL";
                WebResponse response = request.GetResponse();
                response.Close();
                return true;
            }
            catch (WebException)
            {
                return false;
            }
        }
    }
}