private static void SearchComp(List<CompData> comps, string domainName)
{
using (PrincipalContext ctx = new PrincipalContext(ContextType.Domain, domainName))
{
foreach (var comp in comps)
{
if (comp.CompName == null)
{
var sp = new ComputerPrincipal(ctx);
sp.Description = comp.User.Name;
var searcher = new PrincipalSearcher(sp);
var res = searcher.FindAll();
foreach (var p in res)
{
if (p is ComputerPrincipal)
{
var findComp = (ComputerPrincipal)p;
comp.CompName = findComp.Name;
comp.CompPath = findComp.DistinguishedName;
}
}
}
}
}
}
/// <summary>
/// Constructor that instantiates an AdComputer object with values of the attributes of the
/// specified ComputerPrincipal object.
/// </summary>
/// <param name="computer"></param>
public AdComputer(ComputerPrincipal computer)
{
this.AccountExpirationDate = computer.AccountExpirationDate.ToString();
this.AccountLockouttime = computer.AccountLockoutTime.ToString();
this.BadLogonCount = computer.BadLogonCount;
this.DelegationPermitted = computer.DelegationPermitted;
this.Description = computer.Description;
this.DisplayName = computer.DisplayName;
this.DistinguishedName = computer.DistinguishedName;
this.Enabled = computer.Enabled;
this.Guid = computer.Guid.ToString();
this.HomeDirectory = computer.HomeDirectory;
this.HomeDrive = computer.HomeDrive;
this.LastBadPasswordAttempt = computer.LastBadPasswordAttempt.ToString();
this.Name = computer.Name;
this.PasswordNeverExpires = computer.PasswordNeverExpires;
this.PasswordNotRequired = computer.PasswordNotRequired;
this.SamAccountName = computer.SamAccountName;
this.ScriptPath = computer.ScriptPath;
List<string> svcPNs = new List<string>();
foreach (var spn in computer.ServicePrincipalNames)
{
svcPNs.Add(spn);
}
this.ServicePrincipalNames = svcPNs;
this.Sid = computer.Sid.Value;
this.SmartcardLogonRequired = computer.SmartcardLogonRequired;
this.UserCannotChangePassword = computer.UserCannotChangePassword;
this.UserPrincipalName = computer.UserPrincipalName;
}
private void CreateNewComputer(string computerName, string computerOUPath)
{
try
{
// Set default Directory OU Path
PrincipalContext setOU = new PrincipalContext(ContextType.Domain, null, computerOUPath);
// Create new Computer object
ComputerPrincipal newComputerObject = new ComputerPrincipal(setOU, computerName, "password", enabled: true);
// Set Extra Computer Info
newComputerObject.DisplayName = computerName;
// Save settings
using (newComputerObject)
{
newComputerObject.Save();
}
// Close Connection
newComputerObject.Dispose();
}
catch (Exception ex)
{
Console.WriteLine("Some error to create computer object" + ex.Message);
throw;
}
}
static internal Principal SearchResultToPrincipal(SearchResult sr, PrincipalContext owningContext, Type principalType)
{
Principal p;
// Construct an appropriate Principal object.
// Make* constructs a Principal that is marked persisted
// and not loaded (p.unpersisted = false, p.loaded = false).
// Since there should be no more multistore contexts, the owning context IS
// the specific context
// If we know the type we should just construct it ourselves so that we don't need to incur the costs of reflection.
// If this is an extension type then we must reflect teh constructor to create the object.
if (typeof(UserPrincipal) == principalType)
{
p = UserPrincipal.MakeUser(owningContext);
}
else if (typeof(ComputerPrincipal) == principalType)
{
p = ComputerPrincipal.MakeComputer(owningContext);
}
else if (typeof(GroupPrincipal) == principalType)
{
p = GroupPrincipal.MakeGroup(owningContext);
}
else if (null == principalType ||
typeof(AuthenticablePrincipal) == principalType ||
typeof(Principal) == principalType)
{
if (SDSUtils.IsOfObjectClass(sr, "computer"))
{
p = ComputerPrincipal.MakeComputer(owningContext);
}
else if (SDSUtils.IsOfObjectClass(sr, "user"))
{
p = UserPrincipal.MakeUser(owningContext);
}
else if (SDSUtils.IsOfObjectClass(sr, "group"))
{
p = GroupPrincipal.MakeGroup(owningContext);
}
else
{
p = AuthenticablePrincipal.MakeAuthenticablePrincipal(owningContext);
}
}
else
{
p = Principal.MakePrincipal(owningContext, principalType);
}
// The DirectoryEntry we're constructing the Principal from
// will serve as the underlying object for that Principal.
p.UnderlyingSearchObject = sr;
// It's up to our caller to assign an appropriate StoreKey.
// Caller must also populate the underlyingObject field if the P is to be used R/W
return(p);
}
internal static ComputerPrincipal MakeComputer(PrincipalContext ctx)
{
ComputerPrincipal computerPrincipal = new ComputerPrincipal(ctx);
computerPrincipal.unpersisted = false;
return(computerPrincipal);
}
internal static Principal SearchResultToPrincipal(SearchResult sr, PrincipalContext owningContext, Type principalType)
{
Principal principal;
if (typeof(UserPrincipal) != principalType)
{
if (typeof(ComputerPrincipal) != principalType)
{
if (typeof(GroupPrincipal) != principalType)
{
if (null == principalType || typeof(AuthenticablePrincipal) == principalType || typeof(Principal) == principalType)
{
if (!SDSUtils.IsOfObjectClass(sr, "computer"))
{
if (!SDSUtils.IsOfObjectClass(sr, "user"))
{
if (!SDSUtils.IsOfObjectClass(sr, "group"))
{
principal = AuthenticablePrincipal.MakeAuthenticablePrincipal(owningContext);
}
else
{
principal = GroupPrincipal.MakeGroup(owningContext);
}
}
else
{
principal = UserPrincipal.MakeUser(owningContext);
}
}
else
{
principal = ComputerPrincipal.MakeComputer(owningContext);
}
}
else
{
principal = Principal.MakePrincipal(owningContext, principalType);
}
}
else
{
principal = GroupPrincipal.MakeGroup(owningContext);
}
}
else
{
principal = ComputerPrincipal.MakeComputer(owningContext);
}
}
else
{
principal = UserPrincipal.MakeUser(owningContext);
}
principal.UnderlyingSearchObject = sr;
return(principal);
}
internal static Principal DirectoryEntryToPrincipal(DirectoryEntry de, PrincipalContext owningContext, Type principalType)
{
Principal principal;
if (typeof(UserPrincipal) != principalType)
{
if (typeof(ComputerPrincipal) != principalType)
{
if (typeof(GroupPrincipal) != principalType)
{
if (null == principalType || typeof(AuthenticablePrincipal) == principalType || typeof(Principal) == principalType)
{
if (!SDSUtils.IsOfObjectClass(de, "computer"))
{
if (!SDSUtils.IsOfObjectClass(de, "user"))
{
if (!SDSUtils.IsOfObjectClass(de, "group"))
{
principal = AuthenticablePrincipal.MakeAuthenticablePrincipal(owningContext);
}
else
{
principal = GroupPrincipal.MakeGroup(owningContext);
}
}
else
{
principal = UserPrincipal.MakeUser(owningContext);
}
}
else
{
principal = ComputerPrincipal.MakeComputer(owningContext);
}
}
else
{
principal = Principal.MakePrincipal(owningContext, principalType);
}
}
else
{
principal = GroupPrincipal.MakeGroup(owningContext);
}
}
else
{
principal = ComputerPrincipal.MakeComputer(owningContext);
}
}
else
{
principal = UserPrincipal.MakeUser(owningContext);
}
principal.UnderlyingObject = de;
return(principal);
}
// Used to implement StoreCtx.GetAsPrincipal for AD and SAM
static internal Principal DirectoryEntryToPrincipal(DirectoryEntry de, PrincipalContext owningContext, Type principalType)
{
Principal p;
// Construct an appropriate Principal object.
// Make* constructs a Principal that is marked persisted
// and not loaded (p.unpersisted = false, p.loaded = false).
// Since there should be no more multistore contexts, the owning context IS
// the specific context
if (typeof(UserPrincipal) == principalType)
{
p = UserPrincipal.MakeUser(owningContext);
}
else if (typeof(ComputerPrincipal) == principalType)
{
p = ComputerPrincipal.MakeComputer(owningContext);
}
else if (typeof(GroupPrincipal) == principalType)
{
p = GroupPrincipal.MakeGroup(owningContext);
}
else if (null == principalType ||
typeof(AuthenticablePrincipal) == principalType ||
typeof(Principal) == principalType)
{
if (SDSUtils.IsOfObjectClass(de, "computer"))
{
p = ComputerPrincipal.MakeComputer(owningContext);
}
else if (SDSUtils.IsOfObjectClass(de, "user"))
{
p = UserPrincipal.MakeUser(owningContext);
}
else if (SDSUtils.IsOfObjectClass(de, "group"))
{
p = GroupPrincipal.MakeGroup(owningContext);
}
else
{
p = AuthenticablePrincipal.MakeAuthenticablePrincipal(owningContext);
}
}
else
{
p = Principal.MakePrincipal(owningContext, principalType);
}
// The DirectoryEntry we're constructing the Principal from
// will serve as the underlying object for that Principal.
p.UnderlyingObject = de;
// It's up to our caller to assign an appropriate StoreKey.
return(p);
}
/// <summary>
/// Seeks one computer account in Active Directory whose name exactly matches the parameter.
/// </summary>
/// <param name="computerName">The name of the computer account to look for.</param>
/// <returns>Returns a computer model of the computer found, or an empty model.</returns>
public static Computer GetADComputerByName(string computerName)
{
using (var context = new PrincipalContext(ContextType.Domain, Properties.Resources.DC1UPN, Properties.Resources.DomainRootOU, Properties.Resources.DomainAccount, Properties.Resources.domain))
{
try
{
var searchPrinciple = new ComputerPrincipal(context){Name = computerName};
var search = new PrincipalSearcher(searchPrinciple);
var searchResult = (ComputerPrincipal)search.FindOne();
return searchResult != null ? PrincipalToADComputer(searchResult) : null;
}
catch (Exception ex)
{
throw new Exception("GetADComputerByName.\n" + ex.Message);
}
}
}
protected void Page_Load(object sender, EventArgs e)
{
UserPanel.Visible = false;
ComputerPanel.Visible = false;
PrincipalContext pc = new PrincipalContext( ContextType.Domain, "ITSERVICES" );
ComputerPrincipal computer = new ComputerPrincipal( pc );
computer.Name = "*"; //reg expression
PrincipalSearcher ps = new PrincipalSearcher();
ps.QueryFilter = computer;
((System.DirectoryServices.DirectorySearcher)ps.GetUnderlyingSearcher()).PageSize = 500;
PrincipalSearchResult<Principal> psr = ps.FindAll();
AD_Computers = new string[psr.Count()];
int i = 0;
foreach ( ComputerPrincipal cp in psr )
{
AD_Computers[i++] = cp.Name;
}
}
/// <summary>
/// Deletes all computer accounts from Active Directory that end with a hyphen, plus asset tag.
/// </summary>
/// <param name="asset">The asset tag of the computer to be deleted.</param>
/// <param name="whatif">Runs only the logic without actually deleting the account.</param>
/// <returns>Returns true if the accounts were (or would have been -- if whatif is true) deleted, otherwise false.</returns>
public static bool DeleteComputersByAsset(string asset, bool whatif = false)
{
using (var context = new PrincipalContext(ContextType.Domain, Properties.Resources.DC1UPN, Properties.Resources.DomainRootOU, Properties.Resources.DomainAccount, Properties.Resources.domain))
{
var searchPrinciple = new ComputerPrincipal(context) {Name = $"*-{asset}" };
try
{
var search = new PrincipalSearcher(searchPrinciple);
var searchResult = search.FindAll().Select(ps => ps as ComputerPrincipal).ToList();
foreach (var curComputer in searchResult)
{
if (!whatif) curComputer.Delete();
}
return true;
}
catch (Exception ex)
{
var newException = new Exception("Exception in Global.cs -> DeleteComputersByAsset.\n" + ex.Message);
throw newException;
}
}
}
public bool Contains(ComputerPrincipal computer)
{
return(this.Contains(computer));
}
/// <summary>
/// Converts an AD computer object to an AD computer Model.
/// </summary>
/// <param name="computerPrincipal">The AD computer object to convert.</param>
/// <returns>Returns the converted computer model, or null if it couldn't.</returns>
private static Computer PrincipalToADComputer(ComputerPrincipal computerPrincipal)
{
try
{
return new Computer()
{
DistinguishedName = computerPrincipal.DistinguishedName,
Name = computerPrincipal.Name
};
}
catch
{
return null;
}
}
//
// Internal "constructor": Used for constructing Computer returned by a query
//
static internal ComputerPrincipal MakeComputer(PrincipalContext ctx)
{
ComputerPrincipal computer = new ComputerPrincipal(ctx);
computer.unpersisted = false;
return computer;
}
/// <summary>
/// ADD Active Directory Computer Obbject
/// </summary>
/// <param name="computerInfo">ADComputerRequest</param>
/// <returns>ResponseMessage</returns>
public ResponseMessage AddMachine( RequestComputerCreate computerInfo )
{
ResponseMessage status = new ResponseMessage();
status.IsSuccessful = false;
status.Message = string.Empty;
Session stat = ValidateSession( computerInfo.DomainInfo.SessionKey );
if ( stat.IsAuthenticated == true )
{
string uri = FixADURI( computerInfo.DomainInfo.ADHost , computerInfo.DomainInfo.ContainerPath );
if ( string.IsNullOrWhiteSpace( uri ) )
{
status.Message = status.Message = "AD Host is not allowed to be empty, kindly provide the AD Host";
return status;
}
bool isAllowWite = CheckWriteOermission( uri , computerInfo.DomainInfo.BindingUserName , computerInfo.DomainInfo.BindingUserPassword );
try
{
ComputerPrincipal computer = FindADComputer( computerInfo.SamAccountName , computerInfo.DomainInfo );
if ( computer != null )
{
status.Message = @"There is a existing computer with the provided name, kindly choose another name";
return status;
}
else
{
var principalContext = new PrincipalContext( ContextType.Domain , computerInfo.DomainInfo.DomainName , computerInfo.DomainInfo.ContainerPath , computerInfo.DomainInfo.BindingUserName , computerInfo.DomainInfo.BindingUserPassword );
computer = new ComputerPrincipal( principalContext );
computer.DisplayName = computerInfo.DisplayName;
computer.Description = computerInfo.Description;
computer.SamAccountName = computerInfo.SamAccountName;
computer.Enabled = true;
computer.SetPassword( GenerateADPassword( uri , computerInfo.DomainInfo.BindingUserName , computerInfo.DomainInfo.BindingUserPassword ) );
computer.Save();
status.Message = @"Computer has been added successfully ";
status.IsSuccessful = true;
return status;
}
}
catch ( Exception ex )
{
status.Message = status.Message = "error has accured while adding the desgnated group" + ex;
return status;
}
}
else
{
status.Message = "Kindly authenticate first";
return status;
}
}
public bool Remove(ComputerPrincipal computer)
{
return(this.Remove(computer));
}
private void btn_createPC_Click(object sender, RoutedEventArgs e)
{
if (currentPC == null || currentBranch == null)
{
MessageBox.Show("Before createing new PC, you must select Current Branch and generate free PC name!", "Error", MessageBoxButton.OK, MessageBoxImage.Stop);
return;
}
MessageBoxResult mbr = MessageBox.Show(String.Format("Create new PC with name {0} in OU {1}", currentPC, currentBranch), "Agree or disagree?", MessageBoxButton.YesNo,
MessageBoxImage.Question);
if (mbr == MessageBoxResult.No) return;
if (mbr == MessageBoxResult.Yes)
{
try
{
pcx = new PrincipalContext(ContextType.Domain, "bin.bank", String.Format("OU={0},OU=BIN BRANCHES,DC=BIN,DC=BANK", currentBranch), username, password);
ComputerPrincipal comp = new ComputerPrincipal(pcx, currentPC, "", true);
if (ckbx_description.IsChecked == true)
{
string diskrip = Interaction.InputBox("Input a description if needed.", "Description for " + currentPC, "Иванов И. В.");
comp.Description = (diskrip == "") ? null : diskrip;
}
comp.Save();
MessageBox.Show("Successfully!", "Information", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex) { MessageBox.Show(ex.Message); }
finally { pcx.Dispose(); }
}
}
public void Add(ComputerPrincipal computer)
{
this.Add(computer);
}
public void ComputerPrincipalConstructorTest()
{
ComputerPrincipal computer = new ComputerPrincipal(domainContext);
computer.Dispose();
Assert.Inconclusive("TODO: Implement code to verify target");
}
internal override Principal CreatePrincipal(PrincipalContext context, string name)
{
ComputerPrincipal computer = new ComputerPrincipal(context);
computer.Name = name;
return computer;
}
public bool Contains(ComputerPrincipal computer)
{
return(Contains((Principal)computer));
}
/// <summary>
/// Creates a computer with the specified name and description in the specified location.
/// </summary>
/// <param name="name">The name of the new computer.</param>
/// <param name="location">The distinguished name of the OU in which the computer should be created.</param>
/// <param name="description">The description of the new computer.</param>
/// <returns>A ComputerPrincipal object representing the new computer.</returns>
public static ComputerPrincipal CreateComputer(string name, string location, string description)
{
ComputerPrincipal newComputer = new ComputerPrincipal(GetPrincipalContext(location), name, GetRandomPassword(), true);
newComputer.Description = description;
newComputer.DisplayName = name;
newComputer.Name = name;
newComputer.Save();
return newComputer;
}
public void Add(ComputerPrincipal computer)
{
Add((Principal)computer);
}
public bool Remove(ComputerPrincipal computer)
{
return(Remove((Principal)computer));
}
protected void fillBtn_Click(object sender, EventArgs e)
{
if ( isNull() )
return;
using ( PrincipalContext context = new PrincipalContext( ContextType.Domain, "ITSERVICES" ) )
{
ComputerPrincipal computer = new ComputerPrincipal( context );
computer.Name = ComputerTextBox.Text;
using ( PrincipalSearcher searcher = new PrincipalSearcher( computer ) )
{
Principal result = searcher.FindOne();
AuthenticablePrincipal auth = result as AuthenticablePrincipal;
if ( auth != null )
{
lblName.Text = auth.Name;
lblLastLogon.Text = auth.LastLogon.ToString();
lblEnabled.Text = auth.Enabled.ToString();
lblDistinguishedName.Text = auth.DistinguishedName;
}
}
}
ComputerPanel.Visible = true;
}