initial commit

DigitalData.Core.Console/DirectoryService.cs

@@ -0,0 +1,145 @@
+using System.DirectoryServices;
+using System.Collections;
+using Microsoft.VisualBasic.CompilerServices;
+using System.Reflection;
+
+namespace DigitalData.Core.ConsoleApp
+{
+    public class DirectoryService
+    {
+        public static T MapResultProperty<T>(ResultPropertyCollection rpc) where T : new()
+        {
+            if (!OperatingSystem.IsWindows())
+                throw new PlatformNotSupportedException("The method is only supported on the Windows platform.");
+
+            T resultObject = new();
+            foreach (string propertyName in rpc.PropertyNames ?? throw new ArgumentNullException("PropertyNames are null"))
+            {
+                var propertyValue = rpc[propertyName][0];
+                PropertyInfo? pi = typeof(T).GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
+                if (pi != null && propertyValue != null)
+                {
+                    Type propertyType = pi.PropertyType;
+                    Type underlyingType = Nullable.GetUnderlyingType(propertyType) ?? propertyType;
+
+                    if (propertyType != underlyingType)
+                    {
+                        propertyValue = Convert.ChangeType(propertyValue, underlyingType);
+                        pi.SetValue(resultObject, propertyValue);
+                    }
+                    else if (typeof(IEnumerable).IsAssignableFrom(propertyType) && propertyType != typeof(string))
+                    {
+                        var itemType = propertyType.GetGenericArguments()[0];
+                        IList list = (IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(itemType));
+                        list.Add(Convert.ChangeType(propertyValue, itemType));
+                        pi.SetValue(resultObject, list);
+                    }
+                    else if (propertyValue is byte[] && propertyType == typeof(string))
+                    {
+                        pi.SetValue(resultObject, Convert.ToBase64String((byte[])propertyValue));
+                    }
+                    else if (propertyValue is byte[] stBytes && propertyType == typeof(string))
+                    {
+                        pi.SetValue(resultObject, BitConverter.ToString(stBytes).Replace("-", ""));
+                    }
+                    else if (propertyValue is byte[] guiBytes && propertyType == typeof(Guid))
+                    {
+                        pi.SetValue(resultObject, new Guid(guiBytes));
+                    }
+                    else
+                    {
+                        propertyValue = Convert.ChangeType(propertyValue, propertyType);
+                        pi.SetValue(resultObject, propertyValue);
+                    }
+                }
+            }
+            return resultObject;
+        }
+
+        public static SearchResultCollection Search(string filter)
+        {
+            if (!OperatingSystem.IsWindows())
+                throw new PlatformNotSupportedException("The ListGroups method is only supported on the windows platform.");
+
+            DirectorySearcher directorySearcher = new()
+            {
+                SearchScope = SearchScope.Subtree,
+                SizeLimit = 50000,
+                Filter = filter,
+            };
+
+            return directorySearcher.FindAll();
+        }
+
+        public static IEnumerable<T> Search<T>(string filter) where T: new()
+        {
+            List<T> list = new();
+            foreach(SearchResult result in Search(filter))
+            {
+                if (!OperatingSystem.IsWindows())
+                    throw new PlatformNotSupportedException("The ListGroups method is only supported on the windows platform.");
+
+                ResultPropertyCollection rpc = result.Properties;
+                T obj = MapResultProperty<T>(rpc);
+                list.Add(obj);
+            }
+            return list;
+        }
+        public List<ADGroup> ListGroups(string query)
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                DirectorySearcher directorySearcher = new()
+                {
+                    SearchScope = SearchScope.Subtree,
+                    SizeLimit = 50000,
+                    Filter = query
+                };
+
+                SearchResultCollection result = directorySearcher.FindAll();
+
+
+                return GroupResultsToList(result);
+            }
+
+            throw new PlatformNotSupportedException("The ListGroups method is only supported on the Windows platform.");
+        }
+
+        private List<ADGroup> GroupResultsToList(SearchResultCollection results)
+        {
+            List<ADGroup> list = new();
+
+            foreach(SearchResult result in results)
+            {
+                list.Add(new ADGroup
+                {
+                    Name = TryGetProperty(result, "name"),
+                    SAMAccountName = TryGetProperty(result, "samaccountname"),
+                    CN = TryGetProperty(result, "cn"),
+                    Description = TryGetProperty(result, "description"),
+                    DistinguishedName = TryGetProperty(result, "distinguishedName"),
+                    ObjectCategory = TryGetProperty(result, "objectCategory"),
+                    //ObjectClass = TryGetProperty(result, "objectClass")
+                });
+            }         
+
+            return list;
+        }
+
+        private string TryGetProperty(SearchResult Result, string PropertyName)
+        {
+            var messages = new List<string>();
+            try
+            {
+                return Conversions.ToString(Result.Properties[PropertyName][0]);
+            }
+            catch (Exception ex)
+            {
+                Exception ex2 = ex;
+                messages.Add(String.Format("Property {0} not found", PropertyName));
+                string empty = string.Empty;
+                return empty;
+            }
+        }
+    }
+}