AcUsers.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.DirectoryServices;
using System.DirectoryServices.AccountManagement;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace AcUtils
{

    [Serializable]
    [TypeDescriptionProvider(typeof(PrncplDescriptionProvider))]
    public sealed class AcUser : IFormattable, IEquatable<AcUser>, IComparable<AcUser>, IComparable
    {
        #region class variables
        private AcPrincipal _principal = new AcPrincipal();
        private string _givenName; // John
        private string _middleName;
        private string _surname; // Doe
        private string _displayName; // Doe, John
        private string _business; // business phone number
        private string _emailAddress; // John.Doe@VerizonWireless.com
        private string _description;
        private string _distinguishedName;
        // [title,value] pairs for user properties outside the default set
        private Dictionary<string, object> _other = new Dictionary<string, object>();
        #endregion


        internal AcUser(int id, string name, PrinStatus status)
        {
            _principal.ID = id;
            _principal.Name = name;
            _principal.Status = status;
        }

        #region Equality comparison

        public bool Equals(AcUser other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            return Principal.ID == other.Principal.ID;
        }

        public override bool Equals(object other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            if (GetType() != other.GetType()) return false;
            return this.Equals(other as AcUser);
        }

        public override int GetHashCode()
        {
            return Principal.ID;
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcUser other)
        {
            int result;
            if (AcUser.ReferenceEquals(this, other))
                result = 0;
            else
            {
                if (!String.IsNullOrEmpty(DisplayName) && !String.IsNullOrEmpty(other.DisplayName))
                    result = String.Compare(DisplayName, other.DisplayName);
                else
                    result = String.Compare(Principal.Name, other.Principal.Name);
            }

            return result;
        }

        int IComparable.CompareTo(object other)
        {
            if (!(other is AcUser))
                throw new ArgumentException("Argument is not an AcUser", "other");
            AcUser o = (AcUser)other;
            return this.CompareTo(o);
        }
        #endregion

        public AcPrincipal Principal
        {
            get { return _principal; }
        }

        public string GivenName
        {
            get { return _givenName ?? String.Empty; }
        }

        public string MiddleName
        {
            get { return _middleName ?? String.Empty; }
        }

        public string Surname
        {
            get { return _surname ?? String.Empty; }
        }

        public string DisplayName
        {
            get { return _displayName ?? String.Empty; }
        }

        public string Business
        {
            get { return _business ?? String.Empty; }
        }

        public string EmailAddress
        {
            get { return _emailAddress ?? String.Empty; }
        }

        public string Description
        {
            get { return _description ?? String.Empty; }
        }

        public string DistinguishedName
        {
            get { return _distinguishedName ?? String.Empty; }
        }

        public IDictionary<string, object> Other
        {
            get { return _other; }
        }

        #region ToString
        public string ToString(string format, IFormatProvider provider)
        {
            if (provider != null)
            {
                ICustomFormatter fmt = provider.GetFormat(this.GetType()) as ICustomFormatter;
                if (fmt != null)
                    return fmt.Format(format, this, provider);
            }

            if (String.IsNullOrEmpty(format))
                format = "G";

            switch (format.ToUpperInvariant())
            {
                case "G": // user's display name from Active Directory if available, otherwise their AccuRev principal name
                    return _displayName ?? Principal.Name;
                case "LV": // long version (verbose)
                    return $"{DisplayName} ({Principal.Name}), Business: {(String.IsNullOrEmpty(Business) ? "N/A" : Business)}, {EmailAddress}";
                case "I": // user's AccuRev principal ID
                    return Principal.ID.ToString();
                case "N": // user's AccuRev principal name
                    return Principal.Name;
                case "S": // principal's status in AccuRev: Active or Inactive
                    return Principal.Status.ToString();
                case "F": // user's given name from Active Directory
                    return GivenName;
                case "M": // user's middle name from Active Directory
                    return MiddleName;
                case "L": // user's surname from Active Directory
                    return Surname;
                case "DN": // user's display name from Active Directory
                    return DisplayName;
                case "B": // business phone number from Active Directory
                    return Business;
                case "E": // user's email address from Active Directory
                    return EmailAddress;
                case "D": // description from Active Directory
                    return Description;
                case "DG": // distinguished name from Active Directory
                    return DistinguishedName;
                default:
                    throw new FormatException($"The {format} format string is not supported.");
            }
        }

        // Calls ToString(string, IFormatProvider) version with a null IFormatProvider argument.
        public string ToString(string format)
        {
            return ToString(format, null);
        }

        // Calls ToString(string, IFormatProvider) version with the general format and a null IFormatProvider argument.
        public override string ToString()
        {
            return ToString("G", null);
        }
        #endregion ToString


        internal async Task<bool> initFromADAsync(DomainCollection dc, PropCollection pc = null)
        {
            return await Task.Run(() =>
            {
                bool ret = true; // assume success
                foreach (DomainElement de in dc)
                {
                    PrincipalContext ad = null;
                    try
                    {
                        ad = new PrincipalContext(ContextType.Domain, de.Host.Trim(), de.Path.Trim());
                        UserPrincipal up = new UserPrincipal(ad);
                        up.SamAccountName = Principal.Name;
                        using (PrincipalSearcher ps = new PrincipalSearcher(up))
                        {
                            UserPrincipal rs = (UserPrincipal)ps.FindOne();
                            if (rs != null)
                            {
                                _givenName = rs.GivenName;
                                _middleName = rs.MiddleName;
                                _surname = rs.Surname;
                                _displayName = rs.DisplayName;
                                _business = rs.VoiceTelephoneNumber;
                                _emailAddress = rs.EmailAddress;
                                _description = rs.Description;
                                _distinguishedName = rs.DistinguishedName;
                                
                                if (pc != null)
                                {
                                    DirectoryEntry lowerLdap = (DirectoryEntry)rs.GetUnderlyingObject();
                                    foreach (PropElement pe in pc)
                                    {
                                        PropertyValueCollection pvc = lowerLdap.Properties[pe.Field];
                                        if (pvc != null)
                                            _other.Add(pe.Title.Trim(), pvc.Value);
                                    }
                                }

                                break;
                            }
                        }
                    }

                    catch (Exception ecx)
                    {
                        ret = false;
                        AcDebug.Log($"Exception caught and logged in AcUser.initFromADAsync{Environment.NewLine}{ecx.Message}");
                    }

                    // avoid CA2202: Do not dispose objects multiple times
                    finally { if (ad != null) ad.Dispose(); }
                }

                return ret;
            }).ConfigureAwait(false);
        }


        internal async Task<bool> initGroupsListAsync()
        {
            bool ret = false; // assume failure
            try
            {
                // works for inactive users too
                AcResult r = await AcCommand.runAsync($@"show -fx -u ""{Principal.Name}"" groups")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0) // if command succeeded
                {
                    SortedSet<string> members = new SortedSet<string>();
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("Element"))
                    {
                        string name = (string)e.Attribute("Name");
                        members.Add(name);
                    }

                    Principal.Members = members;
                    ret = true; // operation succeeded
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcUser.initGroupsListAsync{Environment.NewLine}{ecx.Message}");
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcUser.initGroupsListAsync{Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }


        public string getGroups()
        {
            string list = null;
            if (Principal.Members != null)
                list = String.Join(", ", Principal.Members);

            return list;
        }
    }


    [Serializable]
    public sealed class AcUsers : List<AcUser>
    {
        #region class variables
        private DomainCollection _dc;
        private PropCollection _pc; // user properties from Active Directory beyond the default set
        private bool _includeGroupsList;
        private bool _includeDeactivated;
        [NonSerialized] private readonly object _locker = new object(); // token for lock keyword scope
        [NonSerialized] private int _counter; // used to report initialization progress back to the caller
        #endregion

        #region object construction:


        public AcUsers(DomainCollection dc = null, PropCollection pc = null, bool includeGroupsList = false, bool includeDeactivated = false)
        {
            _dc = dc;
            _pc = pc;
            _includeGroupsList = includeGroupsList;
            _includeDeactivated = includeDeactivated;
        }


        public async Task<bool> initAsync(IProgress<int> progress = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync($"show {(_includeDeactivated ? "-fix" : "-fx")} users")
                    .ConfigureAwait(false);
                if (r != null && r.RetVal == 0) // if command succeeded
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    IEnumerable<XElement> query = from element in xml.Elements("Element") select element;
                    List<Task<bool>> tasks = new List<Task<bool>>(query.Count());
                    Func<Task<bool>, bool> cf = t =>
                    {
                        bool res = t.Result;
                        if (res && progress != null) progress.Report(Interlocked.Increment(ref _counter));
                        return res;
                    };

                    foreach (XElement e in query)
                    {
                        string name = (string)e.Attribute("Name");
                        int id = (int)e.Attribute("Number");
                        // XML attribute isActive exists only if the user is inactive, otherwise it isn't there
                        PrinStatus status = (e.Attribute("isActive") == null) ? PrinStatus.Active : PrinStatus.Inactive;
                        AcUser user = new AcUser(id, name, status);
                        lock (_locker) { Add(user); }
                        Task<bool> t = initUserPropsAsync(user).ContinueWith(cf);
                        tasks.Add(t);
                    }

                    bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                    ret = (arr != null && arr.All(n => n == true));
                }
            }

            catch (AcUtilsException ecx)
            {
                AcDebug.Log($"AcUtilsException caught and logged in AcUsers.initAsync{Environment.NewLine}{ecx.Message}");
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcUsers.initAsync{Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }
        #endregion

        private async Task<bool> initUserPropsAsync(AcUser user)
        {
            bool ret = false; // assume failure
            try
            {
                if (_dc != null && _includeGroupsList)
                {
                    Task<bool>[] tasks = new Task<bool>[2];
                    // initialize default set and other user properties from Active Directory
                    tasks[0] = user.initFromADAsync(_dc, _pc);
                    // include group membership list initialization
                    tasks[1] = user.initGroupsListAsync();
                    bool[] arr = await Task.WhenAll(tasks).ConfigureAwait(false);
                    ret = (arr != null && arr.All(n => n == true));
                }
                else if (_dc != null && !_includeGroupsList)
                    ret = await user.initFromADAsync(_dc, _pc).ConfigureAwait(false);
                else if (_dc == null && _includeGroupsList)
                    ret = await user.initGroupsListAsync().ConfigureAwait(false);
                else // _dc == null && !_includeGroupsList
                    ret = true; // nothing to do
            }

            catch (Exception ecx)
            {
                AcDebug.Log($"Exception caught and logged in AcUsers.initUserPropsAsync{Environment.NewLine}{ecx.Message}");
            }

            return ret;
        }

        public AcUser getUser(string name)
        {
            return this.SingleOrDefault(n => n.Principal.Name == name);
        }

        public AcUser getUser(int ID)
        {
            return this.SingleOrDefault(n => n.Principal.ID == ID);
        }

        public AcUser getWorkspaceOwner(string name)
        {
            int ii = name.LastIndexOf('_');
            string prncpl = name.Substring(++ii);
            return getUser(prncpl);
        }
    }
}