private static void Main(string[] args)
{
var ad = new PrincipalContextFull(ContextType.Domain);
try
{
Console.WriteLine();
var email = args[0];
if (email.Split(new[] {'@'}).Count() < 2)
{
try
{
foreach (Domain d in Forest.GetCurrentForest().Domains)
{
Console.WriteLine("Searching in Domain: {0}", d.Name);
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
var gdo = GenericDirectoryObject.FindByIdentity(ad, email);
if (!string.IsNullOrWhiteSpace(gdo.DistinguishedName))
{
Console.WriteLine("Search hit: {0}", gdo.DistinguishedName);
if (string.IsNullOrWhiteSpace(gdo.EmailAddress))
{
ExchangeCommon.ExchangeCommon.MailDisable(gdo);
return;
}
email = gdo.EmailAddress;
Console.WriteLine("\nSearching Active Directory Forest for Email: {0}", email);
}
}
catch
{
}
if (email.Split(new[] {'@'}).Count() >= 2)
{
break;
}
}
}
catch
{
}
}
IEnumerable<Principal> results = null;
string manager = null;
foreach (Domain d in Forest.GetCurrentForest().Domains)
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
var filter = new GenericDirectoryObject(ad)
{
EmailAddress = email
};
var ps = new PrincipalSearcher(filter);
results = results == null ? ps.FindAll() : results.Concat(ps.FindAll());
filter = new GenericDirectoryObject(ad)
{
ProxyAddresses = new List<string> {string.Format("smtp:{0}", email)}
};
ps = new PrincipalSearcher(filter);
results = results.Concat(ps.FindAll());
filter = new GenericDirectoryObject(ad)
{
TargetAddress = string.Format("smtp:{0}", email)
};
ps = new PrincipalSearcher(filter);
results = results.Concat(ps.FindAll());
}
var matches = new List<GenericDirectoryObject>();
foreach (var result in results)
{
var gdo = new GenericDirectoryObject(ad);
foreach (Domain d in Forest.GetCurrentForest().Domains)
{
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
gdo = GenericDirectoryObject.FindByIdentity(ad, result.DistinguishedName);
if (!string.IsNullOrWhiteSpace(gdo.DistinguishedName))
{
break;
}
}
catch
{
}
}
matches.Add(gdo);
}
matches.Sort();
var previousDn = string.Empty;
var sortedMatches = new List<GenericDirectoryObject>();
foreach (
var gdo in
matches.Where(gdo => previousDn.ToLowerInvariant() != gdo.DistinguishedName.ToLowerInvariant()))
{
previousDn = gdo.DistinguishedName;
sortedMatches.Add(gdo);
}
IEnumerable<GenericDirectoryObject> iMatches = sortedMatches;
iMatches.Distinct().OrderBy(x => x);
Console.WriteLine("\nFound {0} results", iMatches.Count());
foreach (var gdo in iMatches)
{
Console.WriteLine(gdo.DistinguishedName);
}
Console.WriteLine();
foreach (var gdo in iMatches)
{
Console.WriteLine("Match: {0} \n - SamID: {4}\n -Display: {1}\n -GUID: {2}\n -DN: {3}", gdo.Name,
gdo.DisplayName, gdo.Guid, gdo.DistinguishedName, gdo.SamAccountName);
if (manager == null || gdo.ObjectClass.Contains("contact"))
{
var n = gdo.DistinguishedName.Split(new[] {','})[0].Substring(3).ToLowerInvariant();
var e = email.Split(new[] {'@'})[0].ToLowerInvariant();
if (n == e)
{
Console.Write("Correct? (Y) ");
try
{
if (Console.ReadLine().Substring(0, 1).ToLowerInvariant() == "n")
{
ExchangeCommon.ExchangeCommon.MailDisable(gdo);
}
if (Console.ReadLine().Substring(0, 1).ToLowerInvariant() == "y")
{
ExchangeCommon.ExchangeCommon.MailEnable(gdo, false);
manager = gdo.DistinguishedName;
Console.WriteLine();
continue;
}
}
catch
{
ExchangeCommon.ExchangeCommon.MailEnable(gdo, false);
manager = gdo.DistinguishedName;
Console.WriteLine();
continue;
}
}
else
{
Console.Write("Correct? (N) ");
try
{
if (Console.ReadLine().Substring(0, 1).ToLowerInvariant() == "y")
{
ExchangeCommon.ExchangeCommon.MailEnable(gdo, false);
manager = gdo.DistinguishedName;
Console.WriteLine();
continue;
}
if (Console.ReadLine().Substring(0, 1).ToLowerInvariant() == "n")
{
ExchangeCommon.ExchangeCommon.MailDisable(gdo);
}
}
catch
{
ExchangeCommon.ExchangeCommon.MailDisable(gdo);
}
}
}
else
{
ExchangeCommon.ExchangeCommon.MailDisable(gdo);
}
Console.WriteLine();
}
if (string.IsNullOrWhiteSpace(manager))
{
return;
}
foreach (var gdo in iMatches.Where(gdo => gdo.DistinguishedName != manager))
{
try
{
var existingMgr = string.Empty;
try
{
existingMgr = gdo.Manager;
}
catch
{
}
if (!string.IsNullOrWhiteSpace(existingMgr))
{
continue;
}
gdo.Manager = manager;
gdo.Save();
}
catch
{
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public static void AddResourceAttributes(GenericDirectoryObject directoryObject)
{
try
{
var showInAddressBook = directoryObject.ShowInAddressBook;
showInAddressBook.AddRange(Config.ShowInAddressBookResources);
directoryObject.ShowInAddressBook = showInAddressBook;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.MsExchResourceDisplay = "Equipment";
directoryObject.MsExchResourceDisplayType = 8;
var MsExchResourceMetaData = directoryObject.MsExchResourceMetaData;
MsExchResourceMetaData.Add("ResourceType:Equipment");
directoryObject.MsExchResourceMetaData = MsExchResourceMetaData;
var MsExchResourceSearchProperties = directoryObject.MsExchResourceSearchProperties;
MsExchResourceSearchProperties.Add("Equipment");
directoryObject.MsExchResourceSearchProperties = MsExchResourceSearchProperties;
directoryObject.Save();
}
catch
{
}
}
public static void MailEnable(GenericDirectoryObject directoryObject, bool generateFriendlyAddress,
bool verifyUniqueness)
{
var email = string.Empty;
var emailDomain = string.Empty;
var handle = string.Empty;
try
{
handle = directoryObject.SamAccountName;
}
catch
{
}
if (string.IsNullOrWhiteSpace(handle))
{
handle = directoryObject.Name;
}
try
{
email = directoryObject.EmailAddress;
}
catch
{
}
try
{
emailDomain = email.Split(new[] {'@'})[1];
}
catch
{
}
try
{
if (email.Trim() != directoryObject.EmailAddress)
{
directoryObject.EmailAddress = email.Trim();
directoryObject.Save();
email = directoryObject.EmailAddress;
}
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
if (string.IsNullOrWhiteSpace(email))
{
return;
}
string friendlyEmail;
if (IsManagedDomain(emailDomain))
{
//firstname.lastname@domain
friendlyEmail = string.Format("smtp:{0}@{1}",
directoryObject.DisplayName.Replace(" ", ".").Replace("'", ""), emailDomain);
if (!verifyUniqueness || !IsEmailUnique(friendlyEmail, directoryObject.DistinguishedName))
{
//flastname@domain
friendlyEmail = string.Format("smtp:{0}@{1}",
directoryObject.DisplayName.Substring(0, 1) + directoryObject.Surname, emailDomain);
if (!verifyUniqueness || !IsEmailUnique(friendlyEmail, directoryObject.DistinguishedName))
{
//userID@domain
friendlyEmail = string.Format("smtp:{0}@{1}", handle, emailDomain);
}
}
}
else
{
friendlyEmail = string.Format("smtp:{0}", email);
}
try
{
if (generateFriendlyAddress)
{
directoryObject.TargetAddress = friendlyEmail;
}
else
{
if (!string.IsNullOrWhiteSpace(directoryObject.SamAccountName))
{
directoryObject.TargetAddress = IsManagedDomain(emailDomain)
? string.Format("smtp:{0}@{1}", handle, emailDomain)
: string.Format("smtp:{0}", directoryObject.EmailAddress);
}
else
{
directoryObject.TargetAddress = directoryObject.ObjectClass.Contains("contact")
? string.Format("smtp:{0}", directoryObject.EmailAddress)
: string.Format("smtp:{0}@{1}", directoryObject.Name, emailDomain);
}
}
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.MailNickname = handle;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
var proxyAddresses = new List<string>();
try
{
proxyAddresses = directoryObject.ProxyAddresses;
}
catch
{
}
proxyAddresses.Add(string.Format("SMTP:{0}", directoryObject.EmailAddress));
proxyAddresses.AddRange(
Config.RoutingDomains.Select(domain => string.Format("smtp:{0}@{1}", handle, domain)));
proxyAddresses.AddRange(
Config.RoutingDomains.Select(
domain => string.Format("{0}@{1}", friendlyEmail.Split(new char[1] {'@'})[0], domain)));
directoryObject.ProxyAddresses = proxyAddresses;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
var showInAddressBook = new List<string>();
try
{
showInAddressBook = directoryObject.ShowInAddressBook;
}
catch
{
}
showInAddressBook.AddRange(Config.ShowInAddressBookDefault);
directoryObject.ShowInAddressBook = showInAddressBook;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
//will require editing for your environment or modifying this to be configurable:
directoryObject.LegacyExchangeDn = string.Format("/o=Company/ou=Legacy/cn=Recipients/cn={0}",
directoryObject.SamAccountName);
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.UserPrincipalName = string.Format("{0}@{1}",
directoryObject.UserPrincipalName.Split(new[] {'@'})[0], Config.UpnSuffix);
directoryObject.Save();
}
catch
{
}
}
public static void MailDisable(GenericDirectoryObject directoryObject)
{
try
{
directoryObject.EmailAddress = null;
directoryObject.TargetAddress = null;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.MailNickname = null;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
var proxyAddresses = new List<string>();
try
{
proxyAddresses.AddRange(
directoryObject.ProxyAddresses.Where(
address => address.Substring(0, 5).ToLowerInvariant() != "smtp:"));
}
catch
{
}
try
{
if (proxyAddresses.Count > 0)
{
directoryObject.ProxyAddresses = proxyAddresses;
directoryObject.Save();
}
else
{
directoryObject.SetAttribute("proxyAddresses", null);
directoryObject.Save();
}
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.SetAttribute("showInAddressBook", null);
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
try
{
directoryObject.LegacyExchangeDn = null;
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
}
public static List<GenericDirectoryObject> FixGalCollision(string identity, string address, bool updateManager)
{
var domains = new List<Domain>();
var ad = new PrincipalContextFull(ContextType.Domain);
foreach (Domain d in Forest.GetCurrentForest().Domains)
{
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
if (!string.IsNullOrWhiteSpace(ad.ConnectedServer))
{
domains.Add(d);
}
}
catch
{
}
}
var authorizedIdentity = new GenericDirectoryObject(ad);
foreach (var d in domains)
{
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
authorizedIdentity = GenericDirectoryObject.FindByIdentity(ad, identity);
if (!string.IsNullOrWhiteSpace(authorizedIdentity.DistinguishedName))
{
break;
}
}
catch
{
}
}
if (string.IsNullOrWhiteSpace(authorizedIdentity.DistinguishedName))
{
throw new ArgumentException("Invalid identity - not found: {0}", identity);
}
IEnumerable<Principal> results = null;
foreach (var d in domains)
{
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
var filter = new GenericDirectoryObject(ad) {EmailAddress = address};
var ps = new PrincipalSearcher(filter);
results = results == null ? ps.FindAll() : results.Concat(ps.FindAll());
filter = new GenericDirectoryObject(ad)
{
ProxyAddresses = new List<string>
{
string.Format("smtp:{0}", address)
}
};
ps = new PrincipalSearcher(filter);
results = results.Concat(ps.FindAll());
filter = new GenericDirectoryObject(ad)
{
TargetAddress = string.Format("smtp:{0}", address)
};
ps = new PrincipalSearcher(filter);
results = results.Concat(ps.FindAll());
}
catch
{
}
}
var matches = new List<GenericDirectoryObject>();
foreach (var result in results)
{
var gdo = new GenericDirectoryObject(ad);
foreach (var d in domains)
{
try
{
ad = new PrincipalContextFull(ContextType.Domain, d.Name);
gdo = GenericDirectoryObject.FindByIdentity(ad, result.DistinguishedName);
if (!string.IsNullOrWhiteSpace(gdo.DistinguishedName))
{
break;
}
}
catch
{
}
}
matches.Add(gdo);
}
matches.Sort();
var prevDN = string.Empty;
var sortedMatches = new List<GenericDirectoryObject>();
foreach (
var _gdo in
matches.Where(_gdo => prevDN.ToLowerInvariant() != _gdo.DistinguishedName.ToLowerInvariant()))
{
prevDN = _gdo.DistinguishedName;
sortedMatches.Add(_gdo);
}
IEnumerable<GenericDirectoryObject> iMatches = sortedMatches;
iMatches.Distinct().OrderBy(x => x);
foreach (var gdo in iMatches)
{
if (gdo.DistinguishedName.ToLowerInvariant() == authorizedIdentity.DistinguishedName.ToLowerInvariant())
{
MailEnable(gdo, false, false);
}
else
{
MailDisable(gdo);
if (updateManager)
{
try
{
gdo.Manager = authorizedIdentity.DistinguishedName;
gdo.Save();
}
catch
{
}
}
}
}
return AddressSearch(address);
}
public static void AddAlias(GenericDirectoryObject directoryObject, string address, bool makeDefault)
{
var handle = address.Split(new[] {'@'})[0];
var proxyAddresses = new List<string>();
var nicknameProxies = false;
if (makeDefault)
{
try
{
directoryObject.EmailAddress = address.Trim();
directoryObject.TargetAddress = string.Format("smtp:{0}", address);
if (string.IsNullOrWhiteSpace(directoryObject.MailNickname))
{
directoryObject.MailNickname = handle;
nicknameProxies = true;
}
directoryObject.Save();
}
catch
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
}
try
{
proxyAddresses = directoryObject.ProxyAddresses;
}
catch
{
}
var newProxyAddresses = new List<string>();
foreach (var proxyAddress in proxyAddresses)
{
if (proxyAddress.Substring(0, 5).ToLowerInvariant() == "smtp:")
{
var s = proxyAddress.Split(new[] {':'});
if (s[1].ToLowerInvariant() == address.ToLowerInvariant())
{
newProxyAddresses.Add(makeDefault
? string.Format("SMTP:{0}", address)
: string.Format("smtp:{0}", address));
}
else
{
newProxyAddresses.Add(proxyAddress.Replace("SMTP", "smtp"));
}
}
else
{
newProxyAddresses.Add(proxyAddress);
}
}
if (nicknameProxies)
{
newProxyAddresses.AddRange(
Config.RoutingDomains.Select(domain => string.Format("smtp:{0}@{1}", handle, domain)));
}
try
{
directoryObject.SetAttribute("proxyAddresses", null);
directoryObject.Save();
}
catch
{
}
finally
{
directoryObject = GenericDirectoryObject.FindByIdentity(directoryObject.Context,
directoryObject.DistinguishedName);
}
directoryObject.ProxyAddresses = newProxyAddresses;
directoryObject.Save();
}