public async Task <RegistrationModel> OnRegistration(RegistrationInputModel input)
{
RegistrationModel result = new RegistrationModel();
if (string.IsNullOrEmpty(input.username) || string.IsNullOrEmpty(input.firstName) ||
string.IsNullOrEmpty(input.lastName) || string.IsNullOrEmpty(input.password))
{
result.GenerateError("Неки од података фале!");
return(result);
}
// check if there is account with same username
var db = ARDirect.Instance;
if (await ARDirect.Instance.Query <ClientDM>().Where("username={0}", input.username).CountAsync() > 0)
{
result.GenerateError("Корисничко име је заузето. Одаберите неко друго!");
return(result);
}
ClientDM client = new ClientDM(db)
{
username = input.username,
password = DirectPassword.Hash(input.password),
firstName = input.firstName,
lastName = input.lastName
};
await client.InsertAsync();
this.Notify(Sockets.Dashboard.Models.DashboardModel.FunctionTypes.notifySuccess, $"Нови корисник се регистровао: '${client.username}'!");
return(result);
}
public JsonResult ExtendedRegistration(RegistrationInputModel inputModel)
{
JsonResult result;
try
{
Assert.ArgumentNotNull(inputModel, "RegistrationInputModel");
RegistrationBaseJsonResult registrationBaseJsonResult = new RegistrationBaseJsonResult(StorefrontContext, SitecoreContext);
ValidateModel(registrationBaseJsonResult);
if (registrationBaseJsonResult.HasErrors)
{
result = Json(registrationBaseJsonResult, JsonRequestBehavior.AllowGet);
}
else
{
ManagerResponse <CreateUserResult, CommerceUser> managerResponse = AccountManager.RegisterUser(StorefrontContext, UpdateUserName(inputModel.UserName), inputModel.Password, inputModel.UserName);
if (managerResponse.ServiceProviderResult.Success && managerResponse.Result != null)
{
registrationBaseJsonResult.Initialize(managerResponse.Result);
AccountManager.Login(StorefrontContext, VisitorContext, managerResponse.Result.UserName, inputModel.Password, false);
AccountManager.UpdateUser(VisitorContext, inputModel.FirstName, inputModel.LastName, string.Empty, inputModel.UserName);
}
else
{
registrationBaseJsonResult.SetErrors(managerResponse.ServiceProviderResult);
}
result = Json(registrationBaseJsonResult);
}
}
catch (Exception exception)
{
result = Json(new BaseJsonResult("Registration", exception, StorefrontContext, SitecoreContext), JsonRequestBehavior.AllowGet);
}
return(result);
}
public IActionResult Post([FromBody] RegistrationInputModel inputModel)
{
if (inputModel.Username == null || inputModel.Password == null)
{
return(BadRequest("Username is empty"));
}
if (!Regex.IsMatch(inputModel.Username, "[A-Za-z0123456789\\-\\._@\\+]{3,}"))
{
return(BadRequest("Username should conains only letters or numbers or _@.+."));
}
if (inputModel.Password.Length <= 6)
{
return(BadRequest("Password should contains more than 6 symbols"));
}
if (_userManager.GetByNickName(inputModel.Username) != null)
{
return(BadRequest("Username is already exists"));
}
var result = _userManager.AddOrUpdate(CreateUserEntity(inputModel));
if (result == null || result.Id <= 0)
{
return(StatusCode(500));
}
return(Login(inputModel.Username, inputModel.Password));
}
public async Task <bool> RegisterUser(RegistrationInputModel registrationInputModel)
{
bool Success = false;
Success = await _IAuthService.RegisterUser(registrationInputModel);
return(Success);
}
private UserEntity CreateUserEntity(RegistrationInputModel model)
{
return(new UserEntity
{
Login = model.Username,
PasswordSalt = model.Password, // TODO AF: Put the salt in
});
}
public async Task <IActionResult> ExternalLogin(RegistrationInputModel registrationInputModel)
{
var provider = registrationInputModel.Provider;
var props = new AuthenticationProperties()
{
RedirectUri = Url.Action("ExternalLoginCallback"),
Items =
{
{ "returnUrl", registrationInputModel.ReturnUrl }
}
};
// windows authentication needs special handling
// since they don't support the redirect uri,
// so this URL is re-triggered when we call challenge
if (AccountOptions.WindowsAuthenticationSchemeName == provider)
{
// see if windows auth has already been requested and succeeded
var result = await HttpContext.AuthenticateAsync(AccountOptions.WindowsAuthenticationSchemeName);
if (result?.Principal is WindowsPrincipal wp)
{
props.Items.Add("scheme", AccountOptions.WindowsAuthenticationSchemeName);
var id = new ClaimsIdentity(provider);
id.AddClaim(new Claim(JwtClaimTypes.Subject, wp.Identity.Name));
id.AddClaim(new Claim(JwtClaimTypes.Name, wp.Identity.Name));
// add the groups as claims -- be careful if the number of groups is too large
if (AccountOptions.IncludeWindowsGroups)
{
var wi = wp.Identity as WindowsIdentity;
var groups = wi.Groups.Translate(typeof(NTAccount));
var roles = groups.Select(x => new Claim(JwtClaimTypes.Role, x.Value));
id.AddClaims(roles);
}
await HttpContext.SignInAsync(
IdentityServer4.IdentityServerConstants.ExternalCookieAuthenticationScheme,
new ClaimsPrincipal(id),
props);
return(Redirect(props.RedirectUri));
}
else
{
// challenge/trigger windows auth
return(Challenge(AccountOptions.WindowsAuthenticationSchemeName));
}
}
else
{
// start challenge and roundtrip the return URL
props.Items.Add("scheme", provider);
return(Challenge(props, provider));
}
}
/// <summary>
/// On Init
/// </summary>
protected override void OnInitialized()
{
Model = new RegistrationInputModel();
RegistrationContext = new EditContext(Model);
base.OnInitialized();
if (AuthenticationService.IsLoggedIn())
{
NavigationManager.NavigateTo("/");
}
}
private static RegistrationInputModel GetRequestingMetadata(
this INugetServerProvider provider,
HttpContext context)
{
var model = new RegistrationInputModel(
context.GetBaseUrl(),
context.Request.Path);
return(model);
}
public IActionResult RegisterUser(RegistrationInputModel registrationInputModel)
{
var vm = new RegisterUserViewModel
{
ReturnUrl = registrationInputModel.ReturnUrl,
Provider = registrationInputModel.Provider,
ProviderUserId = registrationInputModel.ProviderUserId
};
return(View(vm));
}
public RedirectToActionResult Register(RegistrationInputModel inputModel)
{
try
{
if (ModelState.IsValid)
{
string browserInfo = "Unable to determine"; // defaults
string deviceInfo = "Unable to determine"; // defaults
if (!Convert.ToBoolean(Configuration["MockData.Enabled"]))
{
try
{
UserAgentHelper.SetUserAgent(Request.Headers["User-Agent"]);
browserInfo = UserAgentHelper.Browser.Name + " " + UserAgentHelper.Browser.Version + " " + UserAgentHelper.Browser.Major;
deviceInfo = UserAgentHelper.OS.Name + " " + UserAgentHelper.OS.Version;
}
catch { }
}
var userModel = WebApiCaller.PostAsync <UserModel>("WebApi:Authenticate:Register", new RegisterUserRequestModel
{
Username = inputModel.Username,
Password = inputModel.Password,
ConfirmPassword = inputModel.ConfirmPassword,
FirstName = inputModel.FirstName,
LastName = inputModel.LastName,
EmailAddress = inputModel.EmailAddress,
Browser = browserInfo,
Device = deviceInfo
});
if (userModel != null)
{
CookieHelper.SignIn(userModel);
SecurityHelper.AddSessionUser(userModel);
return(RedirectToAction("Index", "Orders"));
}
else
{
return(RedirectToAction("Register", new { ErrorMessage = "Unable to perform registration. Please contact IT support." }));
}
}
else
{
return(RedirectToAction("Register", new { ErrorMessage = "There are validation errors with the information supplied." }));
}
}
catch (Exception ex)
{
return(RedirectToAction("Error", "Home", new { IsError = "True", ex.Message, BaseMessage = ex.GetBaseException().Message }));
}
}
public async Task <IActionResult> RegisterAsync(RegistrationInputModel input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var user = _mapper.Map <User>(input);
user.UserName = input.Email;
user.Nickname = input.FirstName;
var result = await _userManager.CreateAsync(user, input.Password);
if (result.Succeeded)
{
_logger.LogInformation("New account for {user} created", input.Email);
result = await _userManager.AddClaimsAsync(user, user.Claims());
if (!result.Succeeded)
{
_logger.LogError("Failed to add user claims", result.Errors);
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var link = Url.Action("ConfirmEmail", "Registration", new
{
userId = user.Id,
code
});
var msg = _emailSender.CreateEmailVerificationMessage(user, link);
_ = _emailSender.SendAsync(msg);
return(View("RegisterStatus", user.Email));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(View(input));
}
}
public async Task <IActionResult> Login(string returnUrl)
{
// build a model so we know what to show on the login page
var vm = await _account.BuildLoginViewModelAsync(returnUrl);
if (vm.IsExternalLoginOnly)
{
// we only have one option for logging in and it's an external provider
var registrationInputModel = new RegistrationInputModel
{
Provider = vm.ExternalLoginScheme,
ReturnUrl = returnUrl,
};
return(await ExternalLogin(registrationInputModel));
}
return(View(vm));
}
public IActionResult Register(RegistrationInputModel registrationInputModel)
{
if (!this.ModelState.IsValid)
{
return(this.Redirect("/Users/Register"));
}
if (registrationInputModel.Password != registrationInputModel.ConfirmPassword)
{
return(this.Redirect("/Users/Register"));
}
this.userServices.
CreateUser(registrationInputModel.Username, registrationInputModel.Email,
registrationInputModel.Password, registrationInputModel.FullName);
return(Redirect("/"));
}
public async Task <bool> RegisterUser(RegistrationInputModel registrationInputModel)
{
bool success = false;
UserDTO user = new UserDTO()
{
UserName = registrationInputModel.UserName,
Email = registrationInputModel.Email,
};
var userDTO = await authRepository.RegisterUser(user, registrationInputModel.Password);
if (userDTO != null)
{
List <ClaimDTO> claims = new List <ClaimDTO>();
claims.Add(new ClaimDTO()
{
ClaimType = "Permission", ClaimValue = "ALL"
});
var isClaimSuccess = await authRepository.AddClaimToUser(userDTO.Id, claims);
var isRpleSuccess = await authRepository.AdRoleToUser(userDTO.Id, "Admin");
if (isClaimSuccess && isRpleSuccess)
{
OrganizationDTO organizationDTO = new OrganizationDTO();
organizationDTO.Address = registrationInputModel.OrganizationInputModel.Address;
organizationDTO.Code = registrationInputModel.OrganizationInputModel.Code;
organizationDTO.Country = registrationInputModel.OrganizationInputModel.Country;
organizationDTO.State = registrationInputModel.OrganizationInputModel.State;
organizationDTO.Type = registrationInputModel.OrganizationInputModel.Type;
organizationDTO.PhoneNo = registrationInputModel.OrganizationInputModel.PhoneNo;
organizationDTO.Name = registrationInputModel.OrganizationInputModel.Name;
organizationDTO = await SaveOrgDetails(organizationDTO);
var result = await UpdateUser(userDTO);
success = true;
}
}
authRepository.Dispose();
return(success);
}
public void Register_Save_Successful()
{
// Given
var resources = new Resources();
var inputModel = new RegistrationInputModel
{
Username = "******",
Password = "******",
ConfirmPassword = "******",
FirstName = "Test",
LastName = "User",
EmailAddress = "*****@*****.**",
};
resources.MockApiCaller.AddMockResponse("WebApi:Authenticate:Register", new RegisterUserRequestModel
{
Username = inputModel.Username,
Password = inputModel.Password,
ConfirmPassword = inputModel.ConfirmPassword,
FirstName = inputModel.FirstName,
LastName = inputModel.LastName,
EmailAddress = inputModel.EmailAddress,
Browser = "Unable to determine",
Device = "Unable to determine",
}, new UserModel {
Username = "******", ApiSessionToken = Guid.NewGuid().ToString(), IsAuthenticated = true
});
// When
var result = resources.Controller.Register(inputModel) as RedirectToActionResult;
// Then
Assert.IsNotNull(result);
Assert.AreEqual("Index", result.ActionName);
Assert.AreEqual("Orders", result.ControllerName);
}
private static async Task RespondRegistrationIndexAsync(
this INugetServerProvider provider,
HttpContext context,
RegistrationInputModel registrationInput,
IEnumerable <Nuspec> nuspecs,
bool useGzip = false)
{
var nuspecList = nuspecs
.Select(x => new { Nuspec = x, Version = (NuGetVersionString)x.Metadata.Version })
.OrderBy(x => x.Version)
.Select(x => x.Nuspec)
.ToList();
var lowest = nuspecList.First().Metadata;
var uppest = nuspecList.Last().Metadata;
var parent = registrationInput.BaseUrl + registrationInput.Path;
var lowestVersion = SemanticVersion.Parse(lowest.Version).ToFullString();
var uppestVersion = SemanticVersion.Parse(uppest.Version).ToFullString();
var packageContentBase = registrationInput.BaseUrl +
provider.GetResourceUrlPath(NugetServerResourceType.PackageBaseAddress);
var model = new RegistrationIndexOutputModel
{
Count = nuspecList.Count
};
foreach (var nuspec in nuspecList)
{
var publishTime = new DateTimeOffset(new FileInfo(nuspec.FilePath).LastWriteTimeUtc);
var metadata = nuspec.Metadata;
var modelItem = new RegistrationPageOutputModel()
{
Id = $"{registrationInput.BaseUrl}{registrationInput.Path}#page/{metadata.Version}/{metadata.Version}",
Count = nuspecList.Count,
Lower = lowestVersion,
Upper = uppestVersion,
};
// If present Items, MUST also present Parent,Id need NOT be used.
modelItem.Parent = parent;
modelItem.Items = new List <RegistrationLeafOutputModel>()
{
new RegistrationLeafOutputModel
{
Id = registrationInput.BaseUrl +
registrationInput.PathBase +
$"/{metadata.Version}.json",
PackageContent = packageContentBase +
$"/{metadata.Id.ToLowerInvariant()}" +
$"/{metadata.Version.ToLowerInvariant()}" +
$"/{metadata.Id.ToLowerInvariant()}" +
$".{metadata.Version.ToLowerInvariant()}.nupkg",
Registration = registrationInput.BaseUrl +
registrationInput.Path,
CatalogEntry = new RegistrationCatalogEntryOutputModel
{
Id_alias = registrationInput.BaseUrl +
registrationInput.PathBase +
$"/{metadata.Version}.json",
Id = metadata.Id,
Authors = metadata.Authors,
Description = metadata.Description,
ProjectUrl = metadata.ProjectUrl,
IconUrl = metadata.IconUrl,
Summary = metadata.ReleaseNotes ?? metadata.Description,
Tags = metadata.Tags?.Split(
new[] { ',' },
StringSplitOptions.RemoveEmptyEntries)
?.ToList() ?? new List <string>(0),
Title = metadata.Id,
Version = metadata.Version,
LicenseUrl = metadata.LicenseUrl,
Listed = !provider.PackageStatusProvider.IsDeleted(metadata.Id, metadata.Version),
RequireLicenseAcceptance = metadata.RequireLicenseAcceptance,
PackageContent = packageContentBase +
$"/{metadata.Id.ToLowerInvariant()}" +
$"/{metadata.Version.ToLowerInvariant()}" +
$"/{metadata.Id.ToLowerInvariant()}" +
$".{metadata.Version.ToLowerInvariant()}.nupkg",
Published = publishTime,
DependencyGroups = metadata.Dependencies
.Select(deps =>
new RegistrationDependencyGroupOutputModel
{
//Id_alias = ""
TargetFramework = deps.TargetFramework,
Dependencies = deps.Dependency.Select(dep =>
new RegistrationDependencyOutputModel
{
Id = dep.Id,
//Id_Alias = "",
Range = dep.Version,
Registration = registrationInput.BaseUrl +
registrationInput.Path
}).ToList()
}).ToList()
}
}
};
model.Items.Add(modelItem);
}
await provider.WriteJsonResponseAsync(context, model, useGzip : useGzip);
}
public ActionResult Register(RegistrationInputModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
if (WebSecurity.UserExists(model.Name))
{
ModelState.AddModelError("Name", "Пользователь с таким логином уже существует!");
}
if (RepositoryManager.UserRepository.IsEmailExist(model.Email))
{
ModelState.AddModelError("Email", "Пользователь с таким email уже существует!");
}
//To show new errors
if (!ModelState.IsValid)
{
return View(model);
}
WebSecurity.CreateUserAndAccount(model.Name, model.Password, new
{
Email = model.Email,
AddTime = DateTime.Now
});
WebSecurity.Login(model.Name, model.Password, true);
return RedirectToAction("Index", "Home");
}
