public Int32 getNextUID()
{
checkConnection();
Int32 id = 0;
DirectorySearcher mySearcher = new DirectorySearcher(entry);
mySearcher.Filter = "(|(objectClass=user))";
SearchResultCollection resultSet = mySearcher.FindAll();
foreach (SearchResult result in resultSet)
{
DirectoryEntry user = result.GetDirectoryEntry();
if (user.Properties["uidnumber"].Value != null)
{
String foo = user.Properties["uidnumber"].Value.ToString();
String username = user.Properties["uid"].Value.ToString();
int thisID;
Int32.TryParse(foo, out thisID);
if (thisID > id){
id = thisID;
}
}
}
mySearcher.Dispose();
return (id != 0) ? (id + 1) : 0;
}
public static Task Test()
{
return Task.Run(() => {
string strServerDNS = "ldap.hp.com:389";
string strSearchBaseDN = "ou=Email,ou=Services,o=hp.com";
string strLDAPPath;
strLDAPPath = "LDAP://" + strServerDNS + "/" + strSearchBaseDN;
DirectoryEntry objDirEntry = new DirectoryEntry(strLDAPPath, null, null, AuthenticationTypes.Anonymous);
DirectorySearcher searcher = new DirectorySearcher(objDirEntry);
SearchResult result = null;
searcher.Filter = "[email protected]";
searcher.PropertiesToLoad.Add("ntUserDomainId");
searcher.ClientTimeout = TimeSpan.FromSeconds(20);
try
{
result = searcher.FindOne();
}
catch (Exception ex)
{
}
finally
{
searcher.Dispose();
}
});
}
public static List<string> GetComputers()
{
List<string> ComputerNames = new List<string>();
DirectoryEntry entry = new DirectoryEntry("LDAP://transnetwork.local/OU=Phoenix-DC,DC=transnetwork,DC=local");
DirectorySearcher mySearcher = new DirectorySearcher(entry);
mySearcher.Filter = ("(objectClass=computer)"); //se buscan solamente objetos de ltipo computadora / server
mySearcher.SizeLimit = int.MaxValue;
mySearcher.PageSize = int.MaxValue;
foreach (SearchResult resEnt in mySearcher.FindAll())
{
//"CN=SGSVG007DC"
string ComputerName = resEnt.GetDirectoryEntry().Name;
if (ComputerName.StartsWith("CN="))
ComputerName = ComputerName.Remove(0, "CN=".Length);
ComputerNames.Add(ComputerName);
}
mySearcher.Dispose();
entry.Dispose();
// Console.ReadLine();
return ComputerNames;
}
/// <summary>
/// Retrieves the user information.
/// </summary>
/// <param name="userNameToRetrieveFrom">The user name to retrieve from.</param>
/// <returns></returns>
/// <remarks></remarks>
public LdapUserInfo RetrieveUserInformation(string userNameToRetrieveFrom)
{
System.DirectoryServices.DirectorySearcher ldapSearcher = new System.DirectoryServices.DirectorySearcher();
System.DirectoryServices.SearchResult ldapResult = default(System.DirectoryServices.SearchResult);
string filter = "(&(objectClass=user)(SAMAccountName=" + userNameToRetrieveFrom + "))";
System.DirectoryServices.DirectoryEntry ldap = default(System.DirectoryServices.DirectoryEntry);
try
{
if (LdapLogonUserName == null)
{
ldap = new System.DirectoryServices.DirectoryEntry("LDAP://" + DomainName);
}
else
{
ldap = new System.DirectoryServices.DirectoryEntry("LDAP://" + DomainName, LdapLogonUserName, LdapLogonPassword);
}
}
catch (Exception e)
{
Util.Log.Trace(e.ToString());
throw new CruiseControlException("Problem connecting to LDAP service", e);
}
ldapSearcher.SearchRoot = ldap;
ldapSearcher.SearchScope = SearchScope.Subtree;
ldapSearcher.PropertiesToLoad.Add(LdapFieldMailAddress);
ldapSearcher.PropertiesToLoad.Add(LdapFieldName);
ldapSearcher.PropertiesToLoad.Add(LdapFieldSurName);
ldapSearcher.PropertiesToLoad.Add(LdapFieldCommonName);
ldapSearcher.PropertiesToLoad.Add(LdapFieldGivenName);
ldapSearcher.PropertiesToLoad.Add(LdapFieldDisplayName);
ldapSearcher.PropertiesToLoad.Add(LdapFieldMailNickName);
ldapSearcher.Filter = filter;
ldapResult = ldapSearcher.FindOne();
ldapSearcher.Dispose();
LdapUserInfo result = new LdapUserInfo();
if ((ldapResult != null))
{
result.CommonName = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldCommonName].Value;
result.DisplayName = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldDisplayName].Value;
result.GivenName = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldGivenName].Value;
result.MailAddress = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldMailAddress].Value;
result.MailNickName = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldMailNickName].Value;
result.Name = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldName].Value;
result.SurName = (string)ldapResult.GetDirectoryEntry().Properties[LdapFieldSurName].Value;
}
return(result);
}
public static string getDNFromLDAP(string strUID)
{
DirectoryEntry entry = new DirectoryEntry("LDAP://rock.temple.edu/ou=temple,dc=tu,dc=temple,dc=edu");
entry.AuthenticationType = AuthenticationTypes.None;
DirectorySearcher mySearcher = new DirectorySearcher(entry);
entry.Close();
entry.Dispose();
mySearcher.Filter = "(sAMAccountName=" + strUID + ")";
SearchResult result = mySearcher.FindOne();
mySearcher.Dispose();
int nIndex = result.Path.LastIndexOf("/");
string strDN = result.Path.Substring((nIndex + 1)).ToString().TrimEnd();
return strDN;
}
public static string GetFullName( string strUserId )
{
if( ServerList.Count == 0 )
LoadServerList();
string sLDAPPath = string.Format( "LDAP://{0}/DC=XXXX,DC=root01,DC=org", ServerList["XXXX"] );
string strFullName = "";
DirectoryEntry objDE = null;
try
{
objDE = new DirectoryEntry(sLDAPPath);
DirectorySearcher objDS = new DirectorySearcher( objDE );
// get the LDAP filter string based on selections
string strFilter = string.Format("(|(&(objectClass=User)(sAMAccountName={0})))", strUserId);
objDS.Filter = strFilter;
objDS.ReferralChasing = ReferralChasingOption.None;
//start searching
SearchResultCollection objSRC = objDS.FindAll();
try
{
if (objSRC.Count != 0)
{
// grab the first search result
SearchResult objSR = objSRC[0];
string strFirstName = objSR.Properties[ "givenName" ][ 0 ].ToString();
string strLastName = objSR.Properties[ "sn" ][ 0 ].ToString();
strFullName = string.Concat( strLastName, ", ", strFirstName );
}
}
catch (Exception e)
{
// ignore errors
}
objSRC.Dispose();
objDS.Dispose();
}
catch (Exception e)
{
// ignore errors
}
return strFullName;
}
public BindableCollection<IComputer> FindMatchingComputers(string filterName)
{
if (!filterName.EndsWith("*") && !filterName.EndsWith("$") && !filterName.EndsWith("%"))
{
filterName = filterName += "$";
}
if (filterName.EndsWith("%"))
{
filterName = filterName.Replace('%', '*');
}
string filter = string.Format("(&(objectCategory=Computer)(sAMAccountName={0}))", filterName);
BindableCollection<IComputer> Matches = new BindableCollection<IComputer>();
DirectoryEntry de = new DirectoryEntry(string.Format("LDAP://{0}",GetClosestDC()));
DirectorySearcher ds = new DirectorySearcher(de);
SearchResultCollection results;
try
{
ds.ReferralChasing = ReferralChasingOption.All;
ds.SearchScope = SearchScope.Subtree;
ds.PropertiesToLoad.Add("sAMAccountName");
ds.Filter = filter;
results = ds.FindAll();
if (results.Count > 0)
{
foreach (SearchResult sr in results)
{
Computer c = new Computer() { Name = sr.Properties["sAMAccountName"][0].ToString().Replace("$", "") };
Matches.Add(c);
}
}
results.Dispose();
}
catch
{
//ERROR....
}
finally
{
de.Dispose();
ds.Dispose();
}
return Matches;
}
/// <summary>
/// Search the LDAP store for the entries required using the context specified
/// </summary>
/// <param name="adsPath">The adspath that the server will use</param>
/// <param name="objectClass">The object class to search for</param>
/// <param name="attrib">The attribute to search on</param>
/// <param name="attribValue">The value to search for</param>
/// <returns>The collection of results found.</returns>
protected SearchResultCollection SearchLdapContext(string adsPath, string objectClass, string attrib, string attribValue)
{
DirectoryEntry root = GetServerContext(adsPath);
StringBuilder sb = new StringBuilder();
sb.AppendFormat(m_defaultSearch, objectClass, attrib, attribValue);
DirectorySearcher ds = new DirectorySearcher(root, sb.ToString());
if ( m_pageSize > 0 )
ds.PageSize = m_pageSize;
ds.SearchScope = SearchScope.Subtree;
foreach(string prop in m_properties )
ds.PropertiesToLoad.Add(prop);
SearchResultCollection src = ds.FindAll();
ds.Dispose();
root.Dispose();
return src;
}
public static Task GetUserInfo(Dictionary<string,string> Filter,Dictionary<string, ResultPropertyValueCollection> ResultFormat)
{
return Task.Run(() => {
string strServerDNS = "ldap.hp.com:389";
string strSearchBaseDN = "ou=People,o=hp.com";
string strLDAPPath;
strLDAPPath = "LDAP://" + strServerDNS + "/" + strSearchBaseDN;
DirectoryEntry objDirEntry = new DirectoryEntry(strLDAPPath, null, null, AuthenticationTypes.Anonymous);
DirectorySearcher searcher = new DirectorySearcher(objDirEntry);
SearchResult result = null;
searcher.Filter = "[email protected]";
foreach(var returnVal in ResultFormat)
{
searcher.PropertiesToLoad.Add(returnVal.Key);
}
searcher.ClientTimeout = TimeSpan.FromSeconds(20);
try
{
result = searcher.FindOne();
for(int i = 0;i<ResultFormat.Count;i++)
{
string key = ResultFormat.ElementAt(i).Key;
ResultFormat[key] = result.Properties[key];
}
}
catch(Exception ex)
{
}
finally
{
searcher.Dispose();
}
});
}
public static void AddUserToGroup(string UserName, string GroupName)
{
DirectoryEntry rootEntry = GetDirectoryObject("/" + GetLDAPDomain());
DirectorySearcher Mysearcher = new DirectorySearcher(rootEntry);
Mysearcher.SearchRoot = rootEntry;
Mysearcher.Filter = "(&(objectCategory=group)(CN=" + GroupName + "))";
SearchResult result = Mysearcher.FindOne();
DirectoryEntry g = result.GetDirectoryEntry();
Mysearcher.Filter = "(&(objectCategory=user)(SAMAccountName=" + UserName + "))";
result = Mysearcher.FindOne();
DirectoryEntry user = result.GetDirectoryEntry();
g.Invoke("Add", new Object[] { user.Path });
g.CommitChanges();
g.Close();
g.Dispose();
user.Close();
user.Dispose();
Mysearcher.Dispose();
rootEntry.Close();
rootEntry.Dispose();
}
/// <summary>
/// Gets the photo for the user from the thumbnailPhoto attribute in Active Directory
/// </summary>
/// <param name="userPrincipalName"></param>
/// <returns></returns>
public byte[] GetPhoto(string userPrincipalName)
{
DirectoryEntry de = null;
DirectorySearcher ds = null;
try
{
logger.Debug("Attempting to find photo for " + userPrincipalName);
de = new DirectoryEntry("LDAP://" + this.domainController, this.username, this.password);
ds = new DirectorySearcher(de);
ds.SearchScope = SearchScope.Subtree;
ds.Filter = string.Format("(&(objectClass=User)(userPrincipalName={0}))", userPrincipalName);
SearchResult found = ds.FindOne();
byte[] data = null;
if (found != null)
{
using (DirectoryEntry u = new DirectoryEntry(found.Path))
{
if (u.Properties["thumbnailPhoto"].Value != null)
data = u.Properties["thumbnailPhoto"].Value as byte[];
}
}
return data;
}
catch (Exception ex)
{
this.logger.Error("Error getting photto for " + userPrincipalName, ex);
throw;
}
finally
{
if (ds != null)
ds.Dispose();
if (de != null)
de.Dispose();
}
}
/// <summary>
/// 根据组名返回用户组
/// </summary>
/// <param name="entry"></param>
/// <param name="groupname"></param>
/// <returns></returns>
public static DirectoryEntry GetGroup(DirectoryEntry entry, string groupname)
{
if (string.IsNullOrEmpty(groupname))
{
return null;
}
DirectorySearcher searcher = new DirectorySearcher(entry);
searcher.Filter = "(&(objectClass=group)(name=" + groupname + "))";
searcher.CacheResults = false;
searcher.PropertyNamesOnly = true;
searcher.PropertiesToLoad.Add("cn");
searcher.PropertiesToLoad.Add("distinguishedName");
searcher.PropertiesToLoad.Add("Description");
searcher.PropertiesToLoad.Add("memberOf");
SearchResult result = searcher.FindOne();
DirectoryEntry group = null;
if (result != null)
{
group = result.GetDirectoryEntry();
}
entry.Dispose();
searcher.Dispose();
return group;
}
void LDB_Query(object sender, RoutedEventArgs e)
{
lbQBUsers.Items.Clear();
DirectorySearcher ds = new DirectorySearcher();
ds.SearchRoot = new DirectoryEntry(selectedPath); // start searching from whatever was selectted
ds.Filter = (tbFilter.Text.Length > 0) ? String.Format(
"(|(&(objectCategory=user)(name={0})))", tbFilter.Text) :
"(|(&(objectCategory=user)(name=*)))";
ds.PropertiesToLoad.Add("sAMAccountName");
if (cbEntireSubt.IsChecked == false)
ds.SearchScope = SearchScope.OneLevel;
SearchResultCollection src = ds.FindAll();
try
{
int arraySiz = (src.Count) * 2;
accts = new string[arraySiz];
int k = 0;
foreach (SearchResult sr in src)
{
DirectoryEntry de = sr.GetDirectoryEntry();
lbQBUsers.Items.Add(de.Name.Substring(3));
foreach (String property in ds.PropertiesToLoad)
{
foreach (Object myCollection in sr.Properties[property])
{
if (property == "sAMAccountName")
{
accts[k++] = de.Name.Substring(3);
accts[k++] = myCollection.ToString();
break;
}
}
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
src.Dispose();
ds.Dispose();
}
///// <summary>
///// Obtiene un usuario sin pasar clave.-
///// </summary>
///// <param name="userName"></param>
///// <returns></returns>
internal static SearchResult User_Get_Result(string userName, DirectoryEntry root)
{
DirectorySearcher deSearch = new DirectorySearcher(root);
deSearch.Filter = "(&(objectClass=user)(sAMAccountName=" + ADHelper.FilterOutDomain(userName) + "))";
deSearch.SearchScope = System.DirectoryServices.SearchScope.Subtree;
SearchResult rs = deSearch.FindOne();
deSearch.Dispose();
return rs;
}
private string GetAvailableSamAccountName(string userPrincipalName)
{
DirectorySearcher ds = null;
try
{
log.DebugFormat("Attempting to find an available sAMAccountName for {0}.", userPrincipalName);
// Get the first part of the user principal name
string upnFirstPart = userPrincipalName.Split('@')[0];
string sAMAccountName = upnFirstPart;
de = GetDirectoryEntry();
ds = new DirectorySearcher(de);
ds.SearchScope = SearchScope.Subtree;
ds.Filter = string.Format("(sAMAccountName={0})", upnFirstPart);
int count = 0;
while (ds.FindOne() != null)
{
count = count + 1;
sAMAccountName = string.Format("{0}{1}", upnFirstPart, count.ToString());
ds.Filter = string.Format("(sAMAccountName={0})", sAMAccountName);
}
// We found our available sAMAccountName
return sAMAccountName;
}
catch (Exception ex)
{
log.ErrorFormat("Error searching for available SamAccountName for {0}. Exception: {1} ", userPrincipalName, ex.ToString());
throw;
}
finally
{
if (ds != null)
ds.Dispose();
}
}
private void GetPropertyFromAD(DataTable result)
{
string userName = this.Context.User.Identity.Name;
using (HostingEnvironment.Impersonate())
{
DirectoryEntry dirEntry = new DirectoryEntry(_adEntryPoint);
string studentName = "";
// Trim the domain name
if (userName.IndexOf("\\") != 0)
{
userName = userName.Substring(userName.LastIndexOf("\\") + 1);
}
// We are storing the Children of a Parent in the property of Active Directory specified
System.DirectoryServices.DirectorySearcher mySearcher = new System.DirectoryServices.DirectorySearcher(dirEntry);
mySearcher.PropertiesToLoad.Add(_adChildAttribute);
//Set the filter for the current user
mySearcher.Filter = "(&(objectCategory=user)(samaccountname=" + userName + "))";
ResultPropertyValueCollection myResultPropColl = null;
try
{
myResultPropColl = mySearcher.FindOne().Properties[_adChildAttribute];
}
catch (Exception ex)
{
Debug(ex.ToString());
ShowMessage(LoadResource(GenericErrMsg), String.Format(LoadResource("ErrorRetrievingChildren"), ex.ToString()));
return;
}
//if null an error occured
if (myResultPropColl == null)
{
ShowMessage(LoadResource(GenericErrMsg));
return;
}
//if count =0 then no childern
if (myResultPropColl.Count == 0)
{
ShowMessage(LoadResource("NoChild"));
}
// Loop through each found child, and return their Display Name , Image Url and First Name
foreach (object myCollection in myResultPropColl)
{
string orgStudentName = myCollection.ToString();
Debug("{0} in AD attribute", orgStudentName);
if (!IsMember(orgStudentName, _studentsSiteURL))
{
Debug("Not member");
continue;
}
DataRow studentRow = result.NewRow();
studentRow[IsSelectedColumnName] = false;
studentRow[UserNameColumnName] = orgStudentName;
// Trim the domain name
if (orgStudentName.IndexOf("\\") != 0)
{
studentName = orgStudentName.Substring(orgStudentName.LastIndexOf("\\") + 1);
}
try
{
//read display name property
mySearcher.PropertiesToLoad.Add(DisplayNameColumnName);
mySearcher.Filter = "(&(objectCategory=user)(samaccountname=" + studentName + "))";
System.DirectoryServices.SearchResult SrchRes;
SrchRes = mySearcher.FindOne();
if (SrchRes != null)
{
studentRow[DisplayNameColumnName] = SrchRes.Properties[DisplayNameColumnName][0].ToString();
string pictureURL = GetStudentImage(studentName);
if (pictureURL == null)
{
System.Uri defaultpic = new Uri(new Uri(Context.Request.Url.ToString()), DefaultPictureURL);
pictureURL = defaultpic.OriginalString.ToString();
}
studentRow[ImageUrlColumnName] = pictureURL;
result.Rows.Add(studentRow);
}
else // No user object found for the attached child
{
ShowMessage(String.Format(LoadResource("NoChildFound"), studentName));
}
}
catch (Exception ex)
{
ShowMessage(LoadResource(GenericErrMsg), String.Format(LoadResource("ErrorRetrievingChildInfo"), studentName, ex.Message));
}
}
mySearcher.Dispose();
}
}
internal static string GetObjectDistinguishedName(objectClass objectCls,
returnType returnValue,
string objectName,
string LdapDomain)
{
string distinguishedName = string.Empty;
string connectionPrefix = "LDAP://" + LdapDomain;
DirectoryEntry entry = Utility.NewDirectoryEntry(connectionPrefix);
DirectorySearcher mySearcher = new DirectorySearcher(entry);
switch (objectCls)
{
case objectClass.user:
mySearcher.Filter = "(&(objectClass=user)(|(cn=" + objectName + ")(sAMAccountName=" + objectName + ")))";
break;
case objectClass.group:
mySearcher.Filter = "(&(objectClass=group)(|(cn=" + objectName + ")(dn=" + objectName + ")))";
break;
}
SearchResult result = mySearcher.FindOne();
if (result == null)
{
throw new NullReferenceException("unable to locate the distinguishedName for the object " +
objectName + " in the " + LdapDomain + " domain");
}
DirectoryEntry directoryObject = result.GetDirectoryEntry();
if (returnValue.Equals(returnType.distinguishedName))
{
distinguishedName = "LDAP://" + directoryObject.Properties["distinguishedName"].Value;
}
if (returnValue.Equals(returnType.ObjectGUID))
{
distinguishedName = directoryObject.Guid.ToString();
}
entry.Close();
entry.Dispose();
mySearcher.Dispose();
return distinguishedName;
}
internal bool checkGroupExists(string groupName)
{
checkConnection();
DirectorySearcher mySearcher = new DirectorySearcher(entry);
mySearcher.Filter = "(&(objectClass=group)(name=" + groupName + "))";
SearchResultCollection resultSet = mySearcher.FindAll();
mySearcher.Dispose();
return resultSet.Count > 0;
}
public string ResolveUsernameToLookupValue(string username, string staffInfoLookupKey)
{
if (lookupValuesByUsername.ContainsKey(username))
return lookupValuesByUsername[username];
DirectorySearcher search = null;
string ldapLookupValue = null;
string ldapLookupKey = null;
try
{
ldapLookupKey = GetLdapLookupKey();
search = new DirectorySearcher(SearcherEntry)
{
Filter = "(" + LdapUsernameProperty + "=" + username + ")"
};
search.PropertiesToLoad.Add(ldapLookupKey);
var result = search.FindOne();
if (result == null)
return null;
if (!result.Properties.Contains(ldapLookupKey))
throw new DistrictProtocolAuthenticationException(string.Format(NoLookupValueErrorMessageFormat, string.Format(NoPropertyReturnedFormat, ldapLookupKey, username))) { Name = username };
if (result.Properties[ldapLookupKey].Count == 0)
throw new DistrictProtocolAuthenticationException(string.Format(NoLookupValueErrorMessageFormat, string.Format(EmptyPropertyCollectionFormat, ldapLookupKey, username))) { Name = username };
var resultValue = result.Properties[ldapLookupKey][0];
if (resultValue is string)
{
ldapLookupValue = (string)resultValue;
}
else if (resultValue is byte[])
{
//LDAP can return a few different types. If it's a byte[], it's probably because ldapLookupKey is objectsid. Convert the byte[] to a SID.
var sid = new System.Security.Principal.SecurityIdentifier((byte[]) (resultValue), 0);
ldapLookupValue = sid.ToString();
}
else
{
throw new InvalidCastException("The type of the Property is " + resultValue.GetType() + " and it needs to be a string or a SID.");
}
ldapLookupValue = ldapLookupValue.ToLower();
lookupValuesByUsername[username] = ldapLookupValue;
}
finally
{
if (search != null)
search.Dispose();
}
if (string.IsNullOrEmpty(ldapLookupValue))
throw new DistrictProtocolAuthenticationException(string.Format(NoLookupValueErrorMessageFormat, string.Format(BlankValueReturnedFormat, ldapLookupKey, username))) { Name = username };
return ldapLookupValue;
}
/// <summary>
/// Verifica si el usuario existe.-
/// </summary>
/// <param name="userName">Nombre de loging de usuario</param>
/// <returns></returns>
public bool User_Exists(string userName)
{
//create instance fo the direcory searcher
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
//set the search filter
//deSearch.Filter = "(&(objectClass=user) (cn=" + FilterOutDomain(userName) + "))";
//deSearch.Filter = string.Format("(&(objectClass=user)(sAMAccountName= {0} ))", FilterOutDomain(userName));
deSearch.Filter = string.Format("(&(ObjectClass={0})(sAMAccountName={1}))", "person", userName);
//find the first instance
SearchResultCollection results = deSearch.FindAll();
if (results.Count == 0)
{
deSearch.Dispose();
return false;
}
else
{
return true;
}
}
/// <summary>
/// Obtiene un usuario por nombre sin tener en cuenta las credenciales del usuario
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
DirectoryEntry Person_Get(string userName)
{
DirectoryEntry userDirectoryEntry = null;
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Filter = string.Format("(&(ObjectClass={0})(sAMAccountName={1}))", "person", userName);
deSearch.CacheResults = false;
//deSearch.SearchScope = System.DirectoryServices.SearchScope.Subtree;
SearchResult results = deSearch.FindOne();
//si result no es nulo se puede crear una DirectoryEntry
if (results != null)
userDirectoryEntry = new DirectoryEntry(results.Path);
deSearch.Dispose();
return userDirectoryEntry;
}
/// <summary>
/// Obtiene un usuario por nombre sin tener en cuenta las credenciales del usuario
/// </summary>
/// <param name="userName"></param>
/// <returns></returns>
DirectoryEntry User_Get(string userName)
{
DirectoryEntry userDirectoryEntry = null;
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Filter = string.Format("(&(objectClass=user)(sAMAccountName={0}))",FilterOutDomain(userName));
//deSearch.Filter = "(&(objectClass=user)(cn=" + FilterOutDomain(userName) + "))";
deSearch.CacheResults = false;
deSearch.SearchScope = System.DirectoryServices.SearchScope.Subtree;
SearchResult results = deSearch.FindOne();
//si result no es nulo se puede crear una DirectoryEntry
if (results != null)
userDirectoryEntry = new DirectoryEntry(results.Path);
deSearch.Dispose();
return userDirectoryEntry;
}
/// <summary>
/// Checks if a userprincipalname exists
/// </summary>
/// <param name="userPrincipalName"></param>
/// <returns></returns>
private bool DoesUserPrincipalNameExist(string userPrincipalName)
{
DirectoryEntry de = null;
DirectorySearcher ds = null;
try
{
logger.Debug("Attempting to find out if userprincipalname exists " + userPrincipalName);
de = new DirectoryEntry("LDAP://" + this.domainController, this.username, this.password);
ds = new DirectorySearcher(de);
ds.SearchScope = SearchScope.Subtree;
ds.Filter = string.Format("(userPrincipalName={0})", userPrincipalName);
if (ds.FindOne() != null)
return true;
else
return false;
}
catch (Exception ex)
{
this.logger.Error("Error checking if user exists " + userPrincipalName, ex);
throw;
}
finally
{
if (ds != null)
ds.Dispose();
if (de != null)
de.Dispose();
}
}
/// <summary>
/// Obtiene un ADGroup que reprecenta un grupo
/// </summary>
/// <param name="pName"></param>
/// <returns></returns>
public ADGroup Group_GetByName(String pName)
{
string filter = string.Format("(&(ObjectClass={0})(sAMAccountName={1}))", "group", pName);
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Filter = filter;
SearchResult result = deSearch.FindOne();
if (result == null) return null;
DirectoryEntry directoryEntry = result.GetDirectoryEntry();
ADGroup wADGroup = new ADGroup(directoryEntry);
directoryEntry.Close();
directoryEntry.Dispose();
deSearch.Dispose();
return wADGroup;
}
/// <summary>
/// Find an availble sAMAccountName
/// It loops and appends a number to the end of a sAMAccountNAme if the original doesn't exist
/// </summary>
/// <param name="userPrincipalName"></param>
/// <returns></returns>
private string GetAvailableSamAccountName(string userPrincipalName)
{
DirectoryEntry de = null;
DirectorySearcher ds = null;
try
{
logger.Debug("Attempting to find an available sAMAccountName for " + userPrincipalName);
// Get the first part of the user principal name
string upnFirstPart = userPrincipalName.Split('@')[0];
string sAMAccountName = upnFirstPart;
de = new DirectoryEntry("LDAP://" + this.domainController, this.username, this.password);
ds = new DirectorySearcher(de);
ds.SearchScope = SearchScope.Subtree;
ds.Filter = string.Format("(&(objectClass=User)(sAMAccountName={0}))", upnFirstPart);
int count = 0;
while (ds.FindOne() != null)
{
count++;
sAMAccountName = string.Format("{0}{1}", upnFirstPart, count.ToString());
ds.Filter = string.Format("(&(objectClass=User)(sAMAccountName={0}))", sAMAccountName);
}
// We found our available sAMAccountName
return sAMAccountName;
}
catch (Exception ex)
{
this.logger.Error("Error retrieving user information " + userPrincipalName, ex);
throw;
}
finally
{
if (ds != null)
ds.Dispose();
if (de != null)
de.Dispose();
}
}
/// <summary>
/// Obtiene todo los grupos pertenecientes al dominio.-
/// </summary>
public List<ADGroup> Groups_GetAll()
{
List<ADGroup> pList = null;
ADGroup group = null;
pList = new List<ADGroup>();
DirectoryEntry wDirectoryEntry = null;
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Filter = "(&(objectClass=group))";
deSearch.Sort.PropertyName = "sAMAccountName";
deSearch.Sort.Direction = System.DirectoryServices.SortDirection.Ascending;
try
{
foreach (SearchResult result in deSearch.FindAll())
{
wDirectoryEntry = result.GetDirectoryEntry();
//GetProperties(wDirectoryEntry, "pQuery");
if (wDirectoryEntry.Properties.Contains("sAMAccountName"))
{
group = new ADGroup(wDirectoryEntry);
pList.Add(group);
}
}
wDirectoryEntry.Close();
wDirectoryEntry.Dispose();
deSearch.Dispose();
return pList;
}
catch (Exception ex)
{
throw ProcessActiveDirectoryException(ex);
}
}
/// <summary>
/// Obtiene todo los usuarios pertenecientes al dominio.-
/// Busca por cn nombre@mail retorna el sAMAccountName ejemplo: moviedo
/// </summary>
List<String> User_SearchGroupStringList(String userName)
{
DirectoryEntry directoryEntryUser = null;
List<String> list = null;
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Filter = string.Format("(&(ObjectClass={0})(sAMAccountName={1}))", "person", userName);
try
{
SearchResult result = deSearch.FindOne();
if (result != null)
{
directoryEntryUser = result.GetDirectoryEntry();
list = new List<String>();
foreach (string grouInfo in directoryEntryUser.Properties["memberOf"])
{
foreach (string g in GetGroupFromMemberOf(grouInfo))
{
list.Add(g);
}
}
directoryEntryUser.Close();
directoryEntryUser.Dispose();
}
deSearch.Dispose();
return list;
}
catch (Exception ex)
{
throw ProcessActiveDirectoryException(ex);
}
}
/// <summary>
/// Executes the task.
/// </summary>
/// <returns>
/// <see langword="true"/> if the task ran successfully; otherwise <see langword="false"/>.
/// </returns>
public override bool Execute()
{
try
{
_userName = Environment.UserName;
_domainName = Environment.UserDomainName;
DirectoryEntry userEntry = null;
DirectorySearcher searcher = new DirectorySearcher();
try
{
// Try to retrieve user information from Active Directory if possible.
searcher.Filter = string.Format("(SAMAccountName={0})", _userName);
userEntry = searcher.FindOne().GetDirectoryEntry();
if (userEntry != null)
{
_firstName = userEntry.Properties["givenName"][0].ToString();
_lastName = userEntry.Properties["sn"][0].ToString();
_middleInitial = userEntry.Properties["initials"][0].ToString();
_email = userEntry.Properties["mail"][0].ToString();
_phone = userEntry.Properties["telephoneNumber"][0].ToString();
}
}
catch
{
Log.LogWarning(Properties.Resources.ActiveDirectoryLookupException, UserNameWithDomain);
}
finally
{
searcher.Dispose();
if (userEntry != null) { userEntry.Dispose(); }
}
return true;
}
catch (Exception ex)
{
Log.LogErrorFromException(ex);
return false;
}
}
public string ResolveLookupValueToUsername(string lookupValue)
{
DirectorySearcher search = null;
try
{
var ldapLookupKey = GetLdapLookupKey();
search = new DirectorySearcher(SearcherEntry)
{
Filter = "(" + ldapLookupKey + "=" + lookupValue + ")"
};
search.PropertiesToLoad.Add(LdapUsernameProperty);
SearchResult result = search.FindOne();
if (result == null)
throw new InvalidOperationException(String.Format("Ldap directory returned no results for query: '({0}={1})'", ldapLookupKey, lookupValue));
// Property names are keyed in lower case by System.DirectoryServices
string username = (string)result.Properties[LdapUsernameProperty.ToLower()][0];
if (String.IsNullOrWhiteSpace(username))
throw new InvalidOperationException(String.Format("Ldap directory returned results for query: '({0}={1})' but the first result value was null or an empty string.", ldapLookupKey, lookupValue));
if (lookupValuesByUsername.ContainsKey(username))
lookupValuesByUsername[username] = lookupValue;
return username;
}
finally
{
if (search != null)
search.Dispose();
}
}
/// <summary>
/// Retorna la lista de usuarios pertenecientes a un determinado grupo
/// </summary>
/// <param name="groupName">Nombre del grupo</param>
/// <returns></returns>
public List<ADUser> Users_SearchByGroupName(String groupName)
{
List<ADUser> userlist = new List<ADUser>();
ADUser wADUser = null;
DirectoryEntry directoryEntryUser = null;
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
//deSearch.Filter = "(&(objectClass=group)(SAMAccountName=" + groupName + "))";
deSearch.Filter = string.Format("(&(objectClass=group)(SAMAccountName={0}))", groupName);
try
{
SearchResult results = deSearch.FindOne();
if (results != null)
{
DirectoryEntry deGroup = new DirectoryEntry(results.Path, LDAPUser, LDAPPassword);
System.DirectoryServices.PropertyCollection pColl = deGroup.Properties;
int count = pColl["member"].Count;
for (int i = 0; i < count; i++)
{
string respath = results.Path;
string[] pathnavigate = respath.Split("CN".ToCharArray());
respath = pathnavigate[0];
string objpath = pColl["member"][i].ToString();
string path = string.Concat(respath, objpath);
directoryEntryUser = new DirectoryEntry(path, LDAPUser, LDAPPassword);
wADUser = new ADUser(directoryEntryUser);
userlist.Add(wADUser);
directoryEntryUser.Close();
directoryEntryUser.Dispose();
}
deGroup.Close();
deGroup.Dispose();
}
deSearch.Dispose();
return userlist;
}
catch (Exception ex)
{
throw ProcessActiveDirectoryException(ex);
}
}
public static List<string> ListOU(string name)
{
List<string> ous = new List<string>();
using (DirectoryEntry root = new DirectoryEntry("LDAP://" + name))
{
DirectorySearcher searcher = new DirectorySearcher(root);
searcher.Filter = "(&(objectClass=organizationalUnit))";
searcher.SearchScope = SearchScope.Subtree;
searcher.PropertiesToLoad.Add("distinguishedName");
var result = searcher.FindAll();
foreach (SearchResult entry in result)
{
ous.Add(entry.GetDirectoryEntry().Properties["distinguishedName"].Value.ToString());
}
result.Dispose();
searcher.Dispose();
}
return ous;
}
/// <summary>
/// Retorna una lista de usuarios cuyo nombre comiense con fname.-
/// Ejemplo: evel*
/// </summary>
/// <param name="fName"></param>
/// <returns></returns>
public List<ADUser> Users_Search_StartName(string fName)
{
List<ADUser> userlist = new List<ADUser>();
DirectorySearcher deSearch = new DirectorySearcher(_directoryEntrySearchRoot);
deSearch.Asynchronous = true;
deSearch.CacheResults = true;
//string filter = string.Format("(givenName={0}*", fName);
//filter = "(&(objectClass=user)(objectCategory=person)" + filter + ")";
deSearch.Filter = string.Format("(&(objectClass=user)(objectCategory=person)(givenName={0}*))", fName);
try
{
SearchResultCollection userCollection = deSearch.FindAll();
foreach (SearchResult users in userCollection)
{
DirectoryEntry userEntry = new DirectoryEntry(users.Path, LDAPUser, LDAPPassword);
userlist.Add(new ADUser(userEntry));
}
deSearch.Dispose();
return userlist;
}
catch (Exception ex)
{
throw ProcessActiveDirectoryException(ex);
}
}