C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx.WinForms/ProjectSelectionForm.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.Collections.Generic;
using System.Web.Services.Protocols;
using System.Windows.Forms;
using System.IO;

namespace Mcs.Epm.MicrosoftProject.mpFx.WinForms
{
    /// <summary>
    /// Implements a project selection dialog
    /// </summary>
    public partial class ProjectSelectionForm : Form
    {
        #region Instance Data

        private readonly ProjectServer _ProjectServer;
        private readonly Dictionary<Guid, string> _DisplayedCustomFields;
        private readonly List<Guid> _OriginallySelectedProjects;
        private Dictionary<Guid, string> _SelectedProjects;
        private readonly bool _UseCache;

        #endregion

        #region Constructors

        public ProjectSelectionForm(ProjectServer projectServer,
                                    Dictionary<Guid, string> displayedCustomFiels,
                                    List<Guid> SelecteProjects,
                                    bool useCache)
        {
            InitializeComponent();

            _ProjectServer = projectServer;
            _DisplayedCustomFields = displayedCustomFiels;
            _OriginallySelectedProjects = SelecteProjects;
            _UseCache = useCache;
        }

        #endregion

        #region Public Properties

        public Dictionary<Guid, string> SelectedProjects
        {
            get
            {
                if (_SelectedProjects == null)
                {
                    _SelectedProjects = new Dictionary<Guid, string>();

                    foreach (DataGridViewRow row in selectedProjectsDataGridView.Rows)
                    {
                        if (Convert.ToBoolean(row.Cells[1].Value))
                        {
                            _SelectedProjects.Add(new Guid(row.Cells[0].Value.ToString()),
                                                  row.Cells[2].Value.ToString());
                        }
                    }
                }

                return _SelectedProjects;
            }
        }

        #endregion

        #region Private Methods

        private void LoadProjects(bool overrideCacheSettings)
        {
            Cursor = Cursors.WaitCursor;
            okButton.Enabled = false;

            selectedProjectsDataGridView.Rows.Clear();

            if (_UseCache && !overrideCacheSettings)
            {
                LoadCachedProjects();
            }
            else
            {
                LoadProjectFromServer();
            }

            okButton.Enabled = true;
            Cursor = Cursors.Default;

            Application.DoEvents();
        }

        private void LoadProjectFromServer()
        {
            string errorMessage = string.Empty;

            try
            {

                for (int i = selectedProjectsDataGridView.Columns.Count - 1; i > 2; i--)
                {
                    selectedProjectsDataGridView.Columns.RemoveAt(i);
                }

                //  Add a column for each displayed custom field 
                foreach (KeyValuePair<Guid, string> displayedCustomField in _DisplayedCustomFields)
                {
                    DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn();

                    column.Tag = displayedCustomField.Key;
                    column.HeaderText = displayedCustomField.Value;

                    selectedProjectsDataGridView.Columns.Add(column);
                }

                char listSeparator = _ProjectServer.Settings.ListSeparator;

                //  Roll through each project and unpack the custom fiels
                foreach (Guid projectGuid in _ProjectServer.Projects)
                {
                    if (Cancel)
                    {
                        return;
                    }

                    Application.DoEvents();

                    List<object> values = new List<object>();

                    values.Add(projectGuid);    //  First column is UID

                    //  Second column is whether it is selected or not
                    if (_OriginallySelectedProjects == null)
                    {
                        values.Add(false);
                    }
                    else
                    {
                        values.Add(_OriginallySelectedProjects.Contains(projectGuid));
                    }

                    //  Third column is project name
                    values.Add(_ProjectServer.Projects[projectGuid].Name);

                    if (_DisplayedCustomFields.Count > 0)
                    {
                        ProjectCustomFieldsCollection fieldCollection = _ProjectServer.Projects[projectGuid].ProjectCustomFieldsCollection;

                        //  Remaining columns are custom fields
                        foreach (KeyValuePair<Guid, string> displayedCustomField in _DisplayedCustomFields)
                        {
                            if (Cancel)
                            {
                                return;
                            }

                            //  Check to see if the custom field value is defined for the current project
                            if (fieldCollection.ContainsKey(displayedCustomField.Key))
                            {
                                //  If List then create concatenated comma delimited string.  
                                if (fieldCollection[displayedCustomField.Key].IsList)
                                {
                                    string concatenatedValue = string.Empty;

                                    foreach (object listItem in fieldCollection[displayedCustomField.Key].List)
                                    {
                                        if (Cancel)
                                        {
                                            return;
                                        }

                                        concatenatedValue = concatenatedValue + listItem + listSeparator;
                                    }

                                    if (concatenatedValue != string.Empty)
                                    {
                                        concatenatedValue = concatenatedValue.Substring(0, concatenatedValue.Length - 1);
                                    }

                                    values.Add(concatenatedValue);
                                }
                                else
                                {
                                    //  Add the value to the list
                                    values.Add(fieldCollection[displayedCustomField.Key].Value);
                                }
                            }
                            else
                            {
                                //  Value is not defined for current project
                                values.Add(string.Empty);
                            }
                        }
                    }

                    //  Create the row
                    selectedProjectsDataGridView.Rows.Add(values.ToArray());
                }
            }
            catch (SoapException soapException)
            {
                errorMessage = Errors.ProcessMSProjectErrors(soapException);
            }
            catch (Exception exception)
            {
                errorMessage = exception.Message;
            }

            if (!string.IsNullOrEmpty(errorMessage))
            {
                MessageBox.Show(this,
                                string.Format("An error has occurred: {0}",
                                              errorMessage),
                                "Bels",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);
            }
        }

        private void LoadCachedProjects()
        {
            string errorMessage = string.Empty;

            try
            {
                ProjectsCache projectsCache = ProjectsCache.Deserialze(Path.Combine(Application.StartupPath,
                                                                                    "cache"));
                //  Add a column for each displayed custom field 
                bool cacheIsInvalid = false;

                //  Inspect the cache
                if (projectsCache.CachedCustomFields.Length != _DisplayedCustomFields.Count)
                {
                    cacheIsInvalid = true;
                }
                else
                {
                    foreach (KeyValuePair<Guid, string> displayedCustomField in _DisplayedCustomFields)
                    {
                        bool cachedCustomFieldLocated = false;

                        foreach (string cachedCustomField in projectsCache.CachedCustomFields)
                        {
                            string[] cachedCustomFieldLocatedComponents = cachedCustomField.Split('~');

                            if (cachedCustomFieldLocatedComponents.Length == 2)
                            {
                                cachedCustomFieldLocated = cachedCustomFieldLocatedComponents[0].Equals(displayedCustomField.Key.ToString(),
                                                                                                        StringComparison.InvariantCultureIgnoreCase);

                                if (cachedCustomFieldLocated)
                                {
                                    break;
                                }
                            }
                        }

                        if (!cachedCustomFieldLocated)
                        {
                            break;
                        }
                    }
                }

                if (cacheIsInvalid)
                {
                    //  Custom fields have changed, which invalidates the cache.
                    LoadProjectFromServer();
                    return;
                }
                foreach (string displayedCustomField in projectsCache.CachedCustomFields)
                {                    
                    string[] cachedCustomFieldLocatedComponents = displayedCustomField.Split('~');

                    if (cachedCustomFieldLocatedComponents.Length == 2)
                    {
                        DataGridViewTextBoxColumn column = new DataGridViewTextBoxColumn
                                                               {
                                                                   Tag = cachedCustomFieldLocatedComponents[0], 
                                                                   HeaderText = cachedCustomFieldLocatedComponents[1]
                                                               };

                        selectedProjectsDataGridView.Columns.Add(column);
                        
                    }
                }

                List<object> values = new List<object>();

                foreach (ProjectsCache.CachedProject cachedProject in projectsCache.CachedProjects)
                {
                    values.Add(cachedProject.Guid);

                    //  Second column is whether it is selected or not
                    if (_OriginallySelectedProjects == null)
                    {
                        values.Add(false);
                    }
                    else
                    {
                        values.Add(_OriginallySelectedProjects.Contains(cachedProject.Guid));
                    }
                    values.Add(cachedProject.Name);
                    values.AddRange(cachedProject.CustomFieldValues);

                    selectedProjectsDataGridView.Rows.Add(values.ToArray());
                    values.Clear();
                }
            }
            catch (IOException ioException)
            {
                errorMessage = ioException.Message;
            }
            catch (Exception exception)
            {
                errorMessage = exception.Message;
            }

            if (!string.IsNullOrEmpty(errorMessage))
            {
                MessageBox.Show(this,
                                string.Format("An error occurred while loading cached project information: {0}.  Loading from server.",
                                              errorMessage),
                                "Bels",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);

                LoadProjectFromServer();
            }
        }

        private void ProjectSelectionForm_Shown(object sender, EventArgs e)
        {
            LoadProjects(false);
        }

        private bool Cancel { get; set; }

        private void SaveCache()
        {
            string errorMessage = string.Empty;

            try
            {
                ProjectsCache projectsCache = new ProjectsCache(_DisplayedCustomFields, selectedProjectsDataGridView.Rows.Count);

                int counter = 0;

                foreach (DataGridViewRow row in selectedProjectsDataGridView.Rows)
                {
                    List<string> customFieldValues = new List<string>();

                    for (int i = 3; i < selectedProjectsDataGridView.Columns.Count; i++)
                    {
                        customFieldValues.Add(row.Cells[i].Value.ToString());
                    }

                    ProjectsCache.CachedProject cachedProject = new ProjectsCache.CachedProject(new Guid(row.Cells[0].Value.ToString()), row.Cells[2].Value.ToString(),
                                                                                                customFieldValues);

                    projectsCache.CachedProjects[counter++] = cachedProject;
                }

                ProjectsCache.Serialze(projectsCache,
                                       Path.Combine(Application.StartupPath,
                                                    "cache"));
            }
            catch (IOException ioException)
            {
                errorMessage = ioException.Message;
            }
            catch (Exception exception)
            {
                errorMessage = exception.Message;
            }

            if (!string.IsNullOrEmpty(errorMessage))
            {
                MessageBox.Show(this,
                                string.Format("An error occurred while caching project information: {0}",
                                              errorMessage),
                                "Bels",
                                MessageBoxButtons.OK,
                                MessageBoxIcon.Error);


                return;
            }

            return;
        }

        private void SetSelectedState(bool state)
        {
            foreach (DataGridViewRow row in selectedProjectsDataGridView.Rows)
            {
                row.Cells[1].Value = state;
            }
        }

        #endregion

        #region Event Handlers

        private void refreshToolStripButton_Click(object sender, EventArgs e)
        {
            LoadProjects(true);
        }

        private void okButton_Click(object sender, EventArgs e)
        {
            if (_UseCache)
            {
                SaveCache();
            }

            Close();
        }

        private void cancelButton_Click(object sender, EventArgs e)
        {
            Cancel = true;
        }

        private void selectAllToolStripButton_Click(object sender, EventArgs e)
        {
            SetSelectedState(true);
        }

        private void unselectAllToolStripButton_Click(object sender, EventArgs e)
        {
            SetSelectedState(false);
        }

        #endregion
    }
}

---