public AdministrationModule(ISContext serverContext) : base("/admin", serverContext)
{
this.assertClaims(TokenAuthService.CLAIM_ADMIN);
Before += ctx => {
userManager = new UserManagerService(serverContext);
return(null);
};
Get("/user/{id}", async args => {
var user = await userManager.findUserByIdentifierAsync((string)args.id);
return(Response.asJsonNet(user));
});
Put("/user/{id}", async args => {
var user = await userManager.findUserByIdentifierAsync((string)args.id);
var req = this.Bind <AdminUserModificationRequest>();
req.apply(user);
await userManager.updateUserInDatabaseAsync(user);
return(HttpStatusCode.NoContent);
});
Get("/metrics/{id}", async args => {
var user = await userManager.findUserByIdentifierAsync((string)args.id);
var metrics = new UserMetricsService(serverContext, user.identifier).get();
return(Response.asJsonNet(metrics));
});
}
public ManageController(
UserManagerService userManager,
SignInManagerService signInManager)
{
this.userManager = userManager;
this.signInManager = signInManager;
}
public async Task Should_Throw_NotFoundException_When_User_Not_Found()
{
//Arrange
var user = new ApplicationUser
{
Email = String.Empty,
UserName = String.Empty,
FirstName = "Test",
LastName = "Test",
Id = 1,
PasswordHash = String.Empty
};
var dbSetMock = new Mock <DbSet <ApplicationUser> >();
var dbContextMock = new Mock <ApplicationIdentityDbContext>();
dbContextMock.Setup(s => s.Set <ApplicationUser>()).Returns(dbSetMock.Object);
var userManagerMock = IdentityMockHelpers.MockUserManager <ApplicationUser>();
userManagerMock.Setup(u => u.FindByIdAsync(It.IsAny <String>()))
.Throws <NotFoundException>();
var roleManagerMock = IdentityMockHelpers.MockRoleManager <ApplicationRole>().Object;
UserManagerService sut = new UserManagerService(userManagerMock.Object, roleManagerMock);
//Act/Assert
await Assert.ThrowsAsync <NotFoundException>(async() =>
{
await sut.GetUserById(user.Id);
});
}
//[EnableCors(origins: "*", headers: "*", methods: "*")]
public HttpResponseMessage UpdateCookie()
{
SSOReturnResult ret = new SSOReturnResult();
SSOUserStatus us = new SSOUserStatus();
string req = SSOHTTPRequestService.getDataInRequest(Request);
SSOCookieInfor ci = SSOHTTPRequestService.getDataFromString <SSOCookieInfor>(req);
SSOUserLoginInfors oldValue = null;
if (ci != null && ci.Token != null && UserManagerService.CheckRequestAuthentication(ci.Token, out oldValue))
{
oldValue.UserCookie.Expires = ci.Expires;
UserManagerService.UsersLoggedIn.AddOrUpdate(ci.Token, oldValue,
(key, existingVal) =>
{
existingVal.UserCookie.Expires = oldValue.UserCookie.Expires;
return(existingVal);
});
ret.ReturnCode = HttpStatusCode.OK;
ret.Message = "Cập nhật thành công";
}
else
{
ret.ReturnCode = HttpStatusCode.BadRequest;
ret.Message = "Dữ liệu cập nhật không hợp lệ";
}
return(SSOHTTPRequestService.CreateResponseMessage(ret, HttpStatusCode.OK));
}
public async Task Should_GetUser_With_Valid_Id()
{
//Arrange
var user = new ApplicationUser
{
Email = String.Empty,
UserName = String.Empty,
FirstName = "Test",
LastName = "Test",
Id = 1,
PasswordHash = String.Empty
};
var dbSetMock = new Mock <DbSet <ApplicationUser> >();
var dbContextMock = new Mock <ApplicationIdentityDbContext>();
dbContextMock.Setup(s => s.Set <ApplicationUser>()).Returns(dbSetMock.Object);
var userManagerMock = IdentityMockHelpers.MockUserManager <ApplicationUser>();
userManagerMock.Setup(u => u.FindByIdAsync(It.IsAny <String>()))
.Returns(Task.FromResult(user));
var roleManagerMock = IdentityMockHelpers.MockRoleManager <ApplicationRole>().Object;
UserManagerService sut = new UserManagerService(userManagerMock.Object, roleManagerMock);
//Act
var returnUser = await sut.GetUserById(user.Id);
//Assert
returnUser.ShouldNotBeNull();
returnUser.ShouldBeOfType <ApplicationUser>();
returnUser.Id.ShouldBe(user.Id);
returnUser.FirstName.ShouldBe(user.FirstName);
returnUser.LastName.ShouldBe(user.LastName);
}
public UserModule(ISContext serverContext) : base("/user", serverContext)
{
this.assertClaims(TokenAuthService.CLAIM_USERNAME);
Before += ctx => {
userManager = new UserManagerService(serverContext);
// update metrics
new UserMetricsService(serverContext,
ctx.CurrentUser.getClaim(TokenAuthService.CLAIM_IDENTIFIER))
.logEvent(MetricsEventType.UserApi);
user = userManager
.findUserByIdentifierAsync(ctx.CurrentUser.getClaim(TokenAuthService.CLAIM_IDENTIFIER))
.Result;
return(null);
};
Get("/", async _ => {
return(Response.asJsonNet(user));
});
Put("/", async _ => {
var req = this.Bind <UserModificationRequest>();
req.apply(user);
await userManager.updateUserInDatabaseAsync(user);
return(HttpStatusCode.NoContent);
});
}
public async Task AddToTeamAsync_UserFound_ReturnsSuccessResult()
{
var sut = new UserManagerService(TestUserManager.GetSuccessfulManager());
var result = await sut.AddToTeamAsync(string.Empty, int.MaxValue);
result.Succeeded.Should().BeTrue();
}
public TestBase()
{
services.AddDbContext <ADreamDbContext>();
AddTransient();
serviceProvider = services.BuildServiceProvider();
aDreamDbContext = serviceProvider.GetService <ADreamDbContext>();
userManagerService = serviceProvider.GetService <UserManagerService>();
}
public RegisterPanel()
{
InitializeComponent();
userManager = new UserManagerService();
pictureManager = new PictureManagerServices();
pictureBox1.ImageLocation = "https://encrypted-tbn0.gstatic.com/images?q=tbn%3AANd9GcT9Tk6QGooYTtRLZe5081Ajm72fRk0ny7fYp4Moxu0qQkGxaWNM";
pictureBox1.SizeMode = PictureBoxSizeMode.StretchImage;
}
public async Task AddToTeamAsync_UserNotFound_ReturnsFailedResult()
{
var sut = new UserManagerService(TestUserManager.GetFailedManager());
var result = await sut.AddToTeamAsync(string.Empty, int.MaxValue);
result.Succeeded.Should().BeFalse();
result.Errors[0].Should().BeEquivalentTo("User not found.");
}
public async Task CreateUserAsync_Failed_ReturnsFailedResult()
{
var sut = new UserManagerService(TestUserManager.GetFailedManager());
var(result, _) = await sut.CreateAsync(string.Empty, string.Empty, int.MaxValue);
result.Succeeded.Should().BeFalse();
}
public SContext(IServiceCollection services, SConfig config) : base(services)
{
this.config = config;
log.verbosity = config.logging.Verbosity;
userManager = new UserManagerService(this);
tokenResolver = new TokenAuthenticationService(this);
authenticator = new BearerAuthenticator(this);
}
public async Task CreateUserAsync_Successful_ReturnsSuccessResult()
{
var sut = new UserManagerService(TestUserManager.GetSuccessfulManager());
var(result, _) = await sut.CreateAsync(string.Empty, string.Empty, int.MaxValue);
result.Succeeded.Should().BeTrue();
}
public async Task <IHttpActionResult> RegisterUser(UserRegisterModel registerModel)
{
if (registerModel == null)
{
return(BadRequest("This request is invalid"));
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser
{
UserName = registerModel.UserName,
Email = registerModel.Email,
PhoneNumber = registerModel.PhoneNumber
};
try
{
var registrationToken = await UserManagerService.RegisterUser(user, registerModel.Password);
var userProfile = new UserProfileModel
{
UserId = user.Id,
FirstName = registerModel.FirstName,
LastName = registerModel.LastName,
Email = registerModel.Email,
PhoneNumber = registerModel.PhoneNumber,
Address = new AddressModel
{
CountryId = registerModel.CountryId,
StateId = registerModel.StateId
}
};
await _userProfileBL.CreateUserProfile(userProfile);
var workspace = new WorkspaceModel
{
Name = string.Join("_", registerModel.FirstName, registerModel.LastName),
WorkspaceUsers = new List <WorkspaceUserModel>
{
new WorkspaceUserModel
{
UserId = user.Id
}
}
};
await _workspaceBL.CreateNewWorkspace(workspace);
return(registrationToken != null?Ok() : GetErrorResult(new IdentityResult("The email address " + registerModel.Email + " is already taken. Please sign in.")));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public RevalidatingIdentityAuthenticationStateProvider(ILoggerFactory loggerFactory,
UserManagerService <IAppUser> userManagerService,
IServiceScopeFactory scopeFactory,
IOptions <IdentityOptions> optionsAccessor)
: base(loggerFactory)
{
_userManager = userManagerService;
_scopeFactory = scopeFactory;
_options = optionsAccessor.Value;
}
public void SetUp()
{
_roles = new List <string>();
_userDTO = new UserDTO();
_mockMapper = new Mock <IMapper>();
var store = new Mock <IUserStore <User> >();
_mockUserManager = new Mock <UserManager <User> >(store.Object, null, null, null, null, null, null, null, null);
_userManagerService = new UserManagerService(_mockUserManager.Object, _mockMapper.Object);
}
/// <summary>
/// Initializes a new instance of the <see cref="T:Microsoft.AspNetCore.Identity.UserClaimsPrincipalFactory`1" /> class.
/// </summary>
/// <param name="userManager">The <see cref="T:Microsoft.AspNetCore.Identity.UserManager`1" /> to retrieve user information from.</param>
/// <param name="optionsAccessor">The configured <see cref="T:Microsoft.AspNetCore.Identity.IdentityOptions" />.</param>
public ADreamClaimsPrincipalFactory(UserManagerService userManager, IOptions <ADreamOptions> optionsAccessor)
{
userManager.CheakArgument();
optionsAccessor.CheakArgument();
if (optionsAccessor.Value != null)
{
UserManager = userManager;
Options = optionsAccessor.Value;
}
}
protected override void Dispose(bool disposing)
{
if (disposing && _userManager != null)
{
_userManager.Dispose();
_userManager = null;
}
base.Dispose(disposing);
}
public static UserManagerService GetUserManagerService(Mock <IIdentityProviderService> mockIdentityProviderService = null)
{
if (mockIdentityProviderService == null)
{
mockIdentityProviderService = new Mock <IIdentityProviderService>();
}
var service = new UserManagerService(mockIdentityProviderService.Object);
return(service);
}
public PackageController(UserManagerService userService, ApplicationUserManager userManager, ApplicationRoleManager roleManager, StudentInfoService studentProfile, PackageService packageService, TeacherProfileService teacherService, ImageService imageService)
{
_userService = userService;
UserManager = userManager;
_teacherService = teacherService;
//_classlevelService = classLevelService;
RoleManager = roleManager;
_packageService = packageService;
_imageService = imageService;
}
public async Task <IHttpActionResult> ToggleSystemEditor(Guid userId)
{
var state = await UserManagerService.ToggleSystemEditor(userId);
if (state)
{
return(Ok(state));
}
return(Content(HttpStatusCode.MethodNotAllowed, "Unauthorized User"));
}
public UserManagersController(UserManagerService userService, ApplicationUserManager userManager, ApplicationRoleManager roleManager, EnrollmentService enrollmentService, ImageService imageService, StudentInfoService studentProfile, TeacherProfileService teacherService)
{
_userService = userService;
UserManager = userManager;
//_classlevelService = classLevelService;
RoleManager = roleManager;
_imageService = imageService;
_studentService = studentProfile;
_enrollmentService = enrollmentService;
_teacherService = teacherService;
}
//[EnableCors(origins: "*", headers: "*", methods: "*")]
public HttpResponseMessage getUserStatus()
{
SSOUserStatus us = new SSOUserStatus();
SSOUserLoginInfors Us = null;
string req = SSOHTTPRequestService.getDataInRequest(Request);
string dt = SSOHTTPRequestService.getDataFromString <string>(req);
us.UserLoggedIn = UserManagerService.CheckRequestAuthentication(dt, out Us);
return(SSOHTTPRequestService.CreateResponseMessage(us, HttpStatusCode.OK));
}
private async Task Client_Ready()
{
AddonLoader.Load(Client);
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
List <Type> commandClasses = new List <Type>();
foreach (Assembly assembly in assemblies)
{
commandClasses.AddRange(assembly.GetTypes().Where(t => t.IsSubclassOf(typeof(ModuleBase)) && !t.IsAbstract).ToList());
}
checkNewUserEntries();
StatusNotifierService.InitializeService(Me);
MusicCommands.Initialize(Client);
RoleManagerService.InitializeHandler(Client, BotConfiguration);
ApiRequestService.Initialize(BotConfiguration);
UserManagerService.InitializeHandler(Client);
await CommandHandlerService.InitializeHandler(Client, BotConfiguration, commandClasses, prefixDictionary, !CredentialManager.OptionalSettings.Contains("CleverApi"));
CacheService.InitializeHandler();
VoiceRewardService.InitializeHandler(Client, BotConfiguration, !CredentialManager.OptionalSettings.Contains("CleverApi"));
switch (startValue)
{
case 0:
//shutdown
break;
case 1:
//restarting
await Me.SendMessageAsync("I have restored and restarted successfully.");
break;
case 2:
//updating
//check if an update is nessasarry
await Me.SendMessageAsync("I at all the new features and restarted successfully.");
break;
default:
break;
}
if (!CredentialManager.OptionalSettings.Contains("WeatherApiKey"))
{
if (!CredentialManager.OptionalSettings.Contains("WeatherPlace"))
{
MoodDictionary.InitializeMoodDictionary(Client, BotConfiguration);
await MoodHandlerService.InitializeHandler(Client, BotConfiguration);
}
WeatherSubscriptionService.InitializeWeatherSub(Client, BotConfiguration);
}
}
public HUAuthenticationModule(IHUServerContext serverContext) : base("/a")
{
ServerContext = serverContext;
Post("/register", async args =>
{
try
{
var registration = this.Bind <RegistrationRequest>();
// Validate registration
if (registration.FullName == null)
{
return(new TextResponse("Invalid name")
.WithStatusCode(HttpStatusCode.BadRequest));
}
if (registration.GHAuthToken == null)
{
return(new TextResponse("Invalid auth token")
.WithStatusCode(HttpStatusCode.BadRequest));
}
// email:
if (!Regex.IsMatch(registration.HangoutsEmail, @"\A(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)\Z", RegexOptions.IgnoreCase))
{
return(new TextResponse("Invalid email")
.WithStatusCode(HttpStatusCode.BadRequest));
}
// test the auth token to make sure it works
try
{
var ghClient = new GitHubClient(new ProductHeaderValue(nameof(HUAuthenticationModule)));
ghClient.Credentials = new Credentials(registration.GHAuthToken);
var ghUser = await ghClient.User.Current();
var um = new UserManagerService(ServerContext);
var registeredUser = await um.RegisterUserAsync(registration, ghUser.Login);
if (registeredUser != null)
{
return(Response.AsJsonNet(registeredUser));
}
}
catch
{
return(HttpStatusCode.BadRequest);
}
return(HttpStatusCode.Unauthorized);
}
catch
{
return(HttpStatusCode.BadRequest);
}
});
}
public async Task <ActionResult <LoginResponse> > PostLogin([Required] LoginRequest login)
{
var usm = new UserManagerService();
if (!usm.AuthenticateUser(login.Username, login.Password))
{
return(Unauthorized(new LoginResponse()));
}
else
{
var user = usm.GetUserByUsername(login.Username);
return(Ok(new LoginResponse(user.Username, user.Company, user.SectorCompany, user.Id)));
}
}
public UserAvatarController(IFileService fileService, UserManagerService userManager,
IUserAvatarManagerService avatarManager,
IValidator <UploadFileDTO> fileUploadValidator)
{
_defaultAvatar = "avatarimage.jpg";
_userManager = userManager;
_fileService = fileService;
_avatarManager = avatarManager;
_fileUploadValidator = fileUploadValidator;
_savePath = Path.Combine(
Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location),
"avatars");
_defaultAvatar = "avatarimage.jpg";
}
public UserAuthenticationService(
IdentityDbService context,
IdentityService identityService,
CurrentUserService currentUserService,
//#??must confugured for dep inj
UserManagerService <IAppUser> userManager,
SignInManagerService <IAppUser> signInManager)
{
_context = context;
_identityService = identityService;
_userManager = userManager;
_signInManager = signInManager;
_currentUserService = currentUserService;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (_userManager != null)
{
_userManager.Dispose();
_userManager = null;
}
if (_signInManager != null)
{
_signInManager.Dispose();
_signInManager = null;
}
}
base.Dispose(disposing);
}
//[EnableCors(origins: "*", headers: "*", methods: "*")]
public HttpResponseMessage LogoutUser(string Token)
{
SSOUserLoginInfors Us = null;
if (UserManagerService.CheckRequestAuthentication(Token, out Us))
{
var context = new HttpContextWrapper(HttpContext.Current);
HttpRequestBase request = context.Request;
SSOHttpRequestParams par = SSOHTTPRequestService.GetRequestParams(request);
//var app = HttpContext.Current.ApplicationInstance as HttpApplication;
UserManagerService.LogoutUser(par, SSOConstants.Cookie.AUTH_COOKIE, null);
}
SSOReturnResult ret = new SSOReturnResult();
ret.ReturnCode = HttpStatusCode.OK;
ret.Message = "Logout thành công";
return(SSOHTTPRequestService.CreateResponseMessage(ret, HttpStatusCode.OK));
}
