Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Workflow.Activities/Role/ADRole.cs

@@ -0,0 +1,271 @@
+#region Using directives
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.DirectoryServices;
+using System.Security.Permissions;
+using System.Security.Principal;
+using System.Runtime.Serialization;
+
+using System.Workflow.ComponentModel;
+using System.Diagnostics;
+
+#endregion
+
+namespace System.Workflow.Activities
+{
+    [Serializable]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    public abstract class WorkflowRole
+    {
+        public abstract String Name { set; get; }
+
+        public abstract IList<String> GetIdentities();
+
+        public abstract bool IncludesIdentity(String identity);
+    }
+
+    [Serializable]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    sealed public class WorkflowRoleCollection : List<WorkflowRole>
+    {
+        public WorkflowRoleCollection()
+            : base()
+        {
+        }
+
+        public bool IncludesIdentity(String identity)
+        {
+            if (identity == null)
+                return false;
+
+            foreach (WorkflowRole role in this)
+            {
+                if (role != null)
+                {
+                    if (role.IncludesIdentity(identity))
+                        return true;
+                }
+            }
+
+            return false;
+        }
+    }
+
+    [Serializable]
+    [Obsolete("The System.Workflow.* types are deprecated.  Instead, please use the new types from System.Activities.*")]
+    sealed public class ActiveDirectoryRole : WorkflowRole, ISerializable, IDisposable
+    {
+        private String m_name;
+        private DirectoryEntry m_root;
+        private List<IDirectoryOperation> m_operations;
+
+        internal ActiveDirectoryRole(DirectoryEntry rootEntry, IDirectoryOperation operation)
+        {
+            if (rootEntry == null)
+                throw new ArgumentNullException("rootEntry");
+
+            this.m_root = rootEntry;
+
+            this.m_operations = new List<IDirectoryOperation>();
+            if (operation != null)
+                this.m_operations.Add(operation);
+        }
+
+        internal ActiveDirectoryRole(DirectoryEntry rootEntry, ICollection<IDirectoryOperation> operations)
+        {
+            if (rootEntry == null)
+                throw new ArgumentNullException("rootEntry");
+
+            this.m_root = rootEntry;
+
+            if (operations == null)
+                this.m_operations = new List<IDirectoryOperation>();
+            else
+                this.m_operations = new List<IDirectoryOperation>(operations);
+        }
+
+        private ActiveDirectoryRole(SerializationInfo info, StreamingContext context)
+        {
+            this.m_name = info.GetString("m_name");
+            this.m_operations = (List<IDirectoryOperation>)info.GetValue("m_operations", typeof(List<IDirectoryOperation>));
+
+            String path = info.GetString("m_root\\path");
+
+            this.m_root = new DirectoryEntry(path);
+        }
+
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            info.AddValue("m_name", this.m_name);
+            info.AddValue("m_operations", this.m_operations);
+
+            info.AddValue("m_root\\path", this.m_root.Path);
+        }
+
+        public override String Name
+        {
+            get
+            {
+                return this.m_name;
+            }
+
+            set
+            {
+                this.m_name = value;
+            }
+        }
+
+        public DirectoryEntry RootEntry
+        {
+            get
+            {
+                return this.m_root;
+            }
+        }
+
+        internal ICollection<IDirectoryOperation> Operations
+        {
+            get
+            {
+                return this.m_operations;
+            }
+        }
+
+        public ActiveDirectoryRole GetManager()
+        {
+            List<IDirectoryOperation> queries = new List<IDirectoryOperation>(this.Operations);
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.DirectReports));
+
+            return new ActiveDirectoryRole(this.RootEntry, queries);
+        }
+
+        public ActiveDirectoryRole GetManagerialChain()
+        {
+            List<IDirectoryOperation> queries = new List<IDirectoryOperation>(this.Operations);
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.DirectReports, true));
+
+            return new ActiveDirectoryRole(this.RootEntry, queries);
+        }
+
+        public ActiveDirectoryRole GetDirectReports()
+        {
+            List<IDirectoryOperation> queries = new List<IDirectoryOperation>(this.Operations);
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.Manager));
+
+            return new ActiveDirectoryRole(this.RootEntry, queries);
+        }
+
+        public ActiveDirectoryRole GetAllReports()
+        {
+            List<IDirectoryOperation> queries = new List<IDirectoryOperation>(this.Operations);
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.Manager, true));
+
+            return new ActiveDirectoryRole(this.RootEntry, queries);
+        }
+
+        public ActiveDirectoryRole GetPeers()
+        {
+            ICollection<DirectoryEntry> entries = this.GetEntries();
+
+            List<IDirectoryOperation> queries = new List<IDirectoryOperation>(this.Operations);
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.DirectReports));
+            queries.Add(new DirectoryRedirect(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, ActiveDirectoryRoleFactory.Configuration.Manager));
+
+            foreach (DirectoryEntry entry in entries)
+            {
+                queries.Add(new DirectoryLocalQuery(ActiveDirectoryRoleFactory.Configuration.DistinguishedName, (String)entry.Properties[ActiveDirectoryRoleFactory.Configuration.DistinguishedName][0], DirectoryQueryOperation.NotEqual));
+            }
+
+            return new ActiveDirectoryRole(this.RootEntry, queries);
+        }
+
+
+        public ICollection<DirectoryEntry> GetEntries()
+        {
+            List<DirectoryEntry> currentEntries = new List<DirectoryEntry>();
+            currentEntries.Add(this.m_root);
+            List<DirectoryEntry> newEntries = new List<DirectoryEntry>();
+
+            for (int i = 0; i < this.m_operations.Count; ++i)
+            {
+                for (int j = 0; j < currentEntries.Count; ++j)
+                {
+                    this.m_operations[i].GetResult(this.m_root, currentEntries[j], newEntries);
+                }
+
+                // Swap between new and current, as the for the new iteration the 'new' of
+                // now will be the current.  After the swap we clear out the 'new' list as to
+                // reuse it.
+
+                List<DirectoryEntry> tempEntries = currentEntries;
+                currentEntries = newEntries;
+                newEntries = tempEntries;
+                newEntries.Clear();
+            }
+
+            // Remove duplicates
+
+            Dictionary<Guid, DirectoryEntry> dFinal = new Dictionary<Guid, DirectoryEntry>();
+            for (int i = 0; i < currentEntries.Count; ++i)
+            {
+                if (!dFinal.ContainsKey(currentEntries[i].Guid))
+                    dFinal.Add(currentEntries[i].Guid, currentEntries[i]);
+            }
+
+            return dFinal.Values;
+        }
+
+        public IList<SecurityIdentifier> GetSecurityIdentifiers()
+        {
+            List<SecurityIdentifier> identifiers = new List<SecurityIdentifier>();
+
+            foreach (DirectoryEntry entry in this.GetEntries())
+            {
+                if (entry.Properties["objectSid"] != null &&
+                    entry.Properties["objectSid"].Count != 0)
+                {
+                    identifiers.Add(new SecurityIdentifier((byte[])(entry.Properties["objectSid"][0]), 0));
+                }
+                else
+                {
+                    WorkflowActivityTrace.Activity.TraceEvent(TraceEventType.Information, 0, "Unable to find 'objectSid' property for directory entry = {0}.", entry.Path);
+                }
+            }
+
+            return identifiers;
+        }
+
+        public override IList<String> GetIdentities()
+        {
+            List<String> identityRefs = new List<String>();
+            foreach (SecurityIdentifier entrySid in this.GetSecurityIdentifiers())
+            {
+                identityRefs.Add(entrySid.Translate(typeof(NTAccount)).ToString());
+            }
+            return identityRefs;
+        }
+
+        public override bool IncludesIdentity(String identity)
+        {
+            if (identity == null)
+                return false;
+
+            foreach (String roleIdentity in this.GetIdentities())
+            {
+                if (String.Compare(identity, roleIdentity, StringComparison.Ordinal) == 0)
+                    return true;
+            }
+
+            return false;
+        }
+
+        void IDisposable.Dispose()
+        {
+            this.m_root.Dispose();
+        }
+
+    }
+}