C:/Data/Projects/MCS EPM Global Practice/Frameworks/Public/mpfX/1.0/Libraries/Mcs.Epm.MicrosoftProject.mpFx/LookupTables.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.Globalization;
using Mcs.Epm.MicrosoftProject.mpFx.LookupTablesWebService;

namespace Mcs.Epm.MicrosoftProject.mpFx
{
    /// <summary>
    /// Provides data and functionality for working with enterprise lookup tables
    /// </summary>
    public class LookupTables
    {
        #region Instance Data

        private readonly ProjectServer _Parent;
        private bool _CacheLookupTables;
        private Dictionary<Guid, LookupTableMultiLangDataSet.LookupTableValuesDataTable> _MultiLanguageLookupTableValues;

        #endregion

        #region Constructors

        /// <summary>
        /// Create an instance of LookupTables
        /// </summary>
        /// <param name="parent">Parent Object</param>
        /// <param name="cacheLookupTables">Indicates whether lookup tables will be cached.</param>
        internal LookupTables(ProjectServer parent,
                              bool cacheLookupTables)
        {
            if (parent == null)
            {
                throw new ArgumentNullException( /*  TODO: Exception Message  */);
            }

            _Parent = parent;

            CacheLookupTables = cacheLookupTables;
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Get and set whether lookup tables are cached
        /// </summary>
        public bool CacheLookupTables
        {
            get { return _CacheLookupTables; }

            set
            {
                _CacheLookupTables = value;

                if (value == false)
                {
                    _MultiLanguageLookupTableValues.Clear();
                    _MultiLanguageLookupTableValues = null;
                }
                else
                {
                    _MultiLanguageLookupTableValues = new Dictionary<Guid, LookupTableMultiLangDataSet.LookupTableValuesDataTable>();
                }
            }
        }

        #endregion

        #region Public Methods

        /// <summary>
        /// Get lookup tables from Project Server
        /// </summary>
        /// <param name="xmlFilter">Filter string</param>
        /// <param name="autoCheckout">Indicates whether or not the lookup table will be automatically checked out.</param>
        /// <returns></returns>
        public LookupTableMultiLangDataSet MultiLangGetLookupTables(string xmlFilter,
                                                                    bool autoCheckout)
        {
            return _Parent.WebServices.LookupTables.ReadLookupTablesMultiLang(xmlFilter, autoCheckout);
        }

        public LookupTableDataSet GetLookupTables(string xmlFilter,
                                                  bool autoCheckout,
                                                  int lcid)
        {
            return _Parent.WebServices.LookupTables.ReadLookupTables(xmlFilter, autoCheckout, lcid);
        }

        /// <summary>
        /// Get lookup table values from the cache or Project Server
        /// </summary>
        /// <param name="lookupTableGuid">The lookup table's GUID</param>
        /// <param name="xmlFilter">The XML filter indicating which columns to retrieve</param>
        /// <returns></returns>
        public LookupTableMultiLangDataSet.LookupTableValuesDataTable MultiLangLoadLookupTableValues(Guid lookupTableGuid,
                                                                                                     string xmlFilter)
        {
            if (_CacheLookupTables)
            {
                if (_MultiLanguageLookupTableValues.ContainsKey(lookupTableGuid))
                {
                    return _MultiLanguageLookupTableValues[lookupTableGuid];
                }
            }

            LookupTableMultiLangDataSet.LookupTableValuesDataTable valuesTable = MultiLangGetLookupTableValues(xmlFilter, false);

            if (_CacheLookupTables)
            {
                _MultiLanguageLookupTableValues.Add(lookupTableGuid, valuesTable);
            }

            return valuesTable;
        }

        /// <summary>
        /// Get lookup table values from Project Server
        /// </summary>
        /// <param name="xmlFilter">Indicates which columns to retrieve</param>
        /// <param name="autoCheckout">Indicates whether the lookup table will be checked out.</param>
        /// <returns>LookupTableMultiLangDataSet.LookupTableValuesDataTable populated with the lookup table values</returns>
        public LookupTableMultiLangDataSet.LookupTableValuesDataTable MultiLangGetLookupTableValues(string xmlFilter,
                                                                                                    bool autoCheckout)
        {
            using (LookupTableMultiLangDataSet lookupTableMultiLangDataSet = MultiLangGetLookupTables(xmlFilter, autoCheckout))
            {
                return lookupTableMultiLangDataSet.LookupTableValues;
            }
        }

        /// <summary>
        /// Given a lookup table values table and a value, return the items GUID
        /// </summary>
        /// <param name="value">The value to search for</param>
        /// <param name="lookupTable">The lookup table to search in</param>
        /// <returns>Guid of item if found or Guid.Empty if not found.</returns>
        public static Guid FindInLookupTable(string value,
                                             LookupTableMultiLangDataSet.LookupTableValuesDataTable lookupTable)
        {
            value = value.Trim().ToUpper(CultureInfo.InvariantCulture);

            if (! string.IsNullOrEmpty(value))
            {
                foreach (LookupTableMultiLangDataSet.LookupTableValuesRow row in lookupTable.Rows)
                {
                    if (row.LT_VALUE_TEXT.ToUpper(CultureInfo.InvariantCulture) == value)
                    {
                        return row.LT_STRUCT_UID;
                    }
                }
            }

            return Guid.Empty;
        }

        /// <summary>
        /// Given a lookup table GUID and a value GUID, return its string value
        /// </summary>
        /// <param name="lookupTableGuid">The lookup table's GUID</param>
        /// <param name="valueGuid">The value's GUID</param>
        /// <param name="languageCode">The language code for which the value GUID's value should be returned</param>
        /// <returns></returns>
        public string MultiLangGetLookupTableTextValue(Guid lookupTableGuid,
                                                       Guid valueGuid,
                                                       int languageCode)
        {
            using (
                LookupTableMultiLangDataSet.LookupTableValuesDataTable lookupTableValues = MultiLangLoadLookupTableValues(lookupTableGuid,
                                                                                                                          LookupTableFilters.ItemBasicInformation(lookupTableGuid)))
            {
                if (lookupTableValues == null)
                {
                    throw new ArgumentNullException( /*  TODO: Exception Message */);
                }

                LookupTableMultiLangDataSet.LookupTableValuesRow valuesTable = lookupTableValues.FindByLT_STRUCT_UIDLCID(valueGuid, languageCode);

                if (valuesTable == null)
                {
                    throw new InvalidOperationException( /*  TODO: Exception Message */);
                }

                return valuesTable.LT_VALUE_TEXT;
            }
        }

        public void AddLookupTableTextValue(Guid lookupTableGuid, Guid valueGuid, string value, int lcid)
        {
            LookupTableMultiLangDataSet lookupTableDataSet = null;
            bool checkedOut = false;

            try
            {
                lookupTableDataSet = _Parent.WebServices.LookupTables.ReadLookupTablesMultiLangByUids(new[] { lookupTableGuid }, true);

                checkedOut = true;

                LookupTableMultiLangDataSet.LookupTableStructuresRow structureRow = lookupTableDataSet.LookupTableStructures.NewLookupTableStructuresRow();
                structureRow.LT_UID = lookupTableGuid;

                structureRow.LT_STRUCT_UID = valueGuid;
                lookupTableDataSet.LookupTableStructures.Rows.Add(structureRow);

                LookupTableMultiLangDataSet.LookupTableValuesRow newValue = lookupTableDataSet.LookupTableValues.NewLookupTableValuesRow();

                newValue.LCID = lcid;
                newValue.LT_VALUE_TEXT = value;
                newValue.LT_STRUCT_UID = structureRow.LT_STRUCT_UID;

                newValue.LT_VALUE_SORT_INDEX = lookupTableDataSet.LookupTables[0].LT_SORT_ORDER_ENUM;

                lookupTableDataSet.LookupTableValues.AddLookupTableValuesRow(newValue);

                _Parent.WebServices.LookupTables.UpdateLookupTablesMultiLang(lookupTableDataSet, false, true);

                checkedOut = false;
            }
            finally
            {
                if (lookupTableDataSet != null)
                {
                    lookupTableDataSet.Dispose();
                }

                if (checkedOut)
                {
                    try
                    {
                        _Parent.WebServices.LookupTables.CheckInLookupTables(new[] { lookupTableGuid }, true);
                    }
                    catch
                    {
                        /*  Swallow  */
                    }
                }
            }
        }

        public Guid GetTextLookupTableValueGuid(Guid lookupTableGuid, string value)
        {
            using (LookupTableMultiLangDataSet.LookupTableValuesDataTable valuesTable = MultiLangLoadLookupTableValues(lookupTableGuid, string.Empty))
            {
                return FindInLookupTable(value, valuesTable);
            }
        }

        #endregion
    }
}

---