public string ConnectToLDAP() {
List<string> props = new List<string>();
props.Add("cn");
AuthenticationType = AuthenticationTypes.Secure;
type = LdapService.ActiveDirectory;
return Connect(userName, "(SAMAccountName=" + userName + ")", props);
}
/// <summary>
/// Rename AD user.
/// </summary>
/// <param name="ldapConnectionInfo">Properties to define LDAP connection</param>
/// <param name="userProperties">Properties to define the user to be renamed</param>
/// <returns>operationSuccessful = true if operation is ok.</returns>
public static OutputUser AD_RenameUser([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] AD_RenameUserProperties userProperties)
{
var ldapOperationResult = new OutputUser {
OperationSuccessful = false, User = null
};
List <DirectoryEntry> tmpObjectEntries;
ldapConnectionInfo.LdapUri = ldapConnectionInfo.LdapUri + "/" + userProperties.Path;
var filter = "(&(objectClass=user)(cn=" + userProperties.Cn + "))";
// @"(&(objectClass=user)(cn=MattiMeikalainen))
using (var ldap = new LdapService(ldapConnectionInfo))
{
tmpObjectEntries = ldap.SearchObjectsByFilter(filter);
if (tmpObjectEntries.Count == 1)
{
ldapOperationResult.User = ldap.RenameAdUser(tmpObjectEntries[0], userProperties.NewCn);
}
else if (tmpObjectEntries.Count == 0)
{
throw new Exception($"Did not find any entries matching filter {filter} from {ldapConnectionInfo.LdapUri}");
}
else if (tmpObjectEntries.Count > 1)
{
throw new Exception($"Found more than one entry matching filter {filter} from {ldapConnectionInfo.LdapUri}");
}
}
ldapOperationResult.OperationSuccessful = true;
return(ldapOperationResult);
}
/// <summary>
/// Searches Active Directory for objects specified by the given Path + filter, included in the AD_SearchObjectProperties class.
/// </summary>
/// <param name="ldapConnectionInfo">The LDAP connection information</param>
/// <param name="SearchParameters">Path, filter and returned properties needed for the query</param>
/// <returns>LdapResult class: the Collection of the SearchEntry classes.</returns>
public static List <OutputSearchEntry> AD_SearchObjects([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] AD_SearchObjectProperties SearchParameters)
{
var ldapQueryInfo = new LdapConnectionInfo
{
LdapUri = ldapConnectionInfo.LdapUri + "/" + SearchParameters.Path,
Username = ldapConnectionInfo.Username,
Password = ldapConnectionInfo.Password
};
List <SearchResult> tmpObjectEntries;
// Search objects.
using (var ldap = new LdapService(ldapQueryInfo))
tmpObjectEntries = ldap.SearchObjectsByFilterSpecifyProperties(SearchParameters.Filter, SearchParameters.PropertiesToLoad, SearchParameters.PageSize);
// Create & return result list.
var retOutputs = new List <OutputSearchEntry>();
foreach (var item in tmpObjectEntries)
{
var outputClass = new OutputSearchEntry
{
SearchEntry = item
};
retOutputs.Add(outputClass);
}
return(retOutputs);
}
public void SyncFromLdap()
{
var sites = LdapService.GetSites();
var sitesAdded = DataService.InsertSitesData(sites);
var depts = LdapService.GetDepartments();
var deptsAdded = DataService.InsertDepartmentsData(depts);
var employees = LdapService.GetEmployees();
var empsAdded = DataService.InsertEmployeesData(employees);
var userGroups = LdapService.GetGroups();
var groupsAdded = DataService.InsertGroupsData(userGroups);
var userMappings = new List <GroupMappingDTO>();
userGroups.ToList().ForEach(g =>
{
var mappings = g.MemberLogins.Select(m => new GroupMappingDTO {
EmployeeLogin = m, GroupId = g.Id
});
userMappings.AddRange(mappings.ToList());
});
var mappingsAdded = DataService.InsertGroupMappings(userMappings);
var deptManagers = LdapService.GetDepartmentManagers();
var deptMgrsAdded = DataService.InsertDeptManagers(deptManagers);
}
private async Task AddAsync()
{
try
{
if (!Groups.Any(x => x.Checked))
{
WarningMessage = "Please select at least one group.";
return;
}
await LdapService.AddGroupsAsync(Groups.Where(x => x.Checked).ToList(), CreateEmployees);
await ToastService.ShowToastAsync("Groups added.", ToastType.Success);
await SynchronizationService.UpdateGroups(ExceptPageId);
await ModalDialogService.CloseAsync();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CancelAsync();
}
}
private async Task AddAsync()
{
try
{
if (!Users.Any(x => x.Checked))
{
WarningMessage = "Please select at least one user.";
return;
}
await LdapService.AddUsersAsync(Users.Where(x => x.Checked).ToList(), CreateAccounts, CreateGroups);
await ToastService.ShowToastAsync("Employee imported.", ToastType.Success);
//await HubContext.Clients.AllExcept(ConnectionId).SendAsync(RefreshPage.Employees);
await ModalDialogService.CloseAsync();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogService.CancelAsync();
}
}
public IActionResult Login(string username, string password)
{
try
{
LdapService _ldapService = new LdapService(_ldapconfig);
var appUser = _ldapService.Login(username, password);
if (appUser != null && appUser.IsAuthenticated)
{
// insert user
if (!_eventsRepo.UserExists(username))
{
_eventsRepo.SaveUser(username, "");
}
Response.StatusCode = 200;
return(Ok(Response.StatusCode));
}
else
{
return(null);
}
}
catch (Exception ex)
{
}
return(null);
}
protected void BtnBuscarUsuario_Click(object sender, EventArgs e)
{
try
{
if (TxUsuario.Text == String.Empty)
{
throw new Exception("Ingrese un usuario para proceder con la busqueda.");
}
LdapService vLdap = new LdapService();
DataTable vDatos = vLdap.GetDatosUsuario(ConfigurationManager.AppSettings["ADHOST"], TxUsuario.Text);
if (vDatos.Rows.Count > 0)
{
TxCorreo.Text = vDatos.Rows[0]["mail"].ToString();
TxNombres.Text = vDatos.Rows[0]["givenName"].ToString();
TxApellidos.Text = vDatos.Rows[0]["sn"].ToString();
}
else
{
TxCorreo.Text = String.Empty;
TxNombres.Text = string.Empty;
TxApellidos.Text = String.Empty;
throw new Exception("No existe el usuario buscado");
}
}
catch (Exception Ex) { Mensaje(Ex.Message, WarningType.Danger); }
}
private async Task <bool> VerifyAdUserAsync()
{
try
{
await LdapService.VerifyAdUserAsync(Employee);
return(true);
}
catch (HESException ex) when(ex.Code == HESCode.ActiveDirectoryUserNotFound)
{
await EmployeeService.RemoveFromHideezKeyOwnersAsync(Employee.Id);
Employee = await EmployeeService.GetEmployeeByIdAsync(EmployeeId, asNoTracking : true);
await ToastService.ShowToastAsync(ex.Message, ToastType.Notify);
return(false);
}
catch (LdapException ex) when(ex.ResultCode == (LdapForNet.Native.Native.ResultCode) 81)
{
await ToastService.ShowToastAsync("The LDAP server is unavailable.", ToastType.Error);
return(false);
}
catch (Exception ex)
{
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
return(false);
}
}
private async Task EditAccountPasswordAsync()
{
try
{
await ButtonSpinner.SpinAsync(async() =>
{
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await EmployeeService.EditPersonalAccountPwdAsync(Account, AccountPassword);
if (AccountPassword.UpdateActiveDirectoryPassword)
{
await LdapService.SetUserPasswordAsync(Account.EmployeeId, AccountPassword.Password, LdapSettings);
}
transactionScope.Complete();
}
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId));
await ToastService.ShowToastAsync("Account password updated.", ToastType.Success);
await ModalDialogClose();
});
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogClose();
}
}
void getResponsables(String vIdInforme)
{
try{
LdapService vLdap = new LdapService();
String vQuery = "[ACSP_ObtenerUsuariosInforme] 1," + vIdInforme;
DataTable vDatosResponsables = vConexion.obtenerDataTable(vQuery);
DDLHallazgoResponsable.Items.Clear();
DDLModificarHallazgosResponsable.Items.Clear();
DDLHallazgoResponsable.Items.Add(new ListItem {
Value = "0", Text = "Seleccione un estado"
});
DDLModificarHallazgosResponsable.Items.Add(new ListItem {
Value = "0", Text = "Seleccione un estado"
});
foreach (DataRow item in vDatosResponsables.Rows)
{
DDLHallazgoResponsable.Items.Add(new ListItem {
Value = item["idUsuario"].ToString(), Text = vConexion.GetNombreUsuario(item["idUsuario"].ToString())
});
DDLModificarHallazgosResponsable.Items.Add(new ListItem {
Value = item["idUsuario"].ToString(), Text = vConexion.GetNombreUsuario(item["idUsuario"].ToString())
});
}
}
catch (Exception Ex) { Mensaje(Ex.Message, WarningType.Danger); }
}
protected void BtnLogin_Click(object sender, EventArgs e)
{
try{
LdapService vLdap = new LdapService();
//Boolean vLogin = vLdap.ValidateCredentials(ConfigurationManager.AppSettings["ADHOST"], TxUsername.Text, TxPassword.Text);
Boolean vLogin = true;
if (vLogin)
{
DataTable vDatos = new DataTable();
vDatos = vConexion.obtenerDataTable("ACSP_Login '" + TxUsername.Text + "'");
foreach (DataRow item in vDatos.Rows)
{
Session["AUTHCLASS"] = vDatos;
Session["USUARIO"] = item["idUsuario"].ToString();
Session["TIPOUSUARIO"] = item["tipoUsuario"].ToString();
Session["JEFEAUDITORIA"] = item["jefeAuditoria"].ToString();
Session["AUTH"] = true;
Response.Redirect("/default.aspx");
}
}
else
{
Session["AUTH"] = false;
throw new Exception("Usuario o contraseña incorrecta.");
}
}catch (Exception Ex) {
LbMensaje.Text = "Usuario o contraseña incorrecta.";
String vErrorLog = Ex.Message;
}
}
private async Task SaveSettingsAsync()
{
try
{
var isValid = LdapSettingsContext.Validate();
if (!isValid)
{
return;
}
await LdapService.ValidateCredentialsAsync(LdapSettings);
await AppSettingsService.SetLdapSettingsAsync(LdapSettings);
await ToastService.ShowToastAsync("Domain settings updated.", ToastType.Success);
await ModalDialogClose();
}
catch (LdapForNet.LdapInvalidCredentialsException)
{
ValidationErrorMessage.DisplayError(nameof(LdapSettings.Password), "Invalid password");
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
public ActionResult Index()
{
try
{
ViewBag.Error = false;
var tempData = (MessageVM)TempData["UserMessage"];
TempData["UserMessage"] = tempData;
ViewBag.DisplayName = Thread.CurrentPrincipal.Identity.Name;
if (ViewBag.Path != null)
{
m_LdapService = new LdapService(ViewBag.Path);
var usuario = m_LdapService.Search();
ViewBag.DisplayName = usuario.Nome;
return(View(usuario));
}
return(View());
}
catch (Exception ex)
{
ViewBag.Error = true;
TempData["UserMessage"] = new MessageVM()
{
CssClassName = "alert-error", Title = "Erro", Message = ex.Message
};
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
return(View());
}
}
private async Task GenerateAccountPasswordAsync()
{
try
{
if (LdapSettings?.Password == null)
{
throw new Exception("Active Directory credentials not set in parameters page.");
}
var accountPassword = new AccountPassword()
{
Password = PasswordGenerator.Generate()
};
using (TransactionScope transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await EmployeeService.EditPersonalAccountPwdAsync(Account, accountPassword);
await LdapService.SetUserPasswordAsync(Account.EmployeeId, accountPassword.Password, LdapSettings);
transactionScope.Complete();
}
RemoteDeviceConnectionsService.StartUpdateHardwareVaultAccounts(await EmployeeService.GetEmployeeVaultIdsAsync(Account.EmployeeId));
await ToastService.ShowToastAsync("Account password updated.", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
/// <summary>
/// Delete AD user.
/// </summary>
/// <param name="ldapConnectionInfo">Properties to define LDAP connection</param>
/// <param name="userProperties">Properties to define the user to be deleted</param>
/// <returns>operationSuccessful = true if operation is ok.</returns>
public static Output AD_DeleteUser([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] AD_DeleteUserProperties userProperties)
{
var ret_output = new Output();
List <DirectoryEntry> tmpObjectEntries;
ret_output.operationSuccessful = false;
ldapConnectionInfo.LdapUri = ldapConnectionInfo.LdapUri + "/" + userProperties.Path;
string filter = "(&(objectClass=user)(cn=" + userProperties.Cn + "))";
using (var ldap = new LdapService(ldapConnectionInfo))// @"(&(objectClass=user)(cn=MattiMeikalainen))
{
tmpObjectEntries = ldap.SearchObjectsByFilter(filter);
if (tmpObjectEntries.Count > 0)
{
ldap.DeleteAdUser(tmpObjectEntries[0]);
}
else
{
throw new System.Exception($"Did not find any entries matching filter {filter} from {ldapConnectionInfo.LdapUri}");
}
}
ret_output.operationSuccessful = true;
return(ret_output);
}
public AccountController(SignInManager <ApplicationUser> signInManager, UserManagementService userService, UserManager <ApplicationUser> userManager, LdapService ldapService)
{
_signInManager = signInManager;
_userService = userService;
_userManager = userManager;
_ldapService = ldapService;
}
public HomeController()
{
ViewBag.Path = WebConfigurationManager.AppSettings["LdapPath"];
if (ViewBag.Path != null)
{
m_LdapService = new LdapService(ViewBag.Path);
}
}
/// <summary>
/// Remove AD object from a set of groups.
/// </summary>
/// <param name="ldapConnectionInfo"></param>
/// <param name="target"></param>
/// <param name="groupsToRemoveFrom"></param>
/// <returns>Object { bool operationSuccessful }</returns>
public static Output AD_RemoveFromGroups([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] AD_RemoveFromGroupsTargetProperties target, [PropertyTab] AD_RemoveFromGroupsGroupProperties groupsToRemoveFrom)
{
var result = new Output();
using (var ldap = new LdapService(ldapConnectionInfo)) result.OperationSuccessful = ldap.RemoveFromGroups(target.Dn, groupsToRemoveFrom.Groups);
return(result);
}
public string ConnectToOpenLDAP()
{
List <string> props = new List <string>();
props.Add("cn");
AuthenticationType = AuthenticationTypes.None;
type = LdapService.OpenLDAP;
return(Connect(openLdapUserName, "(objectClass=*)", props));
}
public string ConnectToLDAP()
{
List <string> props = new List <string>();
props.Add("cn");
AuthenticationType = AuthenticationTypes.Secure;
type = LdapService.ActiveDirectory;
return(Connect(userName, "(SAMAccountName=" + userName + ")", props));
}
public LDAPHandler(string server, string rootDomain, string userName, string passWord) {
this.serverName = server;
this.rootDomain = rootDomain;
this.userName = userName;
this.openLdapUserName = "******" + userName + "," + rootDomain;
this.passWord = passWord;
this.isLoggedIn = false;
this.type = LdapService.None;
}
public RadiusRouter(Configuration configuration, IRadiusPacketParser packetParser, ILogger logger)
{
_configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_packetParser = packetParser ?? throw new ArgumentNullException(nameof(packetParser));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_multifactorApiClient = new MultiFactorApiClient(configuration, logger);
_activeDirectoryService = new ActiveDirectoryService(configuration, logger);
_ldapService = new LdapService(configuration, logger);
}
public void Setup()
{
_settingsService = Substitute.For <SettingsService>((IServiceProvider)null);
_certService = Substitute.For <CertificateValidationService>(_settingsService);
_ldap = Substitute.For <LdapAuthWrapper>();
_service = new LdapService(_settingsService, _certService, _ldap);
_settingsService.Ldap_Enable.Returns(false);
}
public LDAPHandler(string server, string rootDomain, string userName, string passWord)
{
this.serverName = server;
this.rootDomain = rootDomain;
this.userName = userName;
this.openLdapUserName = "******" + userName + "," + rootDomain;
this.passWord = passWord;
this.isLoggedIn = false;
this.type = LdapService.None;
}
public AccountController(
UserManager <AppUser> userManager,
SignInManager <AppUser> signInManager,
IIdentityServerInteractionService interactionService,
LdapService ldap)
{
this.userManager = userManager;
this.signInManager = signInManager;
this.interactionService = interactionService;
this.ldap = ldap;
}
public void getUsuariosResponsables()
{
try{
LdapService vLdap = new LdapService();
String vQuery = "[ACSP_ObtenerUsuarios] 8";
DataTable vDatosDB = vConexion.obtenerDataTable(vQuery);
DataTable vDatosFinal = new DataTable();
vDatosFinal.Columns.Add("usuario");
vDatosFinal.Columns.Add("nombre");
vDatosFinal.Columns.Add("apellido");
vDatosFinal.Columns.Add("correo");
vDatosFinal.Columns.Add("empresa");
vDatosFinal.Columns.Add("perfil");
for (int i = 0; i < vDatosDB.Rows.Count; i++)
{
DataTable vDatosAD = vLdap.GetDatosUsuario(ConfigurationManager.AppSettings["ADHOST"], vDatosDB.Rows[i]["idUsuario"].ToString());
if (vDatosAD.Rows.Count > 0)
{
vDatosFinal.Rows.Add(
vDatosDB.Rows[i]["idUsuario"].ToString(),
vDatosAD.Rows[0]["givenName"].ToString(),
vDatosAD.Rows[0]["sn"].ToString(),
vDatosAD.Rows[0]["mail"].ToString());
vDatosFinal.Rows[i]["empresa"] = vDatosDB.Rows[i]["empresa"].ToString();
vDatosFinal.Rows[i]["perfil"] = vDatosDB.Rows[i]["perfil"].ToString();
}
else
{
vDatosFinal.Rows.Add(
vDatosDB.Rows[i]["idUsuario"].ToString(),
"",
"",
vDatosDB.Rows[i]["correo"].ToString());
vDatosFinal.Rows[i]["empresa"] = vDatosDB.Rows[i]["empresa"].ToString();
vDatosFinal.Rows[i]["perfil"] = vDatosDB.Rows[i]["perfil"].ToString();
}
}
DDLUserResponsable.Items.Add(new ListItem {
Value = "0", Text = "Seleccione un usuario"
});
foreach (DataRow item in vDatosFinal.Rows)
{
DDLUserResponsable.Items.Add(new ListItem {
Value = item["usuario"].ToString(), Text = item["nombre"].ToString() + " " + item["apellido"].ToString() + " - " + item["empresa"].ToString() + " - " + item["perfil"].ToString()
});
}
DDLUserResponsable.DataBind();
}
catch (Exception Ex) { Mensaje(Ex.Message, WarningType.Danger); }
}
/// <summary>
/// Add the user in AD to group(s).
/// </summary>
/// <param name="ldapConnectionInfo"></param>
/// <param name="User"></param>
/// <param name="GroupsToAdd"></param>
/// <returns></returns>
public static Output AD_AddGroups([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] AD_AddGroupsUserProperties User, [PropertyTab] AD_AddGroupsProperties GroupsToAdd)
{
var ldapOperationResult = new Output {
operationSuccessful = false
};
using (var ldap = new LdapService(ldapConnectionInfo))
{
ldapOperationResult.operationSuccessful = ldap.AddAdUserToGroup(User.dn, GroupsToAdd.groups);
return(ldapOperationResult);
}
}
/// <summary>
/// Update a user in the AD.
/// </summary>
/// <param name="ldapConnectionInfo">The LDAP connection information</param>
/// <param name="adUser">The user record to be updated</param>
/// <returns>LdapResult class, which carries a copy of the updated user record.</returns>
public static OutputUser AD_UpdateUser([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] UpdateADuser adUser)
{
var ldapOperationResult = new OutputUser {
operationSuccessful = false, user = null
};
using (var ldap = new LdapService(ldapConnectionInfo))
{
ldapOperationResult.user = ldap.UpdateAdUser(adUser);
ldapOperationResult.operationSuccessful = true;
return(ldapOperationResult);
}
}
/// <summary>
/// Move a object to another OU (Organizational Unit). Returns class, which carries a copy of the updated object.
/// </summary>
/// <param name="ldapConnectionInfo"></param>
/// <param name="adObject"></param>
/// <returns>Object { DirectoryEntry ObjectEntryCopy }</returns>
public static MoveAdObjectResult AD_MoveObject([PropertyTab] LdapConnectionInfo ldapConnectionInfo, [PropertyTab] MoveObject adObject)
{
var result = new MoveAdObjectResult
{
OperationSuccessful = false
};
using (var ldap = new LdapService(ldapConnectionInfo))
{
result.ObjectEntryCopy = ldap.MoveAdObject(adObject);
result.OperationSuccessful = true;
}
return(result);
}
/// <summary>
/// Authenticate request at LDAP/Active Directory Domain with user-name and password
/// </summary>
private async Task <PacketCode> ProcessLdapAuthentication(PendingRequest request, ClientConfiguration clientConfig)
{
var userName = request.RequestPacket.UserName;
var password = request.RequestPacket.UserPassword;
if (string.IsNullOrEmpty(userName))
{
_logger.Warning("Can't find User-Name in message id={id} from {host:l}:{port}", request.RequestPacket.Identifier, request.RemoteEndpoint.Address, request.RemoteEndpoint.Port);
return(PacketCode.AccessReject);
}
if (string.IsNullOrEmpty(password))
{
_logger.Warning("Can't find User-Password in message id={id} from {host:l}:{port}", request.RequestPacket.Identifier, request.RemoteEndpoint.Address, request.RemoteEndpoint.Port);
return(PacketCode.AccessReject);
}
LdapService _service;
switch (clientConfig.FirstFactorAuthenticationSource)
{
case AuthenticationSource.ActiveDirectory:
_service = new ActiveDirectoryService(_serviceConfiguration, _logger);
break;
case AuthenticationSource.Ldap:
_service = new LdapService(_serviceConfiguration, _logger);
break;
default:
throw new NotImplementedException(clientConfig.FirstFactorAuthenticationSource.ToString());
}
//check all hosts
var ldapUriList = clientConfig.ActiveDirectoryDomain.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var ldapUri in ldapUriList)
{
var isValid = await _service.VerifyCredential(userName, password, ldapUri, request, clientConfig);
if (isValid)
{
return(PacketCode.AccessAccept);
}
}
return(PacketCode.AccessReject);
}
private async Task SyncAsync()
{
try
{
await LdapService.SyncUsersAsync(LdapSettings);
await LdapService.ChangePasswordWhenExpiredAsync(LdapSettings);
await ToastService.ShowToastAsync("Users synced.", ToastType.Success);
await ModalDialogClose();
}
catch (Exception ex)
{
Logger.LogError(ex.Message);
await ToastService.ShowToastAsync(ex.Message, ToastType.Error);
await ModalDialogCancel();
}
}
public string ConnectToOpenLDAP() {
List<string> props = new List<string>();
props.Add("cn");
AuthenticationType = AuthenticationTypes.None;
type = LdapService.OpenLDAP;
return Connect(openLdapUserName, "(objectClass=*)", props);
}
private string Connect(string username, string filter, List<string> propertiesToLoad) {
try {
connection = new DirectoryEntry(FullURL, username, passWord);
connection.AuthenticationType = AuthenticationType;
//Object obj = connection.NativeObject;
DirectorySearcher search = new DirectorySearcher(connection);
search.SearchScope = SearchScope.Subtree;
search.Filter = filter;
if (propertiesToLoad != null) {
foreach (string s in propertiesToLoad) search.PropertiesToLoad.Add(s);
}
SearchResult result = search.FindOne();
if(result == null) {
type = LdapService.None;
this.isLoggedIn = false;
return "Logon failure: Unrecognized username!";
}
this.isLoggedIn = true;
return "Authenticated as "+result.Path;
} catch (Exception e) {
type = LdapService.None;
this.isLoggedIn = false;
return e.Message;
}
}
