public async Task <GenericResult <LockoutPolicy> > SetLockoutPolicy(LockoutPolicy policy)
{
var result = new GenericResult <LockoutPolicy>();
try
{
var validationResults = await _setLockoutPolicyEngine.ValidateLockoutPolicyForSave(policy);
if (validationResults.IsFailure)
{
result.IsFailure = true;
result.Message = validationResults.Message;
return(result);
}
result.Data = await _policyAccessor.SetLockoutPolicy(policy);
result.Message = "Success";
}
catch (Exception ex)
{
result.IsFailure = true;
result.Exception = ex;
result.Message = ex.Message;
}
return(result);
}
public LockoutPolicy GetLockoutPolicy()
{
LockoutPolicy result = null;
// Create Authorization Invocation Context
var authorizedInvocationContext =
CreateAuthorizedInvocationContext();
// Invoke SSO Admin GetLockoutPolicyAsync operation
var ssoAdminLockoutPolicy = authorizedInvocationContext.
InvokeOperation(() =>
_ssoAdminBindingClient.GetLockoutPolicyAsync(
new ManagedObjectReference {
type = "SsoAdminLockoutPolicyService",
Value = "lockoutPolicyService"
})).Result;
if (ssoAdminLockoutPolicy != null)
{
result = new LockoutPolicy(this)
{
Description = ssoAdminLockoutPolicy.description,
AutoUnlockIntervalSec = ssoAdminLockoutPolicy.autoUnlockIntervalSec,
FailedAttemptIntervalSec = ssoAdminLockoutPolicy.failedAttemptIntervalSec,
MaxFailedAttempts = ssoAdminLockoutPolicy.maxFailedAttempts
};
}
return(result);
}
public void Save(BinaryWriter writer)
{
// Get policy from main window
LockoutPolicy policy = LockoutPolicy.GetFromWindow(MainWindow);
// Write policy settings to stream
policy.Write(writer);
}
public void Load(BinaryReader reader)
{
// Get stored policy
LockoutPolicy policy = LockoutPolicy.Parse(reader);
// Write policy settings to window
policy.WriteToWindow(MainWindow);
}
public async Task <LockoutPolicy> SetLockoutPolicy(LockoutPolicy policy)
{
var data = await _policyAccessor.SetLockoutPolicy(policy);
SetLockoutSharedPolicy(data);
return(data);
}
private void SetLockoutSharedPolicy(LockoutPolicy policy, LockoutOptions shared = null)
{
if (shared == null)
{
shared = _sharedPolicyAccessor.GetPolicy().Lockout;
}
shared.AllowedForNewUsers = policy.AllowedForNewUsers;
shared.DefaultLockoutTimeSpan = policy.DefaultLockoutTimeSpan;
shared.MaxFailedAccessAttempts = policy.MaxFailedAccessAttempts;
_sharedPolicyAccessor.SetLockoutPolicy(shared);
}
public async Task <LockoutPolicy> SetLockoutPolicy(LockoutPolicy policy)
{
using (var ctx = new UserDbContext(_options))
{
var ent = await ctx.LockoutPolicies.AddAsync(policy.ToEntity());
var cnt = await ctx.SaveChangesAsync();
if (cnt < 1 || cnt > 2)
{
throw new Exception("There was an error updating the Lockout Policy record.");
}
return(ent.Entity.ToModel());
}
}
internal static LockoutPolicyEntity ToEntity(this LockoutPolicy model)
{
if (model == null)
{
return(null);
}
return(new LockoutPolicyEntity
{
Id = model.Id,
Created = model.Created,
CreatedById = model.CreatedById,
AllowedForNewUsers = model.AllowedForNewUsers,
MaxFailedAccessAttempts = model.MaxFailedAccessAttempts,
DefaultLockoutTimeSpanTicks = model.DefaultLockoutTimeSpan.Ticks
});
}
public async Task <GenericResult <IEnumerable <string> > > ValidateLockoutPolicyForSave(LockoutPolicy policy)
{
var isNull = policy == null;
return(await Task.FromResult(new GenericResult <IEnumerable <string> >
{
IsFailure = isNull,
Message = isNull
? "Lockout Policy cannot be null."
: string.Empty,
Data = isNull
? new [] { "Lockout Policy cannot be null." }
: new string[0]
}));
}
