public List <string> ExecuteSync(string username)
{
var adUser = AdAccount.For(username).Name;
var task = Task.Run(async() => {
return(await _rolesUsuarioReadOnlyRepository.Get(adUser));
});
return(task.Result);
}
public void ImplicitConversionToStringReturnsDomainAndName()
{
const string value = "am\\moh";
var account = new AdAccount(value);
string result = account;
Assert.Equal(value, result);
}
public void ImplicitConversionToStringResultsInCorrectString()
{
const string value = "SSW\\Jason";
var account = AdAccount.For(accountString: value);
string result = account;
Assert.Equal(expected: value, actual: result);
}
public void ImplicitConversionToStringReturnsDomainAndName()
{
const string value = "SSW\\Jason";
var account = AdAccount.For(value);
string result = account;
result.ShouldBe(value);
}
public void ToString_ShouldResultInCorrectString()
{
const string accountString = "SSW\\Jason";
var account = AdAccount.For(accountString);
var result = account.ToString();
result.ShouldBe(accountString);
}
public void ImplicitConversionToStringResultsInCorrectString()
{
const string value = "Showcase\\Hamza";
var account = AdAccount.For(value);
string result = account;
Assert.Equal(value, result);
}
public void ImplicitConversionToStringResultsInCorrectString()
{
const string accountString = "SSW\\Jason";
var account = AdAccount.For(accountString);
string result = account;
result.Should().Be(accountString);
}
public void ImplicitConversionToStringResultsInCorrectString()
{
const string accountString = "MyCompany\\Shulga";
var account = AdAccount.For(accountString);
string result = account;
result.Should().Be(accountString);
}
public void ToStringReturnsCorrectFormat()
{
const string accountString = "MyCompany\\Shulga";
var account = AdAccount.For(accountString);
string result = account.ToString();
result.Should().Be(accountString);
}
public void ToStringReturnsCorrectFormat()
{
const string accountString = "SSW\\Jason";
var account = AdAccount.For(accountString);
var result = account.ToString();
result.Should().Be(accountString);
}
public UserAccountRepositoryTests()
{
this.sut = this.ServiceProvider.GetService <IUserAccountRepository>();
var domains = new[] { "East", "West" };
this.entityFaker = new Faker <UserAccount>() //https://github.com/bchavez/Bogus
.RuleFor(u => u.Email, (f, u) => f.Internet.Email())
.RuleFor(u => u.LastVisitDate, (f, u) => new DateTimeEpoch())
.RuleFor(u => u.RegisterDate, (f, u) => new DateTimeEpoch())
.RuleFor(u => u.TenantId, (f, u) => this.tenantId)
.RuleFor(u => u.AdAccount, (f, u) => AdAccount.For(f.PickRandom(new[] { "East", "West" }) + $"\\{f.System.Random.AlphaNumeric(5)}"))
.RuleFor(u => u.VisitCount, (f, u) => 1);
}
public async Task Process(TRequest request, CancellationToken cancellationToken)
{
var requestName = typeof(TRequest).Name;
var userId = _currentUserService.UserId ?? string.Empty;
string userName = string.Empty;
if (!string.IsNullOrEmpty(userId))
{
userName = await _domainUserService.GetUserNameAsync(AdAccount.For(userId));
}
_logger.LogInformation("OfficeEntry Request: {Name} {@UserId} {@UserName} {@Request}",
requestName, userId, userName, request);
}
public async Task <IActionResult> Add([FromBody] UserDto userDto)
{
var user = new User
{
Firstname = userDto.Firstname,
Surname = userDto.Surname,
Account = AdAccount.For(userDto.Account)
};
_logger.LogInfo($"Add user with firstname {userDto.Firstname}");
await _repository.AddAsync(user);
return(Ok());
}
public async Task <string> GetUserNameAsync(AdAccount adAccount)
{
return(await Task.Run(() =>
{
using var AD = new PrincipalContext(ContextType.Domain, _domainName);
var userIdentity = UserPrincipal.FindByIdentity(AD, adAccount.Name);
if (userIdentity == null)
{
throw new AdAccountInvalidException(adAccount);
}
return userIdentity.DisplayName;
}));
}
public async Task <IActionResult> Update(int id, [FromBody] UserDto userDto)
{
var user = new User
{
Firstname = userDto.Firstname,
Surname = userDto.Surname,
Account = AdAccount.For(userDto.Account)
};
_logger.LogInfo($"Update user with id '{id}'");
await _repository.AddAsync(user);
return(Ok());
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid)
{
var a = model.UserName.Split('\\');
var domain = a.Length > 1 ? a[0] : "";
var userId = a.Length > 1 ? a[1] : model.UserName;
var isAdmin = IsAdmin(userId, model.Password);
var role = isAdmin ? "admin" : "user";
if (isAdmin || AdAccount.IsAuthenticated(domain, userId, model.Password))
{
FormsAuthenticationTicket ticket = new FormsAuthenticationTicket(
1,
model.UserName,
DateTime.Now,
DateTime.Now.Add(FormsAuthentication.Timeout),
true,
role
);
HttpCookie cookie = new HttpCookie(
FormsAuthentication.FormsCookieName,
FormsAuthentication.Encrypt(ticket));
Response.Cookies.Add(cookie);
if (!String.IsNullOrEmpty(returnUrl))
{
return(Redirect(returnUrl));
}
else
{
if (isAdmin)
{
return(RedirectToAction("Index", "Admin", new { Key = DateTime.Now }));
}
return(RedirectToAction("Index", "Document", new { Key = DateTime.Now }));
}
}
else
{
ModelState.AddModelError("", "用户名或密码不正确");
}
}
return(View());
}
public static AdAccount For(string accountString)
{
var account = new AdAccount();
try
{
var index = accountString.IndexOf("\\", StringComparison.Ordinal);
account.Domain = accountString.Substring(0, index);
account.Name = accountString.Substring(index + 1);
}
catch (Exception ex)
{
throw new AdAccountInvalidException(accountString, ex);
}
return(account);
}
public UserAccountRepositoryTests()
{
//this.sut = this.ServiceProvider.GetService<IUserAccountRepository>();
this.sut = this.ServiceProvider.GetRequiredService <IGenericRepository <UserAccount> >();
this.ServiceProvider.GetRequiredService <UserAccountsDbContext>().Database.Migrate();
var domains = new[] { "East", "West" };
this.entityFaker = new Faker <UserAccount>() //https://github.com/bchavez/Bogus
.RuleFor(u => u.Email, (f, u) => f.Internet.Email())
.RuleFor(u => u.LastVisitDate, (f, u) => DateTime.UtcNow.AddDays(-1))
.RuleFor(u => u.RegisterDate, (f, u) => DateTime.UtcNow.AddDays(-14))
.RuleFor(u => u.TenantId, (f, u) => this.tenantId)
.RuleFor(u => u.AdAccount, (f, u) => AdAccount.For(f.PickRandom(new[] { "East", "West" }) + $"\\{f.System.Random.AlphaNumeric(5)}"))
//.RuleFor(u => u.Status, (f, u) => f.PickRandom(new[] { UserAccountStatus.Active, UserAccountStatus.Inactive }))
.RuleFor(u => u.Status, (f, u) => f.PickRandom(new[] { UserAccountStatus.For("Active"), UserAccountStatus.For("Inactive") }))
.RuleFor(u => u.VisitCount, (f, u) => 1);
}
public async Task <Unit> Handle(CreateUserCommand request, CancellationToken cancellationToken)
{
var entity = new User
{
CreatedBy = AdAccount.For(request.UserName).UserName,
DepartmentName = request.DepartmentName,
Division = request.Division,
LastModifiedBy = AdAccount.For(request.UserName).UserName,
Name = new Name(request.FirstMidName, request.LastName),
AdAccount = AdAccount.For(request.UserName),
};
_context.Set <User>().Add(entity);
await _context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public UserProfileOutput Execute(string adAccount)
{
var adUser = AdAccount.For(adAccount);
var roles = Task.Run(async() =>
{
return(await _rolesUsuarioReadOnlyRepository.Get(adUser.Name));
});
var funcionario = Task.Run(async() =>
{
return(await _funcionarioUsuarioReadOnlyRepository.Get(adUser.Name));
});
if (funcionario.Result == null)
{
return(null);
}
return(UserProfileOutput.LoadRoles(adUser.Name, funcionario.Result.FuncionarioID, funcionario.Result.NombreCompleto.ToString(),
funcionario.Result.EstadoID, funcionario.Result.Estado, funcionario.Result.Email, roles.Result));
}
public void ShouldHaveCorrectName()
{
var account = AdAccount.For("SSW\\Jason");
account.Name.ShouldBe("Jason");
}
public void ShouldHaveCorrectDomain()
{
var account = new AdAccount("SSW\\Jason");
Assert.Equal("SSW", account.Domain);
}
public void Should_Have_Domain()
{
var account = new AdAccount("aforbes\\motjopet");
Assert.AreEqual("aforbes", account.Domain);
}
public async Task <ActionResult <string> > Get()
{
return(await _domainUserService.GetUserNameAsync(AdAccount.For(User.Identity.Name)));
}
public static ModuleOptions AddUserAccountsModule(
this ModuleOptions options,
string connectionString = null,
string section = "naos:sample:userAccounts:entityFramework",
UserAccountsDbContext dbContext = null)
{
EnsureArg.IsNotNull(options, nameof(options));
EnsureArg.IsNotNull(options.Context, nameof(options.Context));
options.Context.AddTag("useraccounts");
if (dbContext != null)
{
options.Context.Services.AddSingleton(dbContext); // cross wiring, warning this will be a singleton (not scoped)
}
var configuration = options.Context.Configuration?.GetSection(section).Get <EntityFrameworkConfiguration>();
options.Context.Services.AddScoped <IGenericRepository <UserAccount> >(sp =>
{
return(new UserAccountRepository(
new RepositoryTracingDecorator <UserAccount>(
sp.GetService <ILogger <UserAccountRepository> >(),
sp.GetService <ITracer>(),
new RepositoryLoggingDecorator <UserAccount>(
sp.GetRequiredService <ILogger <UserAccountRepository> >(),
//new RepositoryTenantDecorator<UserAccount>(
//"naos_sample_test", // TODO: resolve from runtime context
//new RepositorySoftDeleteDecorator<UserAccount>(
new EntityFrameworkRepository <UserAccount>(o => o
.LoggerFactory(sp.GetRequiredService <ILoggerFactory>())
.Mediator(sp.GetRequiredService <IMediator>())
.DbContext(sp.GetRequiredService <UserAccountsDbContext>()))))));
});
options.Context.Services.AddScoped <IGenericRepository <UserVisit> >(sp =>
{
return(new UserVisitRepository(
new RepositoryTracingDecorator <UserVisit>(
sp.GetService <ILogger <UserVisitRepository> >(),
sp.GetService <ITracer>(),
new RepositoryLoggingDecorator <UserVisit>(
sp.GetRequiredService <ILogger <UserVisitRepository> >(),
new RepositoryTenantDecorator <UserVisit>(
"naos_sample_test", // TODO: resolve from runtime context
new RepositoryStateSoftDeleteDecorator <UserVisit>(
new EntityFrameworkRepository <UserVisit>(o => o
.LoggerFactory(sp.GetRequiredService <ILoggerFactory>())
.Mediator(sp.GetRequiredService <IMediator>())
.DbContext(sp.GetRequiredService <UserAccountsDbContext>())
.Mapper(new AutoMapperEntityMapper(MapperFactory.Create())))))))));
});
options.Context.Services.AddDbContext <UserAccountsDbContext>(o => o
//.UseSqlServer("Server=127.0.0.1;Database=naos_sample;User=sa;Password=Abcd1234!;Trusted_Connection=False;MultipleActiveResultSets=True;", o => o // docker
//.UseSqlServer(configuration.ConnectionString.EmptyToNull() ?? $"Server=(localdb)\\mssqllocaldb;Database={nameof(UserAccountsDbContext)};Trusted_Connection=True;MultipleActiveResultSets=True;", o => o
.UseSqlServer(configuration.ConnectionString, o => o
.MigrationsHistoryTable("__MigrationsHistory", "useraccounts")
.EnableRetryOnFailure())
.UseLoggerFactory(options.Context.Services.BuildServiceProvider().GetRequiredService <ILoggerFactory>())
//.ConfigureWarnings(w => w.Throw(RelationalEventId.QueryClientEvaluationWarning))
.EnableSensitiveDataLogging()
.EnableDetailedErrors());
options.Context.Services.AddStartupTask <ApplyPendingMigrationsTask <UserAccountsDbContext> >();
options.Context.Services.AddStartupTask <EchoStartupTask>(new TimeSpan(0, 0, 3));
options.Context.Services.AddSeederStartupTask <UserAccountsDbContext, UserAccount>(new[]
{
new UserAccount()
{
Id = Guid.Parse("100fb10f-2ad4-4bd1-9b33-6410a5ce7b25"), Email = "*****@*****.**", TenantId = "naos_sample_test", AdAccount = AdAccount.For("East\\admin"), Status = UserAccountStatus.Active
},
new UserAccount()
{
Id = Guid.Parse("100fb10f-2ad4-4bd1-9b33-6410a5ce7b26"), Email = "*****@*****.**", TenantId = "naos_sample_test", AdAccount = AdAccount.For("East\\test26"), Status = UserAccountStatus.Active
},
new UserAccount()
{
Id = Guid.Parse("100fb10f-2ad4-4bd1-9b33-6410a5ce7b27"), Email = "*****@*****.**", TenantId = "naos_sample_test", AdAccount = AdAccount.For("East\\test27"), Status = UserAccountStatus.Active
},
}, delay: new TimeSpan(0, 0, 10));
//options.Context.Services.AddStartupTask(sp =>
// new SeederStartupTask(
// sp.GetRequiredService<ILoggerFactory>(),
// sp.CreateScope().ServiceProvider.GetService(typeof(IGenericRepository<UserAccount>)) as IGenericRepository<UserAccount>));
options.Context.Services.AddHealthChecks()
.AddSqlServer(configuration.ConnectionString, name: "UserAccounts-sqlserver");
options.Context.Services.AddHealthChecks() // https://docs.microsoft.com/en-us/aspnet/core/host-and-deploy/health-checks?view=aspnetcore-3.1#entity-framework-core-dbcontext-probe
.AddDbContextCheck <UserAccountsDbContext>(name: "UserAccounts-dbcontext");
options.Context.Messages.Add("naos services builder: useraccounts service added");
return(options);
}
public void ShouldHaveCorrectName()
{
var account = new AdAccount("SSW\\Jason");
Assert.Equal("Jason", account.Name);
}
public void ShouldHaveCorrectDomainAndName()
{
var account = AdAccount.For("SSW\\Jason");
account.Domain.ShouldBe("SSW");
}
public void ShouldHaveCorrectDomain()
{
var account = new AdAccount("am\\moh");
Assert.Equal("am", account.Domain);
}
public void Should_Have_Name()
{
var account = new AdAccount("aforbes\\motjopet");
Assert.AreEqual("motjopet", account.Name);
}
public void ShouldHaveCorrectName()
{
var account = new AdAccount("am\\moh");
Assert.Equal("moh", account.Name);
}
