C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/GraphicalIndicator.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;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using Microsoft.Office.Project.Server.Library;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Wraps Project's Graphical Indicator criteria string
    /// </summary>
    public class GraphicalIndicator
    {
        #region Constants

        public static readonly int MAX_NUMBER_OF_CRITERIA = 3;
        public static readonly int MAX_IMAGE_INDEX = 65;

        #endregion

        #region Instance Data

        private static readonly Dictionary<string, string> _Tests = new Dictionary<string, string>();
        private readonly Dictionary<int, Criteria> _ProjectSummaryCriteria = new Dictionary<int, Criteria>();
        private readonly Dictionary<int, Criteria> _SummaryCriteria = new Dictionary<int, Criteria>();
        private readonly Dictionary<int, Criteria> _NonSummaryCriteria = new Dictionary<int, Criteria>();

        #endregion

        #region Enums

        public enum CriteriaFor
        {
            None,
            NonSummaryRows,
            ProjectSummary,
            Summary
        }

        #endregion

        #region Constructor

        /// <summary>
        /// Create an instance of GraphicalIndicator
        /// </summary>
        /// <param name="entityGuid">The GUID of the entity (Project, Task, Resource)</param>
        /// <param name="customField">The CustomField definition of the field for which the Graphical Indicator will be associated with</param>
        /// <param name="customFieldType">The custom field type (Cost, Date, Duration, Flag, Number, and Text</param>
        public GraphicalIndicator(Guid entityGuid,
                                  CustomFieldDefinition customField,
                                  CustomField.Type customFieldType)
        {
            if (customField == null)
            {
                throw new ArgumentNullException("customField");
            }

            if (entityGuid == Guid.Empty || !IsValidEntityForGraphicalIndicator(entityGuid))
            {
                throw new ArgumentException("Invalid entity Guid");
            }

            if (customFieldType == CustomField.Type.FINISHDATE)
            {
                throw new ArgumentException("Invalid custom field type");
            }

            EntityGuid = entityGuid;
            CustomFieldDefinition = customField;
            CustomFieldType = customFieldType;

            LoadTests();

            UnpackCustomField();
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Add criteria to a specific type (Non Summary Rows,Project Summary, and Summary)
        /// </summary>
        /// <param name="criteriaFor">Designates which criteria collection the criteria will be added to</param>
        /// <param name="criteria">The criteria to add</param>
        public void AddCriteria(CriteriaFor criteriaFor,
                                Criteria criteria)
        {
            if (criteria.ImageIndex == 0)
            {
                throw new ArgumentException("criteria");
            }

            if (string.IsNullOrEmpty(criteria.Test))
            {
                throw new ArgumentException("criteria");
            }

            if (string.IsNullOrEmpty(criteria.Value))
            {
                throw new ArgumentException("criteria");
            }

            Dictionary<int, Criteria> thisCollection;

            switch (criteriaFor)
            {
                case CriteriaFor.None:
                    throw new ArgumentException("criteria");

                case CriteriaFor.NonSummaryRows:
                    thisCollection = _NonSummaryCriteria;
                    break;

                case CriteriaFor.ProjectSummary:
                    thisCollection = _ProjectSummaryCriteria;
                    break;

                case CriteriaFor.Summary:
                    thisCollection = _SummaryCriteria;
                    break;

                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }

            Debug.Assert(thisCollection != null);

            if (thisCollection.Count + 1 > MAX_NUMBER_OF_CRITERIA)
            {
                throw new IndexOutOfRangeException();
            }

            thisCollection.Add(criteria.Index, criteria);
        }

        /// <summary>
        /// Retrieve the criteria for the given type at the given index
        /// </summary>
        /// <param name="criteriaFor">Designates which criteria collection to retrieve from</param>
        /// <param name="index">The index of the criteria</param>
        /// <returns>The requested criteria</returns>
        public Criteria GetCriteria(CriteriaFor criteriaFor,
                                    int index)
        {
            switch (criteriaFor)
            {
                case CriteriaFor.NonSummaryRows:
                    return _NonSummaryCriteria[index];
                case CriteriaFor.ProjectSummary:
                    return _ProjectSummaryCriteria[index];
                case CriteriaFor.Summary:
                    return _SummaryCriteria[index];
                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }
        }

        /// <summary>
        /// Returns the criteria string for the specified criteria type
        /// </summary>
        /// <param name="criteriaFor">Designates which criteria should be render as the return string</param>
        /// <returns>The criteria string</returns>
        public string GetCriteriaString(CriteriaFor criteriaFor)
        {
            Dictionary<int, Criteria> thisCollection;

            switch (criteriaFor)
            {
                case CriteriaFor.NonSummaryRows:
                    thisCollection = _NonSummaryCriteria;
                    break;
                case CriteriaFor.ProjectSummary:
                    thisCollection = _ProjectSummaryCriteria;
                    break;
                case CriteriaFor.Summary:
                    thisCollection = _SummaryCriteria;
                    break;
                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }

            StringBuilder criteriaString = new StringBuilder();

            foreach (KeyValuePair<int, Criteria> pair in thisCollection)
            {
                criteriaString.AppendFormat("[[{0}\t{1}\t\t][{2}]]", 
                                            _Tests[pair.Value.Test], 
                                            pair.Value.Value, 
                                            pair.Value.ImageIndex);
            }

            return criteriaString.ToString();
        }

        /// <summary>
        /// Given a specific criteria type, return the count of criteria
        /// </summary>
        /// <param name="criteriaFor">The criteria type</param>
        /// <returns>The count</returns>
        public int GetCount(CriteriaFor criteriaFor)
        {
            switch (criteriaFor)
            {
                case CriteriaFor.NonSummaryRows:
                    return _NonSummaryCriteria.Count;
                case CriteriaFor.ProjectSummary:
                    return _ProjectSummaryCriteria.Count;
                case CriteriaFor.Summary:
                    return _SummaryCriteria.Count;
                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }
        }

        /// <summary>
        /// Given a specific criteria type, clear its criteria
        /// </summary>
        /// <param name="criteriaFor">The criteria type to clear</param>
        public void ClearCriteria(CriteriaFor criteriaFor)
        {
            switch (criteriaFor)
            {
                case CriteriaFor.None:
                    break;
                case CriteriaFor.NonSummaryRows:
                    _NonSummaryCriteria.Clear();
                    break;
                case CriteriaFor.ProjectSummary:
                    _ProjectSummaryCriteria.Clear();
                    break;
                case CriteriaFor.Summary:
                    _SummaryCriteria.Clear();
                    break;
                default:
                    throw new ArgumentOutOfRangeException("criteriaFor");
            }
        }

        /// <summary>
        /// Parses the criteria string
        /// </summary>
        /// <param name="criteriaString"></param>
        /// <returns>A stack representing the individual criteria components </returns>
        public Stack ParseCriteriaString(string criteriaString)
        {
            /*  The criteria string format is as follows 
             *  Brackets arrange to appear like code for readability.
             *  See sample below for what the string looks like):              
             *  [    
             *      [
             *          <test> \t <value> \t\t
             *      ]
             *      [
             *          <image index>
             *      ]
             *  ]
             *  [
             *      [
             *          <test> \t <value> \t\t 
             *      ]
             *      [
             *          <image index>
             *      ]
             *  ]
             *  ... Up to three criteria
             *  
             *  Here is a sample:
             *  
             *  [[DoesntContain\ttest\t\t][63]][[==\t10\t\t][1]][[==\t12\t\t][3]]
             *  
             */
            Regex tokenizer = new Regex(@"\[(?<Tokens>([^\]])*)\]");
            MatchCollection tokens = tokenizer.Matches(criteriaString);
            Stack criteria = new Stack();

            for (int matchCount = 0; matchCount < tokens.Count; matchCount++)
            {
                string token = tokens[matchCount].Value;

                token = token.Replace("[", "");
                token = token.Replace("]", "");

                token = token.Trim();

                string[] components = token.Split('\t');

                for (int i = 0; i < components.Length; i++)
                {
                    criteria.Push(components[i]);
                }
            }

            return criteria;
        }

        /// <summary>
        /// Given a specific test string (for example '==' or '!='), 
        /// return its display name (equals or does not equal)
        /// </summary>
        /// <param name="testString">The test string to look up</param>
        /// <returns>The display name of the test string</returns>
        public static string GetDisplayName(string testString)
        {
            foreach (KeyValuePair<string, string> test in _Tests)
            {
                if (test.Value.Equals(testString, 
                                      StringComparison.CurrentCultureIgnoreCase)) {
                    return test.Key;
                }
            }

            return null;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Retrieve an error of the tests' display names
        /// </summary>
        public string[] TestsDisplayNames
        {
            get
            {
                string[] testDisplayNames = new string[_Tests.Keys.Count];

                _Tests.Keys.CopyTo(testDisplayNames, 0);

                return testDisplayNames;
            }
        }

        /// <summary>
        /// Retrieve and privately set the Graphical Indicator's underlying entity GUID
        /// </summary>
        public Guid EntityGuid { get; private set; }

        /// <summary>
        /// Retrieve and privately set the CustomField type
        /// </summary>
        public CustomField.Type CustomFieldType { get; private set; }

        /// <summary>
        /// Retrieve the count of Project Summary criteria
        /// </summary>
        public int ProjectSummaryCriteriaCount
        {
            get { return _ProjectSummaryCriteria.Count; }
        }

        /// <summary>
        /// Retrieve the count of Summary criteria
        /// </summary>
        public int SummaryCriteriaCount
        {
            get { return _SummaryCriteria.Count; }
        }

        /// <summary>
        /// Retrieve the count of Non Summary criteria
        /// </summary>
        public int NonSummaryCriteriaCount
        {
            get { return _NonSummaryCriteria.Count; }
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Unpack the criteria in the custom field definition, which is in Project Server format
        /// into Criteria collections
        /// </summary>
        private void UnpackCustomField()
        {
            if (!string.IsNullOrEmpty(CustomFieldDefinition.NonSummaryCriteriaString))
            {
                Stack components = ParseCriteriaString(CustomFieldDefinition.NonSummaryCriteriaString);

                AddCriteria(CriteriaFor.NonSummaryRows, components);
            }

            if (!string.IsNullOrEmpty(CustomFieldDefinition.ProjectSummaryCriteriaString))
            {
                Stack components = ParseCriteriaString(CustomFieldDefinition.ProjectSummaryCriteriaString);

                AddCriteria(CriteriaFor.ProjectSummary, components);
            }

            if (!string.IsNullOrEmpty(CustomFieldDefinition.SummaryTaskCriteriaString))
            {
                Stack components = ParseCriteriaString(CustomFieldDefinition.SummaryTaskCriteriaString);

                AddCriteria(CriteriaFor.Summary, components);
            }
        }

        /// <summary>
        /// Adds criteria from a stack of criteria components (returned by ParseCriteriaString
        /// </summary>
        /// <param name="criteriaFor">The criteria types</param>
        /// <param name="criteriaComponents">The stack of criteria components</param>
        private void AddCriteria(CriteriaFor criteriaFor,
                                 Stack criteriaComponents)
        {
            int operationsCount = criteriaComponents.Count;

            // Three components per criteria: image index, value, and test 
            for (int counter = 0; counter < operationsCount/3; counter++)
            {
                Criteria criteria = new Criteria(Convert.ToInt32(criteriaComponents.Pop()),
                                                 criteriaComponents.Pop().ToString(), 
                                                 GetDisplayName(criteriaComponents.Pop().ToString()), counter);

                AddCriteria(criteriaFor, criteria);
            }
        }

        // Load the static list of tests and each test's corresponding Project Server token
        private static void LoadTests()
        {
            if (_Tests.Count == 0)
            {
                _Tests.Add("equals", "==");
                _Tests.Add("does not equal", "!=");
                _Tests.Add("is greater than", ">");
                _Tests.Add("is greater than or equal to", ">=");
                _Tests.Add("is less than", "<");
                _Tests.Add("is less than or equal to", "<=");
                _Tests.Add("is within", "Between");
                _Tests.Add("is not within", "NotBetween");
                _Tests.Add("contains", "Contains");
                _Tests.Add("doesn't contain", "DoesntContain");
                _Tests.Add("contains exactly", "ContainsExactly");
                _Tests.Add("any value", "ANY");
            }
        }

        /// <summary>
        /// Given a entity g|Euid, determine whether or not a graphical indicator can be associated with the 
        /// custom field
        /// </summary>
        /// <param name="entity">The entity's GUID</param>
        /// <returns>True if Project, Task, or Resource; false otherwise</returns>
        private static bool IsValidEntityForGraphicalIndicator(Guid entity)
        {
            string entityString = entity.ToString().ToLower();

            return (entityString == Utilities.GetEntityGuidStringFromName("Project").ToLower() ||
                    entityString == Utilities.GetEntityGuidStringFromName("Task").ToLower() ||
                    entityString == Utilities.GetEntityGuidStringFromName("Resource").ToLower());
        }

        #endregion

        #region Private Properties

        /// <summary>
        /// Retrieve the Graphical Indicator's associated CustomFieldDefinition
        /// </summary>
        private CustomFieldDefinition CustomFieldDefinition { get; set; }

        #endregion

        #region Classes

        /// <summary>
        /// A very simple wrapper around Project Server's graphical indicator
        /// </summary>
        public class Criteria
        {
            /// <summary>
            /// Construct an instance of Criteria
            /// </summary>
            /// <param name="imageIndex">The image index</param>
            /// <param name="value">The value to test</param>
            /// <param name="test">The test</param>
            /// <param name="index">The index (or ordinal) of the criteria</param>
            public Criteria(int imageIndex,
                            string value,
                            string test,
                            int index)
            {
                Index = index;
                ImageIndex = imageIndex;
                Test = test;
                Value = value;
            }

            /// <summary>
            /// Auto properties for instance data
            /// </summary>
            public int Index { get; private set; }

            public int ImageIndex { get; private set; }
            public string Value { get; private set; }
            public string Test { get; private set; }
        }

        #endregion
    }
}

---