protected ListItem SearchItemByName(List list, Folder folder, string pageName)
        {
            var context = list.Context;

            if (folder != null)
            {
                if (!folder.IsPropertyAvailable("ServerRelativeUrl"))
                {
                    folder.Context.Load(folder, f => f.ServerRelativeUrl);
                    folder.Context.ExecuteQueryWithTrace();
                }
            }

            var dQuery = new CamlQuery();

            string QueryString = "<View><Query><Where>" +
                             "<Eq>" +
                               "<FieldRef Name=\"FileLeafRef\"/>" +
                                "<Value Type=\"Text\">" + pageName + "</Value>" +
                             "</Eq>" +
                            "</Where></Query></View>";

            dQuery.ViewXml = QueryString;

            if (folder != null)
                dQuery.FolderServerRelativeUrl = folder.ServerRelativeUrl;

            var collListItems = list.GetItems(dQuery);

            context.Load(collListItems);
            context.ExecuteQueryWithTrace();

            return collListItems.FirstOrDefault();

        }

    static void InitializeClientContext() {

      // create new client context
      string targetSharePointSite = ConfigurationManager.AppSettings["targetSharePointSite"];
      clientContext = new ClientContext(targetSharePointSite);
      
      // get user name and secure password
      string userName = ConfigurationManager.AppSettings["accessAccountName"];
      string pwd = ConfigurationManager.AppSettings["accessAccountPassword"];
      SecureString spwd = new SecureString();
      foreach (char c in pwd.ToCharArray()) {
        spwd.AppendChar(c);
      }
    
        // create credentials for SharePoint Online using Office 365 user account
      clientContext.Credentials = new SharePointOnlineCredentials(userName, spwd);

      // initlaize static variables for client context, web and site
      siteCollection = clientContext.Site;
      clientContext.Load(siteCollection);
      site = clientContext.Web;
      clientContext.Load(site);
      siteRootFolder = site.RootFolder;
      clientContext.Load(siteRootFolder);
      clientContext.Load(site.Lists);

      TopNavNodes = site.Navigation.TopNavigationBar;
      clientContext.Load(TopNavNodes);
      clientContext.ExecuteQuery();

    }

        public static bool GetTextureBytes(string fileName, Folder folder, bool skipCache, out byte[] bytes)
        {
            bytes = null;
            string filePath = GetFilePath(fileName, folder);
            if (filePath == null || !File.Exists(filePath))
            {
#if DEBUG
                Logger.LogInfo("Cannot find texture file at " + filePath);
#endif
                return false;
            }

            if (!skipCache && sm_cachedFiles.TryGetValue(filePath, out bytes))
                return true;

            try
            {
                bytes = File.ReadAllBytes(filePath);
            }
            catch (Exception e)
            {
                Logger.LogInfo("Unexpected " + e.GetType().Name + " reading texture file at " + filePath);
                return false;
            }

            sm_cachedFiles[filePath] = bytes;
            return true;
        }

 private void RecursiveSharePointFolderVisitorInternal(Folder folder, Action<File> visit)
 {
     folder.Context.Load(folder, f => f.Files, f => f.Folders);
     folder.Context.ExecuteQuery();
     folder.Files.ToList().ForEach(f => visit(f));
     folder.Folders.ToList().ForEach(f => Execute(f, visit));
 }

 public DefaultKnownFolders(
                            MigrationsFolder alter_database,
                            MigrationsFolder up,
                            MigrationsFolder down,
                            MigrationsFolder run_first_after_up,
                            MigrationsFolder functions,
                            MigrationsFolder views,
                            MigrationsFolder sprocs,
                            MigrationsFolder indexes,
                            MigrationsFolder runAfterOtherAnyTimeScripts,        
                            MigrationsFolder permissions,
                            Folder change_drop
     )
 {
     this.alter_database = alter_database;
     this.up = up;
     this.down = down;
     this.run_first_after_up = run_first_after_up;
     this.functions = functions;
     this.views = views;
     this.sprocs = sprocs;
     this.indexes = indexes;
     this.runAfterOtherAnyTimeScripts = runAfterOtherAnyTimeScripts;
     this.permissions = permissions;
     this.change_drop = change_drop;
 }

    public DirectoryTree(string rootPath)
    {
        this.RootPath = rootPath;
            var root = Directory.GetParent(rootPath);

            rootFolder = new Folder(rootPath);
    }

        private static Series GetSerieData(Folder folder)
        {
            var s = new Series();
            s.TimeInterval = TimeInterval.Daily;
            foreach (var msg in folder.Messages)
            {
                var txt = msg.Body.Text;
                var exp = @"Pump Station Average Flow:(\s*\d{1,10}(\.){0,1}\d{0,3})\s*cfs";
                Regex re = new Regex(exp);
                var m = Regex.Match(txt, exp);
                if (m.Success)
                {
                    double d = Convert.ToDouble(m.Groups[1].Value);
                    var t = Reclamation.TimeSeries.Math.RoundToNearestHour(msg.Date.Value);

                    if (s.IndexOf(t) < 0)
                    {
                        s.Add(t, d);
                        //msg.Flags.Add(ImapX.Flags.MessageFlags.Seen);
                        msg.Flags.Add(ImapX.Flags.MessageFlags.Deleted);
                        Console.WriteLine(t.ToString() + " " + d.ToString("F2"));
                    }
                }
            }
            return s;
        }

        public static FindItemsResults<Item> GetAllMessages(ExchangeService service, Folder targetFolder, int start, int length)
        {
            //Create empty list for all mailbox messages:
            var listing = new List<EmailMessage>();

            //Create ItemView with correct pagesize and offset:
            ItemView view = new ItemView(length, start, OffsetBasePoint.Beginning);

            view.PropertySet = new PropertySet(EmailMessageSchema.Id,
                EmailMessageSchema.Subject,
                EmailMessageSchema.DateTimeReceived,
                EmailMessageSchema.From
                );

            view.OrderBy.Add(ItemSchema.DateTimeReceived, SortDirection.Descending);

            FindItemsResults<Item> findResults = service.FindItems(targetFolder.Id, view);

            //bool MoreItems = true;

            //while(MoreItems)
            //{
            //foreach (EmailMessage it in findResults.Items)
            //{
            //    listing.Add(it);
            //}
            //}

            //return View(listing.ToPagedList<EmailMessage>(pageNumber, pageSize));

            return findResults;
        }

        private static void TraverseDirectory(Folder currentFolder)
        {
            try
            {
                DirectoryInfo currentDirecotoryInfo = new DirectoryInfo(currentFolder.Name);
                DirectoryInfo[] subDirectories = currentDirecotoryInfo.GetDirectories();

                foreach (var file in currentDirecotoryInfo.GetFiles())
                {
                    currentFolder.AddFile(file.Name, (int)file.Length);
                }

                foreach (var dir in subDirectories)
                {
                    currentFolder.AddFolder(dir.FullName);
                }

                foreach (var child in currentFolder.ChildFolders)
                {
                    TraverseDirectory(child);
                }
            }
            catch (UnauthorizedAccessException uae)
            {
                Console.WriteLine("Cannot access directory: {0}", uae.Message);
            }
            catch(DirectoryNotFoundException dnf)
            {
                Console.WriteLine("Directory not found: {0}", dnf.Message);
            }
        }

        public Folder FolderForPath(string path)
        {
            Folder folder = new Folder();

            if (path == null || path == "")
            {
                return folder;
            }

            folder.FolderPath = path;
            folder.FolderName = Path.GetFileName(path);

            foreach (Folder mf in MediaFolders())
            {
                if (path.Contains(mf.FolderPath))
                {
                    folder.MediaFolderId = mf.FolderId;
                }
            }

            if (folder.IsMediaFolder() || serverSettings.MediaFolders == null)
            {
                int folderId = this.database.GetScalar<int>("SELECT FolderId FROM Folder WHERE FolderName = ? AND ParentFolderId IS NULL", folder.FolderName);
                folder.FolderId = folderId == 0 ? (int?)null : folderId;
            }
            else
            {
                folder.ParentFolderId = GetParentFolderId(folder.FolderPath);

                int folderId = this.database.GetScalar<int>("SELECT FolderId FROM Folder WHERE FolderName = ? AND ParentFolderId = ?", folder.FolderName, folder.ParentFolderId);
                folder.FolderId = folderId == 0 ? (int?)null : folderId;
            }

            return folder;
        }

        async Task UpdateFolder(StorageFolder storageFolder)
        {
            var folder = await databaseConnection.Table<Folder>().Where(p => p.Path == storageFolder.Path).FirstOrDefaultAsync();

            if (folder == null)
            {
                folder = new Folder() { LastUpdateTime = DateTime.Now, CheckedToday = true, Path = storageFolder.Path };
                await databaseConnection.InsertAsync(folder);

                await UpdateFilesInFolder(folder.Id, storageFolder);
            }
            else
            {
                var dateChanged = (await storageFolder.GetBasicPropertiesAsync()).DateModified;
                if (dateChanged > folder.LastUpdateTime)
                {
                    await UpdateFilesInFolder(folder.Id, storageFolder);
                    folder.LastUpdateTime = DateTime.Now;
                }

                folder.CheckedToday = true;
                await databaseConnection.UpdateAsync(folder);
            }

            foreach (var subFolder in await storageFolder.GetFoldersAsync())
                await UpdateFolder(subFolder);
        }

        public virtual void Initialize()
        {
            context = Mock.Of<ITypeDescriptorContext>();

            solution = new Solution();
            project = new Project { Name = "project", PhysicalPath = @"c:\projects\solution\project\project.csproj" };
            folder = new Folder();
            item = new Item { Data = { CustomTool = "", IncludeInVSIX = "false", CopyToOutputDirectory = CopyToOutput.DoNotCopy, ItemType = "None" }, PhysicalPath = @"c:\projects\solution\project\assets\icon.ico" };
            folder.Items.Add(item);
            project.Items.Add(folder);
            project.Data.AssemblyName = "project";
            solution.Items.Add(project);

            serviceProvider = new Mock<IServiceProvider>();
            componentModel = new Mock<IComponentModel>();
            picker = new Mock<ISolutionPicker>();
            var uriProvider = new PackUriProvider();

            var pack = new ResourcePack(item);

            var uriService = new Mock<IUriReferenceService>();
            uriService.Setup(u => u.CreateUri<ResourcePack>(It.IsAny<ResourcePack>(), "pack")).Returns(uriProvider.CreateUri(pack));

            serviceProvider.Setup(s => s.GetService(typeof(SComponentModel))).Returns(componentModel.Object);
            serviceProvider.Setup(s => s.GetService(typeof(ISolution))).Returns(solution);
            serviceProvider.Setup(s => s.GetService(typeof(IUriReferenceService))).Returns(uriService.Object);
            componentModel.Setup(c => c.GetService<Func<ISolutionPicker>>()).Returns(new Func<ISolutionPicker>(() => { return picker.Object; }));

            picker.Setup(p => p.Filter).Returns(Mock.Of<IPickerFilter>());
        }

    private static long sumFileSize(Folder rootFolder, Folder searchFolder)
    {
        long sum = 0;

        if (rootFolder.Name == searchFolder.Name)
        {
            sum = rootFolder.FolderSize;
            return sum;
        }

        foreach (var folder in rootFolder.Folders)
        {
            if (folder.Name == searchFolder.Name)
            {
                sum = folder.FolderSize;
                return sum;
            }
            else
            {
                sumFileSize(folder, searchFolder);
            }
        }

        return sum;
    }

 private void CheckGroup(Folder groupFolder, List<ActivityBase> activities)
 {
     // Create for each remaining sub folder a merge activity (too much nesting).
     activities.AddRange(groupFolder.SubFolders
         .Where(FilterOtherProgramFolders)
         .Select(f => new MergeFolderActivity(groupFolder, f)));
 }

 private static void FillDirectoryTree(string path, Folder folder)
 {
     try
     {
         // Append files
         var files = Directory.GetFiles(path);
         foreach (var file in files)
         {
             string fileName = GetName(file);
             FileInfo fileInfo = new FileInfo(file);
             folder.AddFile(new File(fileName, fileInfo.Length));
         }
         // Append dirs recursively
         var dirs = Directory.GetDirectories(path);
         foreach (var dir in dirs)
         {
             string dirName = GetName(dir);
             Folder newFolder = new Folder(dirName);
             folder.AddFolder(newFolder);
             FillDirectoryTree(dir, newFolder);
         }
     }
     catch (Exception e)
     {
         Console.WriteLine(e.Message);
     }
 }

        public static IEnumerable<Task> GetTasks(Folder[] folders = null)
        {
            var stringOptions = new string[] { "", null, "   ", "kevin", DateTime.Now.ToLongDateString(), "you rock the house with cheese" };
            folders = folders ?? new Folder[] { null, new Folder("foo", Colors.Red) };
            List<Folder> folderOptions = folders.ToList();
            if (!folderOptions.Contains(null))
            {
                folderOptions.Add(null);
            }

            var dateOptions = new DateTime?[] { null, DateTime.Now, DateTime.Now.AddDays((Util.Rnd.NextDouble() - .5) * 100) };

            foreach (TimeSpan? estimate in new TimeSpan?[] { null, TimeSpan.FromDays(Util.Rnd.NextDouble() * 10), TimeSpan.FromDays(Util.Rnd.NextDouble() * 10) })
            {
                foreach (bool? important in new bool?[] { true, false, null })
                {
                    foreach (var description in stringOptions)
                    {
                        foreach (var completeData in dateOptions)
                        {
                            foreach (var folder in folderOptions)
                            {
                                foreach (var dueDate in dateOptions)
                                {
                                    yield return new Task() { Description = description, Due = dueDate, Folder = folder, Completed = completeData, Estimate = estimate, IsImportant = important, };
                                }
                            }
                        }
                    }
                }
            }

        }

 static void Main()
 {
     string rootDir = @"C:\Windows";
     Folder winFolder = new Folder("Windows");
     FillDirectoryTree(rootDir, winFolder);
     PrintSize(winFolder);
 }

        public override void AsyncUpload(Folder parent, string filePath)
        {
            if (!IsAuthenticated)
            {
                throw new FilesOnlineAuthenticationException("You must login before you can upload files.");
            }

            if (!System.IO.File.Exists(filePath))
            {
                throw new FilesOnlineException("Specified upload file does not exist on this machine.");
            }

            if (parent == null)
            {
                throw new FilesOnlineException("Not all parameters were supplied or were invalid.");
            }

            if ((threadUpload != null) && threadUpload.IsAlive)
            {
                throw new FilesOnlineException(
                    "Only one file can be upload at a time. Please wait for the current file to finish upload.");
            }

            fileUploader = new FileUploader(string.Format(Constants.BoxAPIUploadUrl, User.Sid), this) {Proxy = Proxy};
            fileUploader.SetField("location", parent.Id.ToString());
            fileUploading = filePath;
            threadUpload = new Thread(Upload);
            threadUpload.Start();
            Busy = true;
        }

        /// <summary>
        /// Creates a new empty Lua script in the specified project, in the specified folder.
        /// </summary>
        /// <param name="data">The solution creation data, usually derived from the user's input in a NewSolutionForm.</param>
        /// <returns>A new solution that can be loaded.</returns>
        public override Moai.Platform.Management.File Create(string name, Project project, Folder folder)
        {
            File f = null;

            // Determine where to place the file.
            if (folder == null)
            {
                // Place the file in the root of the project
                f = new File(project, project.ProjectInfo.DirectoryName, name);
                project.AddFile(f);
            }
            else
            {
                // Place the file in the specified folder
                f = new File(project, project.ProjectInfo.DirectoryName, System.IO.Path.Combine(folder.FolderInfo.Name, name));
                folder.Add(f);
            }

            // Write the contents of the data into the file.
            using (System.IO.StreamWriter writer = new System.IO.StreamWriter(f.FileInfo.FullName))
            {
                writer.WriteLine("-- An empty script file.");
                writer.WriteLine();
            }

            return f;
        }

        /// <summary>
        /// Add the folder into the media library.
        /// </summary>
        public void AddFolder(string path)
        {
            // make sure the folder isnt already in the list
            bool exists = false;
            this.Foreach (delegate (TreeModel model, TreePath tree_path, TreeIter iter)
            {
                Folder node = (Folder) model.GetValue (iter, 0);
                if (node.Path == path) exists = true;
                return exists;
            });

            // add the folder if it isnt already in the list
            if (exists)
                library.MainPage.ThrowError ("The folder is already in the library:\n" + path);
            else
            {
                Folder folder = new Folder (path);
                this.AppendValues (root_iter, folder);
                library.MainPage.DataManager.AddFolder (folder);

                // load the files within the directory
                Progress progress = new Progress (library.MediaBox);
                progress.Start (Utils.FileCount (path));
                progress.Push ("Waiting in queue:  " + Utils.GetFolderName (path));

                // queue process
                delegate_queue.Enqueue (delegate {
                    addDirRecurse (path, progress, folder);
                    progress.End ();
                });
            }
        }