FileOperations.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Microsoft.Office365.SharePoint.FileServices;
using Microsoft.Office365.SharePoint.CoreServices.Extensions;
using System.Threading.Tasks;
using Microsoft.OData.Client;
using Microsoft.OData.Core;
using System.Diagnostics;
using System.Text;
using System.IO;

namespace LinkWise.Modules.OneDrive
{
    public class FileOperations
    {
        /// <summary>
        /// Performs a search of the default Documents folder. 
        /// </summary>
        /// <returns>A collection of information that describes files and folders.</returns>
        internal async Task<List<FileStats>> GetMyFilesAsync()
        {
            var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");
            //IOrderedEnumerable<IFileSystemItem> files = null;

            var returnResults = new List<FileStats>();

            try
            {
                // Performs a search of the default Documents folder.
                // You could also specify other folders using the syntax: var filesResults = await _client.Files["folder_name"].ExecuteAsync();
                // This results in a call to the service.

                var filesResults = await spClient.Files.ExecuteAsync();

                var files = filesResults.CurrentPage;

                foreach (IItem fileItem in files)
                {
                    // The item to add to the result set.
                    //model.FileObject modelFile = new model.FileObject(fileItem);

                    returnResults.Add(new FileStats
                    {
                        ItemID = fileItem.Id,
                        ItemName = fileItem.Name,
                        ItemSize = fileItem.Size,
                        ItemType = fileItem.Type,
                        ItemUrl = fileItem.WebUrl,
                    });
                }
            }
            catch (ODataErrorException)
            {
                return null;
            }
            catch (DataServiceQueryException)
            {
                return null;
            }
            catch (MissingMethodException e)
            {
                Debug.Write(e.Message);
            }

            return returnResults;
        }

        internal async Task<List<FileStats>> GetMyFilesAsync(string selectedItemID)
        {
            var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

            var returnResults = new List<FileStats>();

            try
            {
                var filesResults = await spClient.Files[selectedItemID].ToFolder().Children.ExecuteAsync();

                var files = filesResults.CurrentPage;

                foreach (IItem fileItem in files)
                {
                    returnResults.Add(new FileStats
                    {
                        ItemID = fileItem.Id,
                        ItemName = fileItem.Name,
                        ItemSize = fileItem.Size,
                        ItemType = fileItem.Type,
                        ItemUrl = fileItem.WebUrl,
                    });
                }
            }
            catch (ODataErrorException)
            {
                return null;
            }
            catch (DataServiceQueryException)
            {
                return null;
            }
            catch (MissingMethodException e)
            {
                Debug.Write(e.Message);
            }

            return returnResults;
        }

        internal async Task<bool> DownloadFileAsync(string selectedItemID)
        {
            var results = false;

            try
            {
                // Make sure we have a reference to the SharePoint client
                var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

                // Get a handle on the selected item.
                IItemFetcher thisItemFetcher = spClient.Files.GetById(selectedItemID);
                IFileFetcher thisFileFetcher = thisItemFetcher.ToFile();
                var myFile = await thisFileFetcher.ExecuteAsync();

                Microsoft.Office365.SharePoint.FileServices.File file = myFile as Microsoft.Office365.SharePoint.FileServices.File;

                // Download the file and put the results into a string. This results in a call to the service.
                using (Stream stream = await file.DownloadAsync())
                {
                    // TODO: save file to users locker
                    // Create a new file. If the file already exists, it will be overwritten.
                    using (var fileStream = new FileStream(@"C:\hosting\WebApp1\Downloads\" + myFile.Name, FileMode.Create, FileAccess.Write))
                    {
                        stream.CopyTo(fileStream);
                    }
                }

                results = true;
            }
            catch (Exception exc)
            {
                throw new Exception("Error occured while downloading file:  ", exc);
            }

            return results;
        }

        ////<summary>
        ////Creates a new file named demo.txt in the default document library.
        ////</summary>
        ////<returns>A Boolean value that indicates whether the new text file was successfully created.</returns>
        //internal async Task<String> CreateNewTextFileAsync()
        //{
        //    //bool isSuccess = false;
        //    String newID = string.Empty;
        //    var sharePointClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

        //    try
        //    {
        //        // First check whether demo.txt already exists. If it exists, delete it.
        //        // If it doesn't exist, swallow the error.
        //        IItem item = await sharePointClient.Files.GetByPathAsync("demo.txt");
        //        await item.DeleteAsync();
        //    }
        //    catch (ODataErrorException)
        //    {
        //        // fail silently because demo.txt doesn't exist.
        //    }

        //    try
        //    {

        //        // In this example, we'll create a simple text file and write the current timestamp into it. 
        //        string createdTime = "Created at " + DateTime.Now.ToLocalTime().ToString();
        //        byte[] bytes = Encoding.UTF8.GetBytes(createdTime);

        //        using (MemoryStream stream = new MemoryStream(bytes))
        //        {
        //            // File is called demo.txt. If it already exists, we'll get an exception. 
        //            Microsoft.Office365.SharePoint.FileServices.File newFile = new Microsoft.Office365.SharePoint.FileServices.File
        //            {
        //                Name = "demo.txt"
        //            };

        //            // Create the empty file.
        //            await sharePointClient.Files.AddItemAsync(newFile);
        //            newID = newFile.Id;

        //            // Upload the file contents.
        //            await sharePointClient.Files.GetById(newFile.Id).ToFile().UploadAsync(stream);
        //        }
        //    }

        //    // ODataErrorException can be thrown when you try to create a file that already exists.
        //    catch (Microsoft.Data.OData.ODataErrorException)
        //    {
        //        //isSuccess = false;
        //    }

        //    return newID;
        //}

        ///// <summary>
        ///// Deletes the selected item or folder from the ListBox.
        ///// </summary>
        ///// <returns>A Boolean value that indicates whether the file or folder was successfully deleted.</returns>
        //internal async Task<bool?> DeleteFileOrFolderAsync(string selectedItemID)
        //{
        //    bool? isSuccess = false;

        //    try
        //    {
        //        // Make sure we have a reference to the SharePoint client
        //        var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

        //        // Get the file to be removed from the SharePoint service. This results in a call to the service.
        //        IItemFetcher thisItemFetcher = spClient.Files.GetById(selectedItemID);
        //        IFileFetcher thisFileFetcher = thisItemFetcher.ToFile();
        //        var thisFile = await thisFileFetcher.ExecuteAsync();

        //        // Delete the file or folder. This results in a call to the service.
        //        await thisFile.DeleteAsync();

        //        isSuccess = true;
        //    }
        //    catch (Microsoft.Data.OData.ODataErrorException)
        //    {
        //        isSuccess = null;
        //    }
        //    catch (NullReferenceException)
        //    {
        //        isSuccess = null;
        //    }

        //    return isSuccess;
        //}

        ///// <summary>
        ///// Reads the contents of a text file and displays the results in a TextBox.
        ///// </summary>
        ///// <param name="_selectedFileObject">The file selected in the ListBox.</param>
        ///// <returns>A Boolean value that indicates whether the text file was successfully read.</returns>
        //internal async Task<object[]> ReadTextFileAsync(string selectedItemID)
        //{
        //    string fileContents = string.Empty;
        //    object[] results = new object[] { fileContents, false };

        //    try
        //    {
        //        // Make sure we have a reference to the SharePoint client
        //        var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

        //        // Get a handle on the selected item.
        //        IItemFetcher thisItemFetcher = spClient.Files.GetById(selectedItemID);
        //        IFileFetcher thisFileFetcher = thisItemFetcher.ToFile();
        //        var myFile = await thisFileFetcher.ExecuteAsync();

        //        // Check that the selected item is a .txt file.
        //        if (!myFile.Name.EndsWith(".txt") && !myFile.Name.EndsWith(".xml"))
        //        {
        //            results[0] = string.Empty;
        //            results[1] = false;
        //            return results;
        //        }

        //        Microsoft.Office365.SharePoint.FileServices.File file = myFile as Microsoft.Office365.SharePoint.FileServices.File;

        //        // Download the text file and put the results into a string. This results in a call to the service.
        //        using (Stream stream = await file.DownloadAsync())
        //        {
        //            using (StreamReader reader = new StreamReader(stream))
        //            {
        //                results[0] = await reader.ReadToEndAsync();

        //                results[1] = true;
        //            }
        //        }
        //    }
        //    catch (NullReferenceException)
        //    {
        //        results[1] = false;
        //    }
        //    catch (ArgumentException)
        //    {
        //        results[1] = false;
        //    }

        //    return results;
        //}

        ///// <summary>
        ///// Update the currently selected item by appending new text.
        ///// </summary>
        ///// <param name="_selectedFileObject">The file selected in the ListBox.</param>
        ///// <param name="fileText">The updated text contents of the file.</param>
        ///// <returns>A Boolean value that indicates whether the text file was successfully updated.</returns>
        //internal async Task<bool> UpdateTextFileAsync(string selectedItemID, string fileText)
        //{
        //    Microsoft.Office365.SharePoint.FileServices.File file;
        //    byte[] byteArray;
        //    bool isSuccess = false;

        //    try
        //    {
        //        // Make sure we have a reference to the SharePoint client
        //        var spClient = await AuthenticationHelper.EnsureSharePointClientCreatedAsync("MyFiles");

        //        // Get a handle on the selected item.
        //        IItemFetcher thisItemFetcher = spClient.Files.GetById(selectedItemID);
        //        IFileFetcher thisFileFetcher = thisItemFetcher.ToFile();
        //        var myFile = await thisFileFetcher.ExecuteAsync();

        //        file = myFile as Microsoft.Office365.SharePoint.FileServices.File;
        //        string updateTime = "\n\r\n\rLast update at " + DateTime.Now.ToLocalTime().ToString();
        //        byteArray = Encoding.UTF8.GetBytes(fileText + updateTime);

        //        using (MemoryStream stream = new MemoryStream(byteArray))
        //        {
        //            // Update the file. This results in a call to the service.
        //            await file.UploadAsync(stream);
        //            isSuccess = true; // We've updated the file.
        //        }
        //    }
        //    catch (ArgumentException)
        //    {
        //        isSuccess = false;
        //    }

        //    return isSuccess;
        //}
    }
}