permissiondict.cs

破解的飞信源代码

namespace Imps.Client.Core
{
    using Imps.Client.Utils;
    using Imps.Common.Permission;
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Reflection;
    using System.Text;

    public class PermissionDict : ICollection<PermissionPointValue>, IEnumerable<PermissionPointValue>, IEnumerable, ICloneable
    {
        private List<PermissionPointValue> _col = new List<PermissionPointValue>();

        public void Add(PermissionPointValue item)
        {
            this._col.Add(item);
        }

        protected virtual void CalcFinalPointValue(PermissionPointValue ppv, PermissionManager manager)
        {
        }

        public void Clear()
        {
            this._col.Clear();
        }

        public PermissionDict Clone()
        {
            PermissionDict dict = new PermissionDict();
            if (this.Count > 0)
            {
                PermissionPointValue[] valueArray = new PermissionPointValue[this.Count];
                this._col.CopyTo(valueArray);
                dict._col.AddRange(valueArray);
            }
            dict.Sort();
            return dict;
        }

        public bool Contains(PermissionPointValue item)
        {
            return this._col.Contains(item);
        }

        public void CopyTo(PermissionDict target, PermissionManager manager)
        {
            target.UpdateValues(this.ToString(), manager);
        }

        public void CopyTo(PermissionPointValue[] array, int arrayIndex)
        {
            throw new NotSupportedException();
        }

        public IEnumerator<PermissionPointValue> GetEnumerator()
        {
            return this._col.GetEnumerator();
        }

        public string GetProposedValues()
        {
            StringBuilder builder = new StringBuilder();
            List<PermissionPointValue>.Enumerator enumerator = this._col.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    PermissionPointValue value2 = enumerator.get_Current();
                    if ((value2.Value != null) && value2.Value.HasProposedValue)
                    {
                        if (builder.Length > 0)
                        {
                            builder.Append(";");
                        }
                        builder.Append(PermissionPointNameHelper.PermissionPointName2Str(value2.PermissionPoint.PointName));
                        builder.Append("=");
                        builder.Append(value2.Value.ProposedValue);
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            return builder.ToString();
        }

        public void Parse(string values, PermissionManager manager)
        {
            this.Clear();
            this.UpdateValues(values, manager);
        }

        public bool Remove(PermissionPointValue item)
        {
            return this._col.Remove(item);
        }

        public void Sort()
        {
            this._col.Sort(new PermissionPointValueComparer());
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return this.GetEnumerator();
        }

        object ICloneable.Clone()
        {
            return this.Clone();
        }

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            List<PermissionPointValue>.Enumerator enumerator = this._col.GetEnumerator();
            try
            {
                while (enumerator.MoveNext())
                {
                    PermissionPointValue value2 = enumerator.get_Current();
                    if (value2.Value != null)
                    {
                        if (builder.Length > 0)
                        {
                            builder.Append(";");
                        }
                        builder.Append(PermissionPointNameHelper.PermissionPointName2Str(value2.PermissionPoint.PointName));
                        builder.Append("=");
                        builder.Append(value2.Value.OriginalValue);
                    }
                }
            }
            finally
            {
                enumerator.Dispose();
            }
            return builder.ToString();
        }

        public virtual void UpdateValues(string values, PermissionManager manager)
        {
            if (!string.IsNullOrEmpty(values))
            {
                foreach (string text in values.Split(new char[] { ';' }))
                {
                    string[] textArray2 = text.Split(new char[] { '=' });
                    if (textArray2.Length == 2)
                    {
                        PermissionPointName name = PermissionPointNameHelper.Str2PermissionPointName(textArray2[0].Trim());
                        PermissionPointValue item = this[name];
                        if (item == null)
                        {
                            item = new PermissionPointValue(new PermissionPoint(name));
                            this.Add(item);
                        }
                        item.Value = new ProposedData<int>(int.Parse(textArray2[1].Trim()));
                        this.CalcFinalPointValue(item, manager);
                    }
                }
                this.Sort();
            }
        }

        public int Count
        {
            get
            {
                return this._col.get_Count();
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public PermissionPointValue this[PermissionPointName name]
        {
            get
            {
                int num = this._col.BinarySearch(new PermissionPointValue(new PermissionPoint(name)), new PermissionPointValueComparer());
                if (num < 0)
                {
                    return null;
                }
                return this[num];
            }
            set
            {
                int num = this._col.BinarySearch(new PermissionPointValue(new PermissionPoint(name)), new PermissionPointValueComparer());
                if (num < 0)
                {
                    this.Add(value);
                    this.Sort();
                }
                else
                {
                    this[num] = value;
                }
            }
        }

        public PermissionPointValue this[int index]
        {
            get
            {
                if (index >= 0)
                {
                    return this._col.get_Item(index);
                }
                return null;
            }
            set
            {
                this._col.set_Item(index, value);
            }
        }

        public PermissionPointValue PermissionPointBirthday
        {
            get
            {
                return this[PermissionPointName.Birthday];
            }
        }

        public PermissionPointValue PermissionPointBuddy
        {
            get
            {
                return this[PermissionPointName.Buddy];
            }
        }

        public PermissionPointValue PermissionPointBusiness
        {
            get
            {
                return this[PermissionPointName.Business];
            }
        }

        public PermissionPointValue PermissionPointContact
        {
            get
            {
                return this[PermissionPointName.Contact];
            }
        }

        public PermissionPointValue PermissionPointEmail
        {
            get
            {
                return this[PermissionPointName.Email];
            }
        }

        public PermissionPointValue PermissionPointIdentity
        {
            get
            {
                return this[PermissionPointName.Identity];
            }
        }

        public PermissionPointValue PermissionPointIvr
        {
            get
            {
                return this[PermissionPointName.Ivr];
            }
        }

        public PermissionPointValue PermissionPointLocation
        {
            get
            {
                return this[PermissionPointName.Location];
            }
        }

        public PermissionPointValue PermissionPointPhone
        {
            get
            {
                return this[PermissionPointName.Phone];
            }
        }

        public PermissionPointValue PermissionPointPresence
        {
            get
            {
                return this[PermissionPointName.Presence];
            }
        }

        private class PermissionPointValueComparer : IComparer<PermissionPointValue>
        {
            public int Compare(PermissionPointValue x, PermissionPointValue y)
            {
                if (x == null)
                {
                    if (y == null)
                    {
                        return 0;
                    }
                    return -1;
                }
                if (y == null)
                {
                    return 1;
                }
                return ((int) x.PermissionPoint.PointName).CompareTo((int) y.PermissionPoint.PointName);
            }
        }
    }
}