C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Applications/Client Plugins/Plugin Publisher Plugin/PluginPublisher.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.IO;
using System.Net;
using System.Text;
using System.Windows.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PluginPlublisher.Controls;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PluginPlublisher.Forms;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PluginPlublisher.Properties;
using Mcs.Epm.MicrosoftProject.mpFx.Client.Shared;

namespace Mcs.Epm.MicrosoftProject.mpFx.Client.Plugins.PluginPlublisher
{
    /// <summary>
    /// Implements the plugin publisher plugin
    /// </summary>
    public class PluginPublisher : IMpFxClientPlugin
    {
        #region Instance Data

        private bool _Disposed;
        private bool _IsLoaded;

        #endregion

        #region Public Properties

        public ProjectServer ProjectServer { get; private set; }

        public bool IsMarkedForDeletion { get; set; }

        public Guid Guid
        {
            get
            {
                return new Guid("{2EB58C93-D11E-47c1-BB16-4C865D527A10}");
            }
        }

        public Version Version
        {
            get
            {
                return new Version("1.0.0.0");
            }
        }

        public string Implementation {get;set;}

        public string Name
        {
            get
            {
                return Resources.PluginName;
            }
        }

        public string Description
        {
            get
            {
                return Resources.PluginDescription;
            }
        }

        public string Author
        {
            get
            {
                return Resources.PluginAuthor;
            }
        }

        public string Tag
        {
            get
            {
                return Resources.PluginTag;
            }
        }

        public Uri Preview
        {
            get
            {
                return new Uri(Resources.PluginPreview);
            }
        }

        public bool IsLoaded
        {
            get
            {
                return _IsLoaded;
            }
        }

        public Form MainForm
        {
            get
            {
                return null;
            }
        }

        public UserControl OptionsControl
        {
            get
            {
                return new OptionsControl();
            }
        }

        public string Password { get; private set; }

        public string UserName { get; private set; }

        public string Location { get; private set; }

        #endregion

        #region Public Events

        public event OnStatusChangedEventHandler OnStatusChanged;

        #endregion

        #region Public Methods

        public void OnLoad(ProjectServer projectServer, Form parent, ToolStrip toolStrip)
        {
            Tools.ValidateOnLoadParams(projectServer, parent, toolStrip);

            ProjectServer = projectServer;

            _IsLoaded = true;
        }

        public void OnUnload()
        {
            ProjectServer = null;
            
            _IsLoaded = false;
        }

        public bool Login(Form parent)
        {
            using (GalleryLoginForm galleryLoginForm = new GalleryLoginForm())
            {
                DialogResult result = DialogResult.OK;
                Exception exception = null;

                while (true)
                {
                    parent.Cursor = Cursors.WaitCursor;

                    if (galleryLoginForm.ShowDialog(parent) == DialogResult.OK)
                    {
                        try
                        {
                            if (AttemptLogin(galleryLoginForm.GalleryLocation, galleryLoginForm.UserName, galleryLoginForm.Password))
                            {
                                parent.Cursor = Cursors.Default;
                                return true;
                            }

                            galleryLoginForm.DisplayLoginFailure = true;
                        }
                        catch (WebException webException)
                        {
                            if (webException.Message.Contains("530"))
                            {
                                exception = new Exception(Resources.LoginFailure);
                            }
                            else if (webException.Message.Contains("550"))
                            {
                                exception = new Exception(Resources.InvalidGalleryLocation);
                            }
                            else
                            {
                                exception = webException;
                            }
                        }
                        catch (Exception generalException)
                        {
                            exception = generalException;
                        }

                        if (exception != null)
                        {
                            result = MessageBox.Show(parent,
                                                     exception.Message,
                                                     Resources.PluginName,
                                                     MessageBoxButtons.OKCancel,
                                                     MessageBoxIcon.Error);

                        }

                        if (result == DialogResult.Cancel)
                        {
                            break;
                        }
                    }
                    else
                    {
                        break;
                    }
                }

                parent.Cursor = Cursors.Default;
            }

            return false;
        }

        public bool AddPlugin(Form parent, PluginHost pluginHost)
        {
            using (AddPluginForm addPluginForm = new AddPluginForm(pluginHost))
            {
                return addPluginForm.ShowDialog(parent) == DialogResult.OK;
            }
        }

        #endregion

        #region Private Methods

        private bool AttemptLogin(string location, string name, string password)
        {
            string tempLocalFile = string.Empty;

            try
            {
                string loginFile = location;

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

                loginFile = loginFile + "Login/" + name + DateTime.Now.Ticks;
                loginFile = loginFile.Replace(" ", "");
                loginFile = loginFile.Replace("@", "_");
                loginFile = loginFile.Replace(@"http://", @"ftp://");
                loginFile = loginFile.Replace(@"www", @"ftp");

                FtpWebRequest request = (FtpWebRequest)WebRequest.Create(loginFile);
                request.Method = WebRequestMethods.Ftp.UploadFile;

                // This example assumes the FTP site uses anonymous logon.
                request.Credentials = new NetworkCredential(name, password);

                // Copy the contents of the file to the request stream.
                tempLocalFile = Path.GetTempFileName();

                File.WriteAllText(tempLocalFile, loginFile);

                byte[] fileContents;

                using (StreamReader sourceStream = new StreamReader(tempLocalFile))
                {
                    fileContents = Encoding.UTF8.GetBytes(sourceStream.ReadToEnd());
                    sourceStream.Close();
                }

                File.Delete(tempLocalFile);

                request.ContentLength = fileContents.Length;

                using (Stream requestStream = request.GetRequestStream())
                {
                    requestStream.Write(fileContents, 0, fileContents.Length);
                    requestStream.Close();
                }

                using (FtpWebResponse response = (FtpWebResponse)request.GetResponse())
                {
                    response.Close();
                }

                Location = location;
                UserName = name;
                Password = password;
            }
            finally
            {

                if (!string.IsNullOrEmpty(tempLocalFile) && File.Exists(tempLocalFile))
                {
                    Tools.DeleteFile(tempLocalFile);
                }
            }

            return true;
        }

        #endregion

        #region Internal Methods

        internal void DoOnStatusChanged(OnStatusChangedArgs args)
        {
            if (OnStatusChanged != null)
            {
                OnStatusChanged(this, args);
            }
        }

        #endregion

        #region IDisposable members

        ~PluginPublisher()
        {
            Dispose(false);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (_Disposed)
            {
                if (disposing)
                {
                    try
                    {
                    }
                    catch (Exception)
                    {/* Swallow */}
                }

                _Disposed = true;
            }
        }


        #endregion
    }
}

---