C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx.Client.Shared/Tools.cs

/*  ----------------------------------------------------------------------------
 *  Microsoft Corporation
 *  ----------------------------------------------------------------------------
 *  Microsoft Project Server mpFx (mpFx)
 *  ----------------------------------------------------------------------------
 *  Author: Colby Africa
 *  ----------------------------------------------------------------------------
 *  License: http://code.msdn.microsoft.com/mpFx/Project/License.aspx
 *  ----------------------------------------------------------------------------
 */

using System;
using System.Globalization;
using System.IO;
using System.Net;
using System.Text.RegularExpressions;
using System.Windows.Forms;
using ICSharpCode.SharpZipLib.Zip;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared.Properties;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Shared
{
    /// <summary>
    /// Implements shared routines
    /// </summary>
    public class Tools
    {
        #region Private Constants

        private const int BUFFER_SIZE = 16;

        #endregion

        #region Guid Routines

        public static bool IsGuid(string candidate)
        {
            bool isValid = false;

            if (!string.IsNullOrEmpty(candidate))
            {
                Regex isGuid = new Regex(@"^(\{){0,1}[0-9a-fA-F]{8}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{4}\-[0-9a-fA-F]{12}(\}){0,1}$", RegexOptions.Compiled); 

                if (isGuid.IsMatch(candidate))
                {
                    isValid = true;
                }
            }

            return isValid;

        }

        #endregion

        #region Validation Routines

        public static void ValidateOnLoadParams(ProjectServer projectServer, Form parent, ToolStrip toolStrip)
        {
            ValidateObjectParam(projectServer, Resources.NullProjectServerObject);
            ValidateObjectParam(parent, Resources.NullParentFormObject);
            ValidateObjectParam(toolStrip, Resources.NullToolStripObject);
        }

        public static void ValidateObjectParam(object validateObject, string errorMessage)
        {
            if (validateObject == null)
            {
                throw new ArgumentNullException(errorMessage);
            }
        }

        public static void ValidateDirectoryParam(string directory, string errorMessage)
        {
            if (string.IsNullOrEmpty(directory) || !Directory.Exists(directory))
            {
                throw new ArgumentException(errorMessage);
            }
        }

        public static bool DoesExistInGridView(DataGridView dataGridView, int columnIndex, string text)
        {
            foreach (DataGridViewRow row in dataGridView.Rows)
            {
                if (row.IsNewRow)
                {
                    continue;
                }
                if (row.Cells[columnIndex].Value.ToString().Equals(text, StringComparison.CurrentCultureIgnoreCase))
                {
                    return true;
                }
            }

            return false;

        }

        #endregion

        #region WinForms Cleanup

        public static void DisposeForm(Form form)
        {
            if (form != null && !form.IsDisposed)
            {
                form.Close();
                form.Dispose();
            }
        }

        public static ToolStripDropDownButton FindToolStripDropDownButtonByText(ToolStrip toolStrip, string text)
        {
            text = text.Replace("&", "");

            foreach (object item in toolStrip.Items)
            {
                ToolStripDropDownButton toolStripDropDownButton = item as ToolStripDropDownButton;

                if (toolStripDropDownButton != null)
                {
                    string tempText = toolStripDropDownButton.Text.Replace("&", "");

                    if (tempText.Equals(text, StringComparison.CurrentCultureIgnoreCase))
                    {
                        return toolStripDropDownButton;
                    }
                }
            }

            return null;
        }

        public static void CleanupToolStripItem(ToolStripItemCollection items, ToolStripMenuItem item)
        {
            if (item != null)
            {
                items.Remove(item);
                item.Dispose();
            }
        }

        public static void CleanupToolStripItem(ToolStripItemCollection items, ToolStripSeparator separator)
        {
            if (separator != null)
            {
                items.Remove(separator);
                separator.Dispose();
            }
        }

        public static void CleanupToolStripItem(ToolStripItemCollection items, ToolStripDropDownButton button)
        {
            if (button != null)
            {
                items.Remove(button);
                button.Dispose();
            }
        }

        #endregion

        #region String Routines

        public static string GetDecameledString(string cameledString)
        {
            int lastUpper = -1;

            string displayName = string.Empty;

            for (int i = 0; i < cameledString.Length; i++)
            {
                bool isUpper = char.IsUpper(cameledString[i]);

                if (isUpper && i > 0 && i - lastUpper > 1)
                {
                    displayName = string.Format("{0} {1}", displayName, cameledString[i]);
                }
                else
                {
                    displayName = displayName + cameledString[i];
                }

                if (isUpper)
                {
                    lastUpper = i;
                }
            }

            return displayName;
        }

        public static string Format(string text, params object[] args)
        {
            return string.Format(CultureInfo.CurrentCulture, text, args);
        }

        #endregion

        #region Http Wrappers

        public static void HttpDownload(string url, string target)
        {
            WebRequest request = WebRequest.Create(url);

            if (request == null)
            {
                // TODO: 
                throw null;
            }

            WebResponse response = request.GetResponse();

            if (response == null)
            {
                //  TODO:
                throw null;
            }

            using (Stream responseStream = response.GetResponseStream())
            {
                using (FileStream localCopy = File.OpenWrite(target))
                {
                    byte[] Buffer = new byte[BUFFER_SIZE];
                    int read;

                    do
                    {
                        read = responseStream.Read(Buffer, 0, Buffer.Length);
                        localCopy.Write(Buffer, 0, read);
                        Application.DoEvents();
                    }
                    while (read > 0);

                    localCopy.Flush();
                    localCopy.Close();
                }

                responseStream.Close();
            }
        }

        #endregion

        #region Ftp Wrappers

        public static bool FtpRemoveDirectory(string ftpLocation, string username, string password)
        {

            FtpWebRequest listRequest = (FtpWebRequest)WebRequest.Create(ftpLocation.TrimEnd('/'));
            listRequest.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
            listRequest.Credentials = new NetworkCredential(username, password);

            using (FtpWebResponse removeResponse = (FtpWebResponse)listRequest.GetResponse())
            {
                using (Stream removeResponseStream = removeResponse.GetResponseStream())
                using (StreamReader removeReader = new StreamReader(removeResponseStream))
                {
                    string listDetails = removeReader.ReadToEnd();

                    if (string.IsNullOrEmpty(listDetails) || listDetails.Contains("total 0"))
                    {

                    }
                    else
                    {
                        FtpRemoveDirectoryFiles(ftpLocation, username, password);
                    }
                }
            }

            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(ftpLocation.TrimEnd('/'));
            request.Method = WebRequestMethods.Ftp.RemoveDirectory;
            request.Credentials = new NetworkCredential(username, password);

            using (FtpWebResponse removeResponse = (FtpWebResponse)request.GetResponse())
            {
                using (Stream removeResponseStream = removeResponse.GetResponseStream())
                using (StreamReader removeReader = new StreamReader(removeResponseStream))
                {
                    string removeDetails = removeReader.ReadToEnd();
                    return string.IsNullOrEmpty(removeDetails);
                }
            }
        }

        public static void FtpRemoveDirectoryFiles(string location, string username, string password)
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(location.TrimEnd('/'));
            request.Method = WebRequestMethods.Ftp.ListDirectory;
            request.Credentials = new NetworkCredential(username, password);

            using (FtpWebResponse removeResponse = (FtpWebResponse)request.GetResponse())
            {
                using (Stream removeResponseStream = removeResponse.GetResponseStream())
                using (StreamReader removeReader = new StreamReader(removeResponseStream))
                {
                    string listDetails = removeReader.ReadToEnd();

                    if (!location.EndsWith("/"))
                    {
                        location = location + "/";
                    }

                    string[] files = listDetails.Split('\n');

                    foreach (string file in files)
                    {
                        if (!string.IsNullOrEmpty(file))
                        {
                            string fullPath = location + file.Substring(file.IndexOf('/') + 1);

                            FtpRemoveFile(fullPath, username, password);
                        }
                    }
                }
            }
        }

        public static void FtpRemoveFile(string path, string username, string password)
        {
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(path);
                request.Method = WebRequestMethods.Ftp.DeleteFile;
                request.Credentials = new NetworkCredential(username, password);

                using (FtpWebResponse removeResponse = (FtpWebResponse)request.GetResponse())
                {
                    using (Stream removeResponseStream = removeResponse.GetResponseStream())
                    using (StreamReader removeReader = new StreamReader(removeResponseStream))
                    {
                        string listDetails = removeReader.ReadToEnd();
                    }
                }
            }
            catch (WebException e)
            {
                Console.WriteLine(e);
                throw;
            }
        }

        public static bool FtpDirectoryExists(string location, string username, string password)
        {
            try
            {
                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(location.TrimEnd('/'));
                request.Method = WebRequestMethods.Ftp.ListDirectoryDetails;
                request.Credentials = new NetworkCredential(username, password);

                using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                {
                    using (Stream responseStream = response.GetResponseStream())
                    using (StreamReader responseReader = new StreamReader(responseStream))
                    {
                        string listDetails = responseReader.ReadToEnd();

                        return !string.IsNullOrEmpty(listDetails);
                    }
                }
            }
            catch (WebException exception)
            {
                if (exception.Message.Contains("550"))
                {
                    return false;
                }
                throw;
            }
        }

        public static bool FtpUploadFile(string targetLocation, string file, string username, string password)
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(targetLocation.TrimEnd('/'));
            request.Method = WebRequestMethods.Ftp.UploadFile;
            request.Credentials = new NetworkCredential(username, password);
            request.UseBinary = true;
            request.Proxy = null;

            FileInfo fileInfo = new FileInfo(file);
            byte[] buffer = new byte[fileInfo.Length];

            using (FileStream fileStream = fileInfo.OpenRead())
            {
                fileStream.Read(buffer, 0, (int)fileInfo.Length);
            }

            using (Stream writer = request.GetRequestStream())
            {
                writer.Write(buffer, 0, (int)fileInfo.Length);
            }

            FtpWebResponse response = (FtpWebResponse)request.GetResponse();

            return response.StatusCode == FtpStatusCode.FileActionOK;

        }

        public static void FtpCreateDirectory(string location, string username, string password)
        {
            FtpWebRequest request = (FtpWebRequest)WebRequest.Create(location.TrimEnd('/'));
            request.Method = WebRequestMethods.Ftp.MakeDirectory;
            request.Credentials = new NetworkCredential(username, password);

            using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
            {
                using (Stream responseStream = response.GetResponseStream())
                using (StreamReader responseReader = new StreamReader(responseStream))
                {
                    string listDetails = responseReader.ReadToEnd();
                }
            }
        }


        #endregion

        #region Zip Wrappers

        public static void ZipFiles(string tempDirectory, string outputPathAndFile)
        {            
            if (File.Exists(outputPathAndFile))
            {
                try
                {
                    File.Delete(outputPathAndFile);
                }
                catch (Exception) { /*  Swallow  */}
                
            }

            FastZip fastZip = new FastZip();
            fastZip.CreateZip(outputPathAndFile, tempDirectory, true, string.Empty);


        }

        #endregion

        #region File and Directory Routines

        public static void DeleteFile(string file)
        {
            try
            {
                if (!string.IsNullOrEmpty(file) && File.Exists(file))
                {
                    File.Delete(file);
                }
            }
            catch { /*  Swallow  */}
        }

        public static string OpenDll(Form parent, string title)
        {
            using (OpenFileDialog openFileDialog = new OpenFileDialog())
            {
                openFileDialog.CheckFileExists = true;
                openFileDialog.CheckPathExists = true;
                openFileDialog.Title = title;
                openFileDialog.Filter = "DLL Assemblies (*.dll) | *.dll";
                openFileDialog.Multiselect = false;

                if (openFileDialog.ShowDialog(parent) == DialogResult.Cancel)
                {
                    return string.Empty;
                }

                return openFileDialog.FileName;

            }
        }

        public static void DeleteDirectory(string directory, bool recurse)
        {
            if (!string.IsNullOrEmpty(directory) && Directory.Exists(directory))
            {
                try
                {
                    Directory.Delete(directory, recurse);
                }
                catch (Exception) { /*  Swallow  */}

            }
        }

        public static string CreateTempDirectory()
        {
            string tempDirectory = Path.GetTempFileName();

            DeleteFile(tempDirectory);

            tempDirectory = Path.ChangeExtension(tempDirectory, "");

            Directory.CreateDirectory(tempDirectory);
            return tempDirectory;
        }
        
        public static void CopyFiles(string sourceDirectory, string targetPath, string filter, bool removeIfExists)
        {
            string[] files = Directory.GetFiles(sourceDirectory, filter);

            foreach (string file in files)
            {
                string targetFilePath = Path.Combine(targetPath, Path.GetFileName(file));

                if (removeIfExists)
                {
                    DeleteFile(targetFilePath);
                }

                File.Copy(file, targetFilePath);
            }
        }

        #endregion


    }
}

---