public void CreateValidNotCallExternalAuthAssociateWithoutAuthResult()
{
var controller = GetController();
MockUpUrl(controller);
_userService.Setup(u => u.IsEmailInUse(It.IsAny <string>())).Returns(false);
_userService.Setup(u => u.IsNameInUse(It.IsAny <string>())).Returns(false);
var user = UserServiceTests.GetDummyUser("Diana", "*****@*****.**");
var signUp = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "passwerd", TimeZone = -5
};
_userService.Setup(u => u.CreateUser(signUp, It.IsAny <string>())).Returns(user);
_newAccountMailer.Setup(n => n.Send(It.IsAny <User>(), It.IsAny <string>())).Returns(System.Net.Mail.SmtpStatusCode.CommandNotImplemented);
var settings = new Settings {
IsNewUserApproved = true
};
_settingsManager.Setup(s => s.Current).Returns(settings);
var authManager = new Mock <IAuthenticationManager>();
_owinContext.Setup(x => x.Authentication).Returns(authManager.Object);
var authResult = Task.FromResult <ExternalAuthenticationResult>(null);
_externalAuth.Setup(x => x.GetAuthenticationResult(authManager.Object)).Returns(authResult);
var result = controller.Create(signUp).Result;
_userAssociationManager.Verify(x => x.Associate(user, It.IsAny <ExternalAuthenticationResult>(), It.IsAny <string>()), Times.Never);
}
public async Task <ActionResult> Signup(SignupData signupData)
{
if (ModelState.IsValid)
{
var user = new ApplicationUser {
UserName = signupData.Username, Email = signupData.Email
};
var result = await _userManager.CreateAsync(user, signupData.Password);
if (result.Succeeded)
{
// If isPersistent is set to false, the browser will acquire session cookie which gets cleared when the browser is closed.
// rememberBrowser is relevant only in Two-factor authentication
await _signInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
((ApplicationUserStore)_applicationUserStore).Context.Set <Parent>().Add(new Parent()
{
UserProfile = user
});
((ApplicationUserStore)_applicationUserStore).SaveOrUpdate();
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
return(View(signupData));
}
public void Signup()
{
var data = new SignupData()
{
username = Username.text,
name = Fullname.text,
email = Email.text,
password = Password.text,
telephone = Telephone.text
};
if (Password.text == RePassword.text)
{
StartCoroutine(SignupAPI(data, res => {
if (res.responseCode == 200)
{
AndroidNativeFunctions.ShowAlert("We will send email to you, please confirm",
"Please follow instructer to reset your password",
"Ok", "", "",
(action) => { });
GameObject.Find("UIManager").GetComponent <LoginUIManager>().AnimateSigninGroup();
}
else if (res.responseCode == 400)
{
AndroidNativeFunctions.ShowAlert("We will send email to you, please confirm",
"Please follow instructer to reset your password",
"Ok", "", "",
(action) => { });
}
}));
}
}
public void CreateNotValid()
{
var controller = GetController();
var context = new HttpContextHelper();
controller.ControllerContext = new ControllerContext(context.MockContext.Object, new RouteData(), controller);
const string tos = "blah blah blah";
var settings = new Settings {
TermsOfService = tos
};
_settingsManager.Setup(s => s.Current).Returns(settings);
_userService.Setup(u => u.IsEmailInUse(It.IsAny <string>())).Returns(true);
_userService.Setup(u => u.IsNameInUse(It.IsAny <string>())).Returns(true);
var signUp = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "pwd", TimeZone = -5
};
var result = controller.Create(signUp).Result;
Assert.IsFalse(controller.ModelState.IsValid);
Assert.IsInstanceOf <ViewResult>(result);
Assert.IsInstanceOf <String>(controller.ViewData[AccountController.CoppaDateKey]);
Assert.IsInstanceOf <String>(controller.ViewData[AccountController.TosKey]);
Assert.AreEqual(tos, controller.ViewData[AccountController.TosKey]);
_userService.Verify(u => u.CreateUser(It.IsAny <SignupData>(), It.IsAny <string>()), Times.Never());
_profileService.Verify(p => p.Create(It.IsAny <User>(), It.IsAny <SignupData>()), Times.Never());
_newAccountMailer.Verify(n => n.Send(It.IsAny <User>(), It.IsAny <string>()), Times.Never());
}
public void CreateValid()
{
var controller = GetController();
MockUpUrl(controller);
_userService.Setup(u => u.IsEmailInUse(It.IsAny <string>())).Returns(false);
_userService.Setup(u => u.IsNameInUse(It.IsAny <string>())).Returns(false);
var user = UserServiceTests.GetDummyUser("Diana", "*****@*****.**");
var signUp = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "passwerd", TimeZone = -5
};
_userService.Setup(u => u.CreateUser(signUp, It.IsAny <string>())).Returns(user);
_newAccountMailer.Setup(n => n.Send(It.IsAny <User>(), It.IsAny <string>())).Returns(System.Net.Mail.SmtpStatusCode.CommandNotImplemented);
var settings = new Settings {
IsNewUserApproved = true
};
_settingsManager.Setup(s => s.Current).Returns(settings);
var authManager = new Mock <IAuthenticationManager>();
_owinContext.Setup(x => x.Authentication).Returns(authManager.Object);
var authResult = Task.FromResult <ExternalAuthenticationResult>(null);
_externalAuth.Setup(x => x.GetAuthenticationResult(It.IsAny <IAuthenticationManager>())).Returns(authResult);
var result = controller.Create(signUp).Result;
Assert.IsTrue(controller.ModelState.IsValid);
Assert.AreEqual("AccountCreated", result.ViewName);
Assert.IsTrue(result.ViewData["EmailProblem"].ToString().Contains(System.Net.Mail.SmtpStatusCode.CommandNotImplemented.ToString()));
_userService.Verify(u => u.CreateUser(signUp, It.IsAny <string>()), Times.Once());
_profileService.Verify(p => p.Create(user, signUp), Times.Once());
_newAccountMailer.Verify(n => n.Send(user, It.IsAny <string>()), Times.Once());
}
public async Task <ViewResult> Create(SignupData signupData)
{
var ip = HttpContext.Connection.RemoteIpAddress.ToString();
if (_config.UseReCaptcha)
{
var reCaptchaResponse = await _reCaptchaService.VerifyToken(signupData.Token, ip);
if (!reCaptchaResponse.IsSuccess)
{
ModelState.AddModelError("Email", Resources.BotError);
}
}
await ValidateSignupData(signupData, ModelState, ip);
if (ModelState.IsValid)
{
var user = await _userService.CreateUser(signupData, ip);
await _profileService.Create(user, signupData);
// TODO: get rid of FullUrlHelper extension
var verifyUrl = this.FullUrlHelper("Verify", "Account");
var result = _newAccountMailer.Send(user, verifyUrl);
if (result != SmtpStatusCode.Ok)
{
ViewData["EmailProblem"] = Resources.EmailProblemAccount + (result?.ToString() ?? "App exception") + ".";
}
if (_settingsManager.Current.IsNewUserApproved)
{
ViewData["Result"] = Resources.AccountReady;
await _userService.Login(user, ip);
}
else
{
ViewData["Result"] = Resources.AccountReadyCheckEmail;
}
var loginState = _externalLoginTempService.Read();
if (loginState != null)
{
var externalLoginInfo = new ExternalLoginInfo(loginState.ProviderType.ToString(), loginState.ResultData.ID, loginState.ResultData.Name);
await _externalUserAssociationManager.Associate(user, externalLoginInfo, ip);
_externalLoginTempService.Remove();
}
await IdentityController.PerformSignInAsync(user, HttpContext);
return(View("AccountCreated"));
}
SetupCreateData();
return(View(signupData));
}
public void ValidateTrue()
{
var signup = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "password", TimeZone = -5
};
var controller = GetController();
_userManager.SetupAllProperties();
signup.Validate(controller.ModelState, _userManager.Object, String.Empty);
Assert.IsTrue(controller.ModelState.IsValid);
Assert.AreEqual(0, controller.ModelState.Keys.Count);
}
public ViewResult Create()
{
SetupCreateData();
var signupData = new SignupData
{
IsDaylightSaving = true,
IsSubscribed = true,
TimeZone = _settingsManager.Current.ServerTimeZone
};
return(View(signupData));
}
private static IEnumerator SignupAPI(SignupData data, Action <UnityWebRequest> callBack)
{
var request = new UnityWebRequest($"{Config.URL()}/users", "POST");
var bodyRaw = new UTF8Encoding().GetBytes(JsonUtility.ToJson(data));
request.uploadHandler = new UploadHandlerRaw(bodyRaw);
request.downloadHandler = new DownloadHandlerBuffer();
request.SetRequestHeader("Content-Type", "application/json");
yield return(request.SendWebRequest());
callBack(request);
}
public Profile Create(User user, SignupData signupData)
{
var profile = new Profile(user.UserID)
{
TimeZone = signupData.TimeZone,
IsDaylightSaving = signupData.IsDaylightSaving,
IsSubscribed = signupData.IsSubscribed,
IsTos = signupData.IsTos
};
_profileRepository.Create(profile);
return(profile);
}
private void ValidateSignupData(SignupData signupData, ModelStateDictionary modelState, string ip)
{
if (!signupData.IsCoppa)
{
modelState.AddModelError("IsCoppa", Resources.MustBe13);
}
if (!signupData.IsTos)
{
modelState.AddModelError("IsTos", Resources.MustAcceptTOS);
}
string passwordError;
var passwordValid = _userService.IsPasswordValid(signupData.Password, out passwordError);
if (!passwordValid)
{
modelState.AddModelError("Password", passwordError);
}
if (signupData.Password != signupData.PasswordRetype)
{
modelState.AddModelError("PasswordRetype", Resources.RetypeYourPassword);
}
if (String.IsNullOrWhiteSpace(signupData.Name))
{
modelState.AddModelError("Name", Resources.NameRequired);
}
else if (_userService.IsNameInUse(signupData.Name))
{
modelState.AddModelError("Name", Resources.NameInUse);
}
if (String.IsNullOrWhiteSpace(signupData.Email))
{
modelState.AddModelError("Email", Resources.EmailRequired);
}
else
if (!signupData.Email.IsEmailAddress())
{
modelState.AddModelError("Email", Resources.ValidEmailAddressRequired);
}
else if (signupData.Email != null && _userService.IsEmailInUse(signupData.Email))
{
modelState.AddModelError("Email", Resources.EmailInUse);
}
if (signupData.Email != null && _userService.IsEmailBanned(signupData.Email))
{
modelState.AddModelError("Email", Resources.EmailBanned);
}
if (_userService.IsIPBanned(ip))
{
modelState.AddModelError("Email", Resources.IPBanned);
}
}
public void ValidateFalsePasswordsTooShort()
{
var signup = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "pword", TimeZone = -5
};
var controller = GetController();
_userManager.SetupAllProperties();
_userManager.Setup(u => u.IsPasswordValid(signup.Password, controller.ModelState)).Returns(false).Callback(() => controller.ModelState.AddModelError("Password", "whatever"));
signup.Validate(controller.ModelState, _userManager.Object, String.Empty);
Assert.IsFalse(controller.ModelState.IsValid);
Assert.AreEqual(1, controller.ModelState.Keys.Count);
Assert.IsTrue(controller.ModelState.ContainsKey("Password"));
}
public async Task <Profile> Create(User user, SignupData signupData)
{
var profile = new Profile
{
UserID = user.UserID,
TimeZone = signupData.TimeZone,
IsDaylightSaving = signupData.IsDaylightSaving,
IsSubscribed = signupData.IsSubscribed,
IsTos = signupData.IsTos
};
await _profileRepository.Create(profile);
return(profile);
}
public void ValidateFalseBannedIP()
{
var signup = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = "Diana", Password = "******", PasswordRetype = "password", TimeZone = -5
};
var controller = GetController();
const string bannedIP = "127.0.0.1";
_userManager.SetupAllProperties();
_userManager.Setup(u => u.IsIPBanned(bannedIP)).Returns(true);
signup.Validate(controller.ModelState, _userManager.Object, bannedIP);
Assert.False(controller.ModelState.IsValid);
Assert.AreEqual(1, controller.ModelState.Keys.Count);
Assert.IsTrue(controller.ModelState.ContainsKey("Email"));
}
public void ValidateFalseNameInUse()
{
const string name = "Diana";
var signup = new SignupData {
Email = "*****@*****.**", IsCoppa = true, IsDaylightSaving = true, IsSubscribed = true, IsTos = true, Name = name, Password = "******", PasswordRetype = "password", TimeZone = -5
};
var controller = GetController();
_userManager.SetupAllProperties();
_userManager.Setup(u => u.IsNameInUse(name)).Returns(true);
signup.Validate(controller.ModelState, _userManager.Object, String.Empty);
Assert.IsFalse(controller.ModelState.IsValid);
Assert.AreEqual(1, controller.ModelState.Keys.Count);
Assert.IsTrue(controller.ModelState.ContainsKey("Name"));
_userManager.Verify(u => u.IsNameInUse(name), Times.Once());
}
public ViewResult Create()
{
SetupCreateData();
var signupData = new SignupData
{
IsDaylightSaving = true,
IsSubscribed = true,
TimeZone = _settingsManager.Current.ServerTimeZone
};
var loginState = _externalLoginTempService.Read();
if (loginState?.ResultData != null)
{
signupData.Email = loginState.ResultData.Email;
signupData.Name = loginState.ResultData.Name;
}
return(View(signupData));
}
public async Task <ViewResult> Create(SignupData signupData)
{
var ip = HttpContext.Connection.RemoteIpAddress.ToString();
if (_config.UseReCaptcha)
{
var reCaptchaResponse = await _reCaptchaService.VerifyToken(signupData.Token, ip);
if (!reCaptchaResponse.IsSuccess)
{
ModelState.AddModelError("Email", Resources.BotError);
}
}
await ValidateSignupData(signupData, ModelState, ip);
if (ModelState.IsValid)
{
var user = await _userService.CreateUser(signupData, ip);
await _profileService.Create(user, signupData);
// TODO: get rid of FullUrlHelper extension
var verifyUrl = this.FullUrlHelper("Verify", "Account");
if (_settingsManager.Current.IsNewUserApproved)
{
ViewData["Result"] = Resources.AccountReady;
await _userService.Login(user, ip);
}
await IdentityController.PerformSignInAsync(user, HttpContext);
_tibiaService.AddCharacter(new TibiaCharacter
{
Name = user.Name,
Level = 0,
UserID = user.UserID
});
return(View("AccountCreated", user));
}
SetupCreateData();
return(View(signupData));
}
public async Task SignupControllerPostTestExists()
{
var data = new SignupDataHandler();
var logic = new CoreApiLogicHandler();
var signup = SignupData.GetSignup();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(StandardUser);
var controller = new SignupController(data, Cloud, logic);
var result = await controller.Post(signup) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeFalse();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
public async Task <ViewResult> Create(SignupData signupData)
{
var ip = HttpContext.Connection.RemoteIpAddress.ToString();
ValidateSignupData(signupData, ModelState, ip);
if (ModelState.IsValid)
{
var user = _userService.CreateUser(signupData, ip);
_profileService.Create(user, signupData);
// TODO: get rid of FullUrlHelper extension
var verifyUrl = this.FullUrlHelper("Verify", "Account");
var result = _newAccountMailer.Send(user, verifyUrl);
if (result != SmtpStatusCode.Ok)
{
ViewData["EmailProblem"] = Resources.EmailProblemAccount + (result?.ToString() ?? "App exception") + ".";
}
if (_settingsManager.Current.IsNewUserApproved)
{
ViewData["Result"] = Resources.AccountReady;
_userService.Login(user, ip);
}
else
{
ViewData["Result"] = Resources.AccountReadyCheckEmail;
}
var authResult = await AuthorizationController.GetExternalLoginInfoAsync(HttpContext);
if (authResult != null)
{
_externalUserAssociationManager.Associate(user, authResult, ip);
}
await AuthorizationController.PerformSignInAsync(user, HttpContext);
return(View("AccountCreated"));
}
SetupCreateData();
return(View(signupData));
}
public async Task SignupControllerAuthTestFail()
{
var data = new SignupDataHandler();
var logic = new CoreApiLogicHandler();
var entry = SignupData.GetEntry();
data.Result.Setup(m => m.Execute(It.IsAny <TenantByEntryKey>())).Returns(null);
var controller = new SignupController(data, Cloud, logic);
var result = await controller.Entry(entry) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
result.Value.Should().BeOfType <FailViewModel>();
logic.HasExecuted.Should().BeFalse();
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <TenantByEntryKey>()), Times.Once);
}
public void CreateFromUserAndSignupData()
{
var service = GetService();
var user = UserServiceTests.GetDummyUser("Jeff", "*****@*****.**");
var signupData = new SignupData {
TimeZone = -5, IsSubscribed = true, IsTos = true, IsDaylightSaving = true
};
_profileRepo.Setup(r => r.Create(It.Is <Profile>(p =>
p.UserID == user.UserID &&
p.TimeZone == signupData.TimeZone &&
p.IsSubscribed == signupData.IsSubscribed &&
p.IsTos == signupData.IsTos &&
p.IsDaylightSaving == signupData.IsDaylightSaving))).Verifiable();
var result = service.Create(user, signupData);
Assert.Equal(user.UserID, result.UserID);
Assert.Equal(signupData.IsDaylightSaving, result.IsDaylightSaving);
Assert.Equal(signupData.IsSubscribed, result.IsSubscribed);
Assert.Equal(signupData.IsTos, result.IsTos);
Assert.Equal(signupData.TimeZone, result.TimeZone);
}
async Task <IActionResult> RegisterUser(SignupData data, string role, string idWorkshop = null)
{
var authData = await _repository.GetAuthDataByEmail(data.Email.ToLower());
if (authData != null)
{
_log.Error("User with the provided email already exists");
return(Conflict());
}
var userId = Guid.NewGuid().ToString();
var token = GenerateToken(data.Email.ToLower(), role, userId);
await _repository.NewAuthData(new AuthData
{
UserId = userId,
Email = data.Email.ToLower(),
Password = data.Password,
Token = token
});
// Notify the kafka message broker that a new user has been registered
var userRegisteredEvent = new UserRegisteredEvent {
User = new User
{
Id = userId,
Name = data.Name,
Surname = data.Surname,
Email = data.Email.ToLower(),
Phone = data.Phone,
IsWorker = role == UserRole.Worker,
IdWorkshop = idWorkshop
}
};
await _mbProducer.Send(userRegisteredEvent, "UserRegistration");
return(Ok());
}
public async Task <ViewResult> Create(SignupData signupData)
{
signupData.Validate(ModelState, _userService, HttpContext.Request.UserHostAddress);
if (ModelState.IsValid)
{
var user = _userService.CreateUser(signupData, HttpContext.Request.UserHostAddress);
_profileService.Create(user, signupData);
var verifyUrl = this.FullUrlHelper("Verify", "Account");
var result = _newAccountMailer.Send(user, verifyUrl);
if (result != System.Net.Mail.SmtpStatusCode.Ok)
{
ViewData["EmailProblem"] = Resources.EmailProblemAccount + result + ".";
}
if (_settingsManager.Current.IsNewUserApproved)
{
ViewData["Result"] = Resources.AccountReady;
_userService.Login(user.Email, signupData.Password, false, HttpContext);
}
else
{
ViewData["Result"] = Resources.AccountReadyCheckEmail;
}
var authentication = _owinContext.Authentication;
var authResult = await _externalAuthentication.GetAuthenticationResult(authentication);
if (authResult != null)
{
_userAssociationManager.Associate(user, authResult, HttpContext.Request.UserHostAddress);
}
return(View("AccountCreated"));
}
SetupCreateData();
return(View(signupData));
}
public async Task SignupControllerPostTest()
{
var data = new SignupDataHandler();
var logic = new CoreApiLogicHandler();
var signup = SignupData.GetSignup();
var auth = LoginData.GetAuth();
data.Result.Setup(m => m.Execute(It.IsAny <UserByEmail>())).Returns(null);
logic.Result.Setup(m => m.Execute(It.IsAny <SignupUser>())).Returns(ActionConfirm.CreateSuccess(auth));
var controller = new SignupController(data, Cloud, logic);
var result = await controller.Post(signup) as OkObjectResult;
result.Should().NotBeNull();
result.Should().BeOfType <OkObjectResult>();
logic.HasExecuted.Should().BeTrue();
logic.Result.Verify(s => s.Execute(It.IsAny <SignupUser>()), Times.Once);
data.HasExecuted.Should().BeTrue();
data.HasCommitted.Should().BeFalse();
data.Result.Verify(s => s.Execute(It.IsAny <UserByEmail>()), Times.Once);
}
private void SetupCreateData()
{
ViewData[CoppaDateKey] = SignupData.GetCoppaDate();
ViewData[TosKey] = _settingsManager.Current.TermsOfService;
ViewData[ServerTimeZoneKey] = _settingsManager.Current.ServerTimeZone;
}
public async Task <IActionResult> RegisterWorker(string workshopId, [FromBody] SignupData data)
{
_log.Info("Calling signup worker endpoint...");
return(await RegisterUser(data, UserRole.Worker, workshopId));
}
public ActionResult UserForm(string name, string email, string password, string repassword, int usertype, int department)
{
var user = new SignupData
{
Name = name,
Email = email,
Password = password,
PasswordRetype = repassword,
UserType = usertype,
DepartmentId = department
};
ViewData["name"] = name;
ViewData["email"] = email;
Regex regex = new Regex(@"^([\w\.\-]+)@([\w\-]+)((\.(\w){2,3})+)$");
Match match = regex.Match(email ?? "");
if (string.IsNullOrEmpty(name))
{
ModelState.AddModelError("title", "Please enter your name!");
}
else if (string.IsNullOrEmpty(email))
{
ModelState.AddModelError("email", "Please enter the email");
}
else if (string.IsNullOrEmpty(password))
{
ModelState.AddModelError("password", "Please enter your password!");
}
else if (string.IsNullOrEmpty(repassword))
{
ModelState.AddModelError("repassword", "Please enter your repassword!");
}
else if (password != repassword)
{
ModelState.AddModelError("repassword", "Repassword is not the same as password");
}
else if (match != null && !match.Success)
{
ModelState.AddModelError("email", "Email is invalid");
}
if (ViewData.ModelState.IsValid)
{
var user2 = _userService.CreateUser(user, HttpContext.Request.UserHostAddress);
_profileService.Create(user2, user);
return(RedirectToAction("EmailUsers"));
}
//if (String.IsNullOrWhiteSpace(subject) || String.IsNullOrWhiteSpace(body))
//{
// ViewBag.Result = Resources.SubjectAndBodyNotEmpty;
// return View();
//}
//var baseString = this.FullUrlHelper("Unsubscribe", AccountController.Name, new { id = "--id--", key = "--key--" });
//baseString = baseString.Replace("--id--", "{0}").Replace("--key--", "{1}");
//Func<User, string> unsubscribeLinkGenerator =
// user => String.Format(baseString, user.UserID, _profileService.GetUnsubscribeHash(user));
//_mailingListService.MailUsers(subject, body, htmlBody, unsubscribeLinkGenerator);
var user1 = new List <UserType>();
user1.Add(new UserType()
{
Id = 2, Name = "Staff"
});
user1.Add(new UserType()
{
Id = 1, Name = "Student"
});
//categories.Insert(0, new Category(0) {Title = "Uncategorized"});
var selectList = new SelectList(user1, "Id", "Name");
ViewData["userType"] = selectList;
var categories = _categoryService.GetAll();
var categoryList = new SelectList(categories, "CategoryID", "Title", 0);
ViewData["department"] = categoryList;
return(View());
}
public async Task <IActionResult> SignUp([FromBody] SignupData data)
{
_log.Info("Calling signup endpoint...");
return(await RegisterUser(data, UserRole.Client));
}
public void GetCoppaDateString()
{
Assert.AreEqual(DateTime.Now.AddYears(-13).ToLongDateString(), SignupData.GetCoppaDate());
}
public User CreateUser(SignupData signupData, string ip)
{
return(CreateUser(signupData.Name, signupData.Email, signupData.Password, _settingsManager.Current.IsNewUserApproved, ip));
}
