public async Task <User> SignUp(RegisterAuth register)
{
if (await _context.Users.Where(x => x.Email == register.Email).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exists" });
}
if (await _context.Users.Where(x => x.UserName == register.Username).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Username = "******" });
}
var user = new ApplicationUser
{
DisplayName = register.DisplayName,
Email = register.Email,
UserName = register.Username
};
var result = await _userManager.CreateAsync(user, register.Password);
if (result.Succeeded)
{
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
Username = user.UserName,
});
}
throw new Exception("Problem creating user");
}
public async void CreateUserAsync_InvalidProviderAndEmail_Fail()
{
using (var transactionScope = new TransactionScope())
{
var model = new RegisterAuth {
};
var result = await _usersControllers.CreateUserAsync(model.ToJToken());
Assert.NotNull(result);
Assert.IsType(typeof(BadRequestErrorMessageResult), result);
}
}
private UserProfileDevice GetNewUserProfileDevice(RegisterAuth model, string userId)
{
return(new UserProfileDevice
{
UserId = userId,
DeviceUniqueId = model.DeviceId,
Model = !string.IsNullOrEmpty(model.Model) ? $"{model.Model} ({model.Idiom})" : "",
Platform = model.Platform,
Version = model.Version,
IPLocation = model.ClientIP,
CreatedAt = _dateTimeManagerService.GetUniversalDateTime()
});
}
public ActionResult Register(RegisterAuth formdata)
{
if (!ModelState.IsValid)
{
return(Redirect(Url.Content("~/Admin/Register")));
}
var user = new Yazarlar()
{
isim = formdata.isim,
email = formdata.email,
sifre = formdata.sifre
};
Database.Session.SaveOrUpdate(user);
return(View(formdata));
}
internal async Task <RegistrationResult> CreateUser(String username, String password, String email)
{
try
{
var userClient = new WebClient();
RegisterAuth auth = new RegisterAuth();
auth.Email = email;
auth.Username = username;
auth.Password = AppUser.ShaPassword(password);
String jsonString = await userClient.UploadStringTaskAsync(new Uri("https://api.trakt.tv/account/create/9294cac7c27a4b97d3819690800aa2fedf0959fa"), AppUser.createJsonStringForAuthentication(typeof(RegisterAuth), auth));
if (jsonString.Contains(" is already a registered e-mail"))
{
return(RegistrationResult.EMAILINUSE);
}
if (jsonString.Contains("is already a registered username"))
{
return(RegistrationResult.USERNAMEINUSE);
}
if (jsonString.Contains("created account for"))
{
return(RegistrationResult.OK);
}
return(RegistrationResult.OK);
}
catch (WebException)
{ Debug.WriteLine("WebException in CreateUser()."); }
catch (TargetInvocationException)
{ Debug.WriteLine("TargetInvocationException in CreateUser()."); }
return(RegistrationResult.FAILED);
}
public void ShouldRegisterAuth()
{
var user = new User(0, "alexandre", "felix", true, UserType.User);
var registration = new UserRegistrationInput()
{
Email = "*****@*****.**", Password = "******", User = user
};
var mockLoginRepo = new Mock <ILoginRepository>();
mockLoginRepo.Setup(mock => mock.Create(It.IsAny <Login>())).Returns(0);
var mockUserRepo = new Mock <IUserRepository>();
mockUserRepo.Setup(mock => mock.Create(It.IsAny <User>())).Returns(0);
mockUserRepo.Setup(mock => mock.DeleteById(0)).Returns(true);
var res = new RegisterAuth(mockLoginRepo.Object, mockUserRepo.Object, registration).Execute();
Assert.AreEqual("alexandre", res.User.FirstName);
Assert.AreEqual("felix", res.User.LastName);
Assert.AreEqual(true, res.User.IsAStudent);
Assert.AreEqual(UserType.User, res.User.Type);
}
public async Task <AuthResult> RegisterAuthAsync(IDomainManager <User> domainManager, RegisterAuth model)
{
if (string.IsNullOrEmpty(model.ProviderUserId) && string.IsNullOrEmpty(model.Email))
{
return(new AuthResult
{
Succeeded = false,
ResultCode = AuthResultCode.Error,
Errors = new[] { "'ProviderUserId' and 'Email' cannot be empty or is invalid." }
});
}
AuthResult authResult = null;
return(await Task.Run(async() =>
{
var deviceRegistrationnAlreadyExist = _dataContext.UserProfileDevices.SingleOrDefault(p => p.DeviceUniqueId.Equals(model.DeviceId));
if (deviceRegistrationnAlreadyExist != null)
{
return new AuthResult
{
Succeeded = true,
ResultCode = AuthResultCode.Exist,
UserId = deviceRegistrationnAlreadyExist.UserId
};
}
var providerAuthRegistrationAlreadyExist = _dataContext.UserProfileAuthorizations.SingleOrDefault(p => p.Provider.Equals(model.Provider) && p.ProviderUserId.Equals(model.ProviderUserId));
if (providerAuthRegistrationAlreadyExist != null)
{
authResult = new AuthResult
{
Succeeded = true,
ResultCode = AuthResultCode.Exist,
UserId = providerAuthRegistrationAlreadyExist.UserId
};
UserProfileDevice userDevice = GetNewUserProfileDevice(model, providerAuthRegistrationAlreadyExist.UserId);
_dataContext.UserProfileDevices.Add(userDevice);
await _dataContext.SecureSaveChangesAsync();
}
// if null, the params didnt match anything
if (authResult == null)
{
var user = new User
{
Email = model.Email,
UserName = model.Email,
Password = string.Empty,
RegisterDate = _dateTimeManagerService.GetUniversalDateTime()
};
user = await domainManager.InsertAsync(user);
if (!string.IsNullOrEmpty(model.ProviderUserId))
{
var userAuth = new UserProfileAuthorization
{
UserId = user.Id,
Provider = model.Provider,
ProviderUserId = model.ProviderUserId,
CreatedAt = _dateTimeManagerService.GetUniversalDateTime()
};
_dataContext.UserProfileAuthorizations.Add(userAuth);
}
var userDevice = GetNewUserProfileDevice(model, user.Id);
_dataContext.UserProfileDevices.Add(userDevice);
await _dataContext.SecureSaveChangesAsync();
authResult = new AuthResult {
Succeeded = true, ResultCode = AuthResultCode.Created, UserId = user.Id
};
}
return authResult;
}));
}
