AcPermissions.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Xml.Linq;

namespace AcUtils
{
    #region enums

    public enum PermType {
        group,
        user,
        builtin
    };

    public enum PermRights
    {
        none,
        all
    };

    public enum PermKind
    {
        depot,
        stream
    };
    #endregion

    [Serializable]
    public sealed class AcPermission : IFormattable, IEquatable<AcPermission>, IComparable<AcPermission>, IComparable
    {
        #region class variables
        private PermKind _kind; // depot or stream
        private string _name; // name of depot or stream permission applies to
        private string _appliesTo; // principal of group or user permission applies to or one of the built-in types anyuser or authuser
        private PermType _type; // whether _appliesTo is a "group", "user", "builtin"
        private PermRights _rights; // whether permission rights is "all" or "none"

        // depots: when true permission applies to the depot and its entire stream hierarchy, 
        // when false permission applies only to AccuWork issues in the depot and not its version-controlled elements
        // streams: when true permission applies to the stream and its entire subhierarchy, 
        // when false permission applies only to the stream
        private bool _inheritable;
        #endregion

        internal AcPermission(PermKind kind)
        {
            _kind = kind;
        }

        #region Equality comparison

        public bool Equals(AcPermission other)
        {
            if (ReferenceEquals(other, null)) return false;
            if (ReferenceEquals(this, other)) return true;
            var left = Tuple.Create(Kind, Name, AppliesTo);
            var right = Tuple.Create(other.Kind, other.Name, other.AppliesTo);
            return left.Equals(right);
        }

        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 AcPermission);
        }

        public override int GetHashCode()
        {
            var hash = Tuple.Create(Kind, Name, AppliesTo);
            return hash.GetHashCode();
        }
        #endregion

        #region Order comparison


        public int CompareTo(AcPermission other)
        {
            int result;
            if (AcPermission.ReferenceEquals(this, other))
                result = 0;
            else
            {
                result = String.Compare(Name, other.Name);
                if (result == 0)
                    result = String.Compare(AppliesTo, other.AppliesTo);
            }

            return result;
        }

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

        public PermKind Kind
        {
            get { return _kind; }
            internal set { _kind = value; }
        }

        public string Name
        {
            get { return _name ?? String.Empty; }
            internal set { _name = value; }
        }

        public string AppliesTo
        {
            get { return _appliesTo ?? String.Empty; }
            internal set { _appliesTo = value; }
        }

        public PermType Type
        {
            get { return _type; }
            internal set { _type = value; }
        }

        public PermRights Rights
        {
            get { return _rights; }
            internal set { _rights = value; }
        }

        public bool Inheritable
        {
            get { return _inheritable; }
            internal set { _inheritable = value; }
        }

        #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":
                {
                    string who = $"{((Type == PermType.builtin) ? AppliesTo : Type.ToString() + " " + AppliesTo)}";
                    return $@"Permission on {Name} {Kind} applies to {who} {{{Rights}, {(Inheritable ? "inherit" : "no inherit")}}}";
                }
                case "K": // whether the permission pertains to a depot or stream
                    return Kind.ToString();
                case "N": // name of the depot or stream this permission applies to
                    return Name;
                case "A": // principal name of the group or user this permission applies to or one of the built-in types "anyuser" or "authuser"
                    return AppliesTo;
                case "T": // whether AppliesTo is the principal name for a "group", "user", or a "builtin" type
                    return Type.ToString();
                case "R": // whether permission rights to Name in AppliesTo is "all" or "none"
                    return Rights.ToString();

                    // For a depot, when true permission applies to the depot and its entire 
                    // stream hierarchy, when false permission applies only to AccuWork issues 
                    // in the depot and not its version-controlled elements.
                    // For a stream, when true permission applies to the stream and its entire 
                    // subhierarchy, when false permission applies only to the stream.
                case "I":
                    return Inheritable.ToString();
                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
    }

    [Serializable]
    public sealed class AcPermissions : List<AcPermission>
    {
        #region class variables
        private PermKind _kind; // whether the list of permissions held pertain to depots or streams
        [NonSerialized] private readonly object _locker = new object();
        #endregion

        public PermKind Kind
        {
            get { return _kind; }
            internal set { _kind = value; }
        }

        #region object construction:


        public AcPermissions(PermKind kind)
        {
            _kind = kind;
        }


        public async Task<bool> initAsync(string name = null)
        {
            bool ret = false; // assume failure
            try
            {
                AcResult r = await AcCommand.runAsync($@"lsacl -fx {_kind} ""{name}""").ConfigureAwait(false);
                if (r != null && r.RetVal == 0)
                {
                    XElement xml = XElement.Parse(r.CmdResult);
                    foreach (XElement e in xml.Elements("Element"))
                    {
                        AcPermission perm = new AcPermission(_kind);
                        perm.Name = (string)e.Attribute("Name");
                        perm.AppliesTo = (string)e.Attribute("Group");
                        string type = (string)e.Attribute("Type");
                        perm.Type = (PermType)Enum.Parse(typeof(PermType), type);
                        string rights = (string)e.Attribute("Rights");
                        perm.Rights = (PermRights)Enum.Parse(typeof(PermRights), rights);
                        perm.Inheritable = (bool)e.Attribute("Inheritable");
                        lock (_locker) { Add(perm); }
                    }

                    ret = true; // operation succeeded
                }
            }

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

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

            return ret;
        }
        #endregion
    }
}