// POST api/CustomRegistration
public HttpResponseMessage Post(RegistrationRequest registrationRequest)
{
if (!Regex.IsMatch(registrationRequest.username, "^[a-zA-Z0-9]{4,}$"))
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid username (at least 4 chars, alphanumeric only)");
}
else if (registrationRequest.password.Length < 8)
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid password (at least 8 chars required)");
}
XamarinPushDemoContext context = new XamarinPushDemoContext();
Account account = context.Accounts.Where(a => a.Username == registrationRequest.username).SingleOrDefault();
if (account != null)
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "That username already exists.");
}
else
{
byte[] salt = CustomLoginProviderUtils.generateSalt();
Account newAccount = new Account
{
Id = Guid.NewGuid().ToString(),
Username = registrationRequest.username,
Salt = salt,
SaltedAndHashedPassword = CustomLoginProviderUtils.hash(registrationRequest.password, salt)
};
context.Accounts.Add(newAccount);
context.SaveChanges();
return this.Request.CreateResponse(HttpStatusCode.Created);
}
}
private void btnRegister_Click(object sender, RoutedEventArgs e)
{
if (Validation() == true)
{
// show Loader
myIndeterminateProbar.Visibility = Visibility.Visible;
// Parameters
RegistrationRequest obj = new RegistrationRequest();
obj.firstName = txtFirstName.Text.Trim();
obj.lastName = txtLastName.Text.Trim();
obj.email = txtEmail.Text.Trim();
obj.userName = txtUserName.Text.Trim();
obj.organizationName = txtBusinessName.Text.Trim();
obj.businessPhone = Convert.ToInt64(txtBusinessPhone.Text.Trim());
// Write user details
if (ISOFile.FileExists("SignUpFirstPageDetails"))
{
ISOFile.DeleteFile("SignUpFirstPageDetails");
}
using (IsolatedStorageFileStream fileStream = ISOFile.OpenFile("SignUpFirstPageDetails", FileMode.Create))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(RegistrationRequest));
serializer.WriteObject(fileStream, obj);
// show Loader
myIndeterminateProbar.Visibility = Visibility.Visible;
// Redirect to home page
NavigationService.Navigate(new Uri("/Views/Registration/SignUpSecondPage.xaml", UriKind.Relative));
}
}
}
public void Login(Credentials credentials)
{
var body = new RegistrationRequest(credentials);
_rest.PostForObjectAsync<RegistrationResponce>("/api/v1/person/sign_in.json", body, r =>
{
if(r.Error == null)
{
_token = r.Response.api_token;
}
AuthorizationFinished(this, new AsyncOperationFinishedEventArgs(r.Error));
});
}
public object Post(RegistrationRequest request)
{
//sprawdzenie czy user jest w bazie danych
//wstawienei do bazy danych
//odpowiedz do frontu
User user1 = new User();
user1.Firstname = request.Firstname.ToString();
user1.Lastname = request.Lastname.ToString();
user1.Login = request.Login.ToString();
user1.Password = request.Password.ToString();
RegistrationResponse Response = new RegistrationResponse();
int result = Response.Session(request);
base.Response.StatusCode = result;
return Response;
}
private string Authorize(string enteredLogin, string enteredPassword)
{
var customerDto = new CustomerDto()
{
Login = enteredLogin,
Password = enteredPassword
};
RegistrationRequest request = new RegistrationRequest()
{
NewCustomerData = customerDto
};
return client.RegisterNewCustomer(request).Message;
}
public async Task <IActionResult> Register([FromBody] RegistrationRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(new AuthenticationFailedResponse
{
Errors = ModelState.Values.SelectMany(x => x.Errors.Select(y => y.ErrorMessage))
}));
}
var existingUser = await _userManager.FindByEmailAsync(request.Email);
if (existingUser != null)
{
return(BadRequest(new AuthenticationFailedResponse
{
Errors = new[] { "User with this e-mail address already exists." }
}));
}
var newUser = new User
{
Email = request.Email,
UserName = request.Email
};
var createdUser = await _userManager.CreateAsync(newUser, request.Password);
if (!createdUser.Succeeded)
{
return(BadRequest(new AuthenticationFailedResponse
{
Errors = createdUser.Errors.Select(x => x.Description)
}));
}
var tokenHandler = new JwtSecurityTokenHandler();
var token = GetToken(newUser, tokenHandler);
return(Ok(new AuthenticationSuccessResponse
{
Token = tokenHandler.WriteToken(token)
}));
}
public RegistrationResponse Post(RegistrationRequest request)
{
var id = ShortGuid.NewGuid();
var user = this.GetLMConnectUser();
var miner = new LISpMiner.LISpMiner(Config.Environment, id.ToString(), request.DbConnection, request.Metabase, request.SharedBinaries);
Config.Environment.Register(miner);
// is user authenticated
if (user == null)
{
var owner = request.Owner;
if (owner != null)
{
// user to be registered
user = new LMConnect.Key.User
{
Username = owner.Username,
Password = owner.Password
};
this.Repository.Add(user);
}
else
{
// use anon user
user = this.GetAnonymousUser();
}
}
user.Miners.Add(new LMConnect.Key.Miner
{
Owner = user,
MinerId = miner.Id,
Path = miner.LMPrivatePath
});
this.Repository.Save(user);
return(new RegistrationResponse {
Id = id
});
}
string RequestCredentials(string email)
{
RegistrationRequest requestData = new RegistrationRequest
{
Email = email,
ServiceTypes = RegistrationConfig.BOLT_SERVICE_ID
};
string body = JsonConvert.SerializeObject(requestData);
string result = null;
try
{
WebRequest webRequest = WebRequest.Create(REGISTER_URL);
var data = Encoding.UTF8.GetBytes(body);
webRequest.Method = "POST";
webRequest.ContentType = "application/json";
webRequest.ContentLength = data.Length;
using (var writer = webRequest.GetRequestStream())
{
writer.Write(data, 0, data.Length);
writer.Close();
using (var resp = webRequest.GetResponse())
{
using (var reader = new StreamReader(resp.GetResponseStream()))
{
result = reader.ReadToEnd();
}
}
}
}
catch (Exception ex)
{
BoltLog.Exception(ex);
return(null);
}
return(result);
}
public async Task <RegistrationResponse> RegisterAsync(RegistrationRequest request)
{
var existingUser = await _userManager.FindByNameAsync(request.UserName);
if (existingUser != null)
{
throw new Exception($"Username '{request.UserName}' already exists.");
}
var user = new ApplicationUser
{
Email = request.Email,
FirstName = request.FirstName,
LastName = request.LastName,
UserName = request.UserName,
EmailConfirmed = true
};
var existingEmail = await _userManager.FindByEmailAsync(request.Email);
if (existingEmail == null)
{
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
await _userManager.AddClaimAsync(user,
new Claim("AccessKey", user.AccessKey.ToString()));
return(new RegistrationResponse()
{
UserId = user.Id
});
}
else
{
throw new Exception($"{result.Errors}");
}
}
else
{
throw new Exception($"Email {request.Email} already exists.");
}
}
public void AdminRegistration_Email_NoDot_Return_BadRequest()
{
var controller = new AdminController(_adminBusiness, _configuration);
var newAdminData = new RegistrationRequest
{
FirstName = "John",
LastName = "Cena",
Email = "JohnCena@gmailcom",
Password = "******",
ContactNumber = "1234567890",
IsVerified = true,
CreatorStamp = "Vin",
CreatorUser = "******"
};
var data = controller.Registration(newAdminData);
Assert.IsType <BadRequestObjectResult>(data);
}
public static RegistrationEntity CreateRegistrationEntity(string password = "******")
{
var tenantProvider = ProviderFactory.Instance.CreateTenantServiceProvider();
var registrationRequest = new RegistrationRequest();
registrationRequest.Account = new Account();
var tenant = new Tenant();
tenant.DisplayName = "fakeTenant";
tenant.ID = Guid.NewGuid();
tenant.Code = GenerateRandomString();
tenant.Address = new Address();
tenant.Person = new Person();
tenant.Organization = new Organization();
var account = registrationRequest.Account;
account.AccountType = EAccountType.Master;
account.Email = GenerateRandomString() + "@test.com";
account.PasswordHash = HashingUtil.CalculateMD5Hash(password);
account.Verified = true;
account.ID = Guid.NewGuid();
account.TenantID = tenant.ID;
account.Address = new Address();
account.Person = new Person();
tenantProvider.CreateTenantAndAccount(new RegistrationRequest()
{
Account = account,
Tenant = tenant
});
var entity = new RegistrationEntity()
{
Account = account,
Tenant = tenant,
AccountPassword = password
};
return(entity);
}
/// <summary>
/// Adds a registration request to the database.
/// </summary>
/// <param name="request">The registration request</param>
/// <returns>The number of records inserted</returns>
public int AddRegistrationRequest(RegistrationRequest request)
{
int count = 0;
using (SqlConnection connection = new SqlConnection(connectionString)) {
connection.Open();
SqlCommand insert = new SqlCommand("INSERT INTO RegistrationRequest (email, coursecode, statusCode)" +
"VALUES (@UEmail, @CCode, @Status);");
insert.Parameters.AddWithValue("@UEmail", request.RegistrationUser.Email);
insert.Parameters.AddWithValue("@CCode", request.RegistrationCourse.CourseCode);
insert.Parameters.AddWithValue("@Status", (int)request.RegistrationStatus);
insert.Connection = connection;
count = insert.ExecuteNonQuery();
}
return(count);
}
public async Task <IActionResult> Register(RegistrationRequest request)
{
string userName = request.UserName.ToLower();
if (await _authenticationRepository.UserExists(userName))
{
return(BadRequest("Username already exists"));
}
User user = await _authenticationRepository.RegisterNewUser(userName, request.Password);
RegistrationResponse response = new RegistrationResponse()
{
UserID = user.Id,
UserName = user.UserName
};
return(StatusCode(StatusCodes.Status201Created, response));
}
public void Register_ReturnsBadRequest_UserNotRegistered()
{
var request = new RegistrationRequest();
var interactor = new Mock <RegisterUserInteractor>();
interactor.Setup(x => x.Execute(request)).Returns(new RegistrationResult {
ResultMessage = "ErrorMessage"
});
RegisterController controller = new RegisterController(interactor.Object);
var result = controller.Register(request);
var resultAsStatus = result as BadRequestObjectResult;
Assert.NotNull(resultAsStatus);
Assert.Equal(400, resultAsStatus.StatusCode);
interactor.Verify();
}
public void AdminRegistration_EmptyFields_Return_BadRequest()
{
var controller = new AdminController(_adminBusiness, _configuration);
var newAdminData = new RegistrationRequest
{
FirstName = "",
LastName = "",
Email = "",
Password = "",
ContactNumber = "",
IsVerified = false,
CreatorStamp = "",
CreatorUser = ""
};
var data = controller.Registration(newAdminData);
Assert.IsType <BadRequestObjectResult>(data);
}
public void AdminRegistration_ValidData_Return_OkResult()
{
var controller = new AdminController(_adminBusiness, _configuration);
var adminData = new RegistrationRequest
{
FirstName = "Abcd",
LastName = "Efgh",
Email = "*****@*****.**",
Password = "******",
ContactNumber = "1234567890",
IsVerified = true,
CreatorStamp = "Vin",
CreatorUser = "******"
};
var data = controller.Registration(adminData);
Assert.IsType <OkObjectResult>(data);
}
public async Task <string> Sign(RegistrationRequest request)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
// This switch must be set before creating the GrpcChannel/HttpClient (Because of macOS).
// see https://docs.microsoft.com/en-us/aspnet/core/grpc/troubleshoot?view=aspnetcore-3.0#call-insecure-grpc-services-with-net-core-client
AppContext.SetSwitch(
"System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
}
var address = configuration.GetValue <string>("SignatureServiceAddress");
using var channel = GrpcChannel.ForAddress(address);
var client = new LicenseSignature.LicenseSignatureClient(channel);
var reply = await client.GenerateAsync(new SignatureRequest { LicenseKey = request.LicenseKey });
return(reply.Signature);
}
private RegistrationStatus ValidateRegistration(RegistrationRequest registrationRequest)
{
if (string.IsNullOrWhiteSpace(registrationRequest.Password))
{
return(RegistrationStatus.INVALID_PASSWORD);
}
if (string.IsNullOrWhiteSpace(registrationRequest.UserName))
{
return(RegistrationStatus.INVALID_USERNAME);
}
if (_userRepository.GetByUserName(registrationRequest.UserName) != null)
{
return(RegistrationStatus.TAKEN_USERNAME);
}
return(RegistrationStatus.SUCCESS);
}
public void AdminRegistration_Password_LessThan8_Return_BadRequest()
{
var controller = new AdminController(_adminBusiness, _configuration);
var adminData = new RegistrationRequest
{
FirstName = "Mark",
LastName = "Henry",
Email = "*****@*****.**",
Password = "******",
ContactNumber = "1234567890",
IsVerified = true,
CreatorStamp = "Vin",
CreatorUser = "******"
};
var data = controller.Registration(adminData);
Assert.IsType <BadRequestObjectResult>(data);
}
public HttpResponseMessage AdminRegistration(RegistrationRequest registrationRequest)
{
try
{
var respList = new List <string>();
if (!AuthUtils.IsEmailValid(registrationRequest.Email))
{
respList.Add(registrationRequest.Email);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_REG_INVALID_EMAIL, respList)));
}
var admin = _context.Admins.AsNoTracking().SingleOrDefault(a => a.Email == registrationRequest.Email);
if (admin != null)
{
respList.Add(registrationRequest.Email);
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_REG_EXISTS_EMAIL, respList)));
}
var salt = AuthUtils.GenerateSalt();
var newUser = new Admin
{
Id = SequentialGuid.NewGuid().ToString(),
Email = registrationRequest.Email,
Salt = salt,
SaltedAndHashedPassword = AuthUtils.Hash(registrationRequest.Password, salt)
};
_context.Admins.Add(newUser);
_context.SaveChanges();
respList.Add(newUser.Id);
return(Request.CreateResponse(HttpStatusCode.OK, RespH.Create(RespH.SRV_CREATED, respList)));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
RespH.Create(RespH.SRV_EXCEPTION, new List <string> {
ex.ToString()
})));
}
}
internal virtual RegistrationResponse HandleUnregistration(RegistrationRequest request)
{
_response = _ardResponseFac.RegistrationOK(CommandEnum.Unregister);
var name = _proxy.Info.UniqueName;
var mac = _proxy.Info.Mac;
CMProxyHub.Sgt.Unregister(mac);
var task = Task.Factory.StartNew(() =>
{
var dash = AppDomain.CurrentDomain.UnityContainer().Resolve <AbstractDashboard>();
dash.LogAsync($"{name} ({mac}) has been unregistered :(.");
});
CallProxyActionEvent(ProxyEventEnum.ProxyUnregistered);
return((RegistrationResponse)_response);
}
// POST api/CustomRegistration
public HttpResponseMessage Post(RegistrationRequest registrationRequest)
{
var message = "Fail";
homesecurityContext context = new homesecurityContext();
if(registrationRequest != null)
{
Account account = context.Accounts.Where(a => a.Email == registrationRequest.email).SingleOrDefault();
if (account != null)
{
//account already exists
return this.Request.CreateResponse(HttpStatusCode.BadRequest, new { message });
}
else
{
//create new account
byte[] salt = CustomLoginProviderUtils.generateSalt();
Account newAccount = new Account
{
Id = Guid.NewGuid().ToString(),
Email = registrationRequest.email,
Salt = salt,
SaltedAndHashedPassword = CustomLoginProviderUtils.hash(registrationRequest.password, salt),
Verified = false
};
context.Accounts.Add(newAccount);
context.SaveChanges();
rm.message = "Created";
rm.verified = false;
try
{
//send email to this email address so that a user may verify it
VerifyAccountEmail(registrationRequest.email);
}catch(Exception e)
{
ApiServices.Log.Error("ERROR SENDING EMAIL");
}
return this.Request.CreateResponse(HttpStatusCode.Created, rm);
}
}
message = "Failed";
return this.Request.CreateResponse(HttpStatusCode.BadRequest, new { message });
}
public IActionResult Registration([FromBody] RegistrationRequest regModel)
{
var user = new TMUser()
{
UserName = regModel.Username
};
if (!_userManager.Users.Any(u => u.UserName.Equals(regModel.Username)))
{
var task = _userManager.CreateAsync(user, regModel.Password);
task.Wait(Constants.AsyncTaskWaitTime);
var result = task.Result;
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
}
return(Ok());
}
public async Task <ResponseDTO <bool> > Register(RegistrationRequest request)
{
var response = new ResponseDTO <bool>();
var isNickTaken = _context.Users.Where(u => u.Login == request.Login).Count();
if (isNickTaken != 0)
{
response.Error = new Error(409, "Nick name is taken");
return(response);
}
await _context.Users.AddAsync(new UserEntity(request));
await _context.SaveChangesAsync();
response.Data = true;
return(response);
}
public async Task <RegistrationResponse> RegisterClientForCode(string address, string redirectUri)
{
var client = new DynamicRegistrationClient(address);
var request = new RegistrationRequest
{
RedirectUris = { redirectUri },
ApplicationType = "native"
};
var response = await client.RegisterAsync(request);
if (response.IsError)
{
throw new Exception(response.ErrorDescription);
}
return(response);
}
public void ProcessUserRegistration_ErrorTest()
{
var tgimbaApi = new SharedTgimbaApiController(this.tgimbaService.Object, this.validationHelper.Object);
var registration = new RegistrationRequest()
{
Login = GetLoginRequest(), EncodedEmail = "email"
};
validationHelper.Setup(x => x.IsValidRequest
(It.IsAny <RegistrationRequest>()))
.Throws(new ArgumentNullException(""));
IActionResult result = tgimbaApi.ProcessUserRegistration(registration);
BadResultVerify(result);
tgimbaService.Verify(x => x.ProcessUserRegistration(It.IsAny <string>(), It.IsAny <string>()
, It.IsAny <string>()), Times.Never);
}
public async Task <ServiceState> CreateAsync(RegistrationRequest modelDto)
{
if (modelDto.Email.Split(' ').Length == 2)
{
State.ErrorMessage = "Email should not contain spaces!";
State.TypeOfError = TypeOfServiceError.BadRequest;
return(State);
}
if (string.IsNullOrWhiteSpace(modelDto.Password))
{
State.ErrorMessage = "You must type a password.";
State.TypeOfError = TypeOfServiceError.BadRequest;
return(State);
}
var checkIfUserExistByUserName = await _userRepository.GetUserByNameAsync(modelDto.UserName);
if (checkIfUserExistByUserName != null)
{
State.ErrorMessage = "User with user name already exist!";
State.TypeOfError = TypeOfServiceError.BadRequest;
return(State);
}
var checkIsUserAlreadyExistWithEmail = await _userRepository.GetUserAsync(modelDto.Email);
if (checkIsUserAlreadyExistWithEmail != null)
{
State.ErrorMessage = "User with requested email already exist!";
State.TypeOfError = TypeOfServiceError.BadRequest;
return(State);
}
// Create user
var user = new ApplicationUser()
{
Email = modelDto.Email,
UserName = modelDto.UserName,
//Tweets = new List<Tweet>()
};
await _userRepository.CreateAsync(user, modelDto.Password);
return(State);
}
private void EndPoint_Register()
{
var request = new RegistrationRequest()
{
Login = new LoginRequest()
{
EncodedUserName = Base64Encode(userName),
EncodedPassword = Base64Encode(password)
},
EncodedEmail = Base64Encode(email)
};
var json = JsonConvert.SerializeObject(request);
var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var url = host + "processuserregistration";
var result = Post(url, content).Result;
Assert.AreEqual(true, System.Convert.ToBoolean(result));
}
public async Task <Registration> Register(RegistrationRequest registration)
{
// check client scope / workspace audience
var workspace = await _workspaceStore.Load(registration.ResourceId);
if (workspace == null)
{
throw new ResourceNotFound();
}
if (!workspace.HasScope(Client.Scope))
{
throw new InvalidClientAudience();
}
var game = await _gamespaceStore.ListByProfile(registration.SubjectId)
.SingleOrDefaultAsync(m => m.GlobalId == registration.ResourceId);
string id = game?.GlobalId ?? Guid.NewGuid().ToString();
string token = Guid.NewGuid().ToString("n");
Challenge challenge = null;
try
{
var spec = JsonSerializer.Deserialize <ChallengeSpec>(workspace.Challenge, jsonOptions);
challenge = Mapper.Map <Challenge>(spec);
challenge.GamespaceId = id;
}
catch {}
return(new Registration {
SubjectId = registration.SubjectId,
SubjectName = registration.SubjectName,
ResourceId = registration.ResourceId,
GamespaceId = id,
Token = token,
RedirectUrl = _options.LaunchUrl + token,
ClientId = Client.Id,
Challenge = challenge
});
}
public async Task <IActionResult> RegistrationRequest(RegistrationRequest request)
{
try
{
var cancellationToken = GetCancellationToken();
var userExists = await _userManager.FindByEmailAsync(request.Email);
if (userExists != null)
{
var urlLink = Url.Action("ForgotPassword", "Account");
ViewData["message"] = $"A user has already been registered with this email address. If you are this person, head <a href=\"{urlLink}\"> here </a> to reset your password.";
ViewBag.Success = false;
}
else
{
var adminUsers = (await _roleManager.GetUserIdsInRoleAsync(RoleNameConstants.AdminRole, cancellationToken)).ToList();
var superAdmminUsers = (await _roleManager.GetUserIdsInRoleAsync(RoleNameConstants.SuperAdminRole, cancellationToken)).ToList();
var emails = new List <string>();
foreach (var userId in (adminUsers.Union(superAdmminUsers)))
{
var user = await _userManager.FindByIdAsync(userId);
emails.Add(user.Email.Value);
}
await _sesService.SendBulkEmail(emails.AsEnumerable(), GetRequestEmail(request), "New User Request", cancellationToken);
ViewData["message"] = "Thanks, your request has been sent to the web site admins one of whom will respond as soon as they're able to.";
ViewBag.Success = true;
}
}
catch (Exception ex)
{
ViewBag.Success = false;
_logger.LogError(ex, $"There was an error handling the registration request for {request.Email}");
ViewData["message"] = "Unfortunately there was an error handling your request. The web admins have been notified";
}
return(View(request));
}
public ServiceResult CreateNewUser(RegistrationRequest registrationData)
{
SystemUserData systemUserData = new SystemUserData
{
Login = registrationData.Login,
OldPassword = registrationData.Password,
NewPassword = registrationData.Password,
Email = registrationData.Email,
Phone = registrationData.Phone,
FirstName = registrationData.FirstName,
LastName = registrationData.LastName,
IdUser = 0,
Role = (new UserRole(UserRole.RoleEnum.User)).GetRoleName(),
Status = (new UserStatus(UserStatus.StatusEnum.Active)).GetStatusName()
};
var serviceResult = _userSystemService.CreatByRegistration(systemUserData);
return(serviceResult);
}
public async Task <IActionResult> RegisterAsync(RegistrationRequest registrationRequest)
{
RegistrationModel registrationModel = registrationRequest.Adapt <RegistrationModel>();
RegistrationResultModel result;
try
{
result = await _accountService.RegisterUserAsync(registrationModel);
}
catch (ConflictException e)
{
return(BadRequest(e.Message));
}
AuthorizationResponse authorizationResponse = result.Adapt <AuthorizationResponse>();
await HttpContext.SignInAsync(authorizationResponse);
return(Ok(authorizationResponse));
}
/// <summary>
/// Rejects all selected requests
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void BtnReject_Click(object sender, EventArgs e)
{
List <int> selectedIDs = GetSelectedIDs();
RegistrationRequestDAO requestDAO = new RegistrationRequestDAO(
ConfigurationManager.ConnectionStrings["flexiLearn"].ConnectionString);
CourseDAO courseDAO = new CourseDAO(
ConfigurationManager.ConnectionStrings["flexiLearn"].ConnectionString);
foreach (int id in selectedIDs)
{
RegistrationRequest request = requestDAO.SearchByRegistrationID(id);
request.RegistrationStatus = Status.REJECTED;
requestDAO.ModifyStatus(request);
}
allRequests = requestDAO.ReadAll();
GVRegistrationRequests.DataSource = allRequests;
GVRegistrationRequests.DataBind();
}
public IdentityResult Register(RegistrationRequest model)
{
ApplicationUser user = new ApplicationUser {
UserName = model.Email, Email = model.Email
};
IdentityResult result = _userManager.Create(user, model.Password);
if (result.Succeeded)
{
_signInManager.SignIn(user, isPersistent: false, rememberBrowser: false);
// 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(result);
}
public async Task <IActionResult> Register([FromBody] RegistrationRequest user)
{
var passwordValidationRes = AuthenticationHelper.CheckPasswordRequierments(user.Password);
if (passwordValidationRes != null)
{
return(BadRequest(passwordValidationRes));
}
if (await _usersService.IsUserExists(user.UserName))
{
return(UnprocessableEntity($"user name {user.UserName} is taken"));
}
await _usersService.Register(user);
var redirectUrl = _urlHelper.Link("Login", null);
return(Redirect(redirectUrl));
}
public async Task <ActionResult <RegistrationResponse> > RegisterAsync(RegistrationRequest request)
{
using (await _locker.EnterAsync(request.Username))
{
// ensure username is unique
if (await _users.GetByNameAsync(request.Username) != null)
{
return(BadRequest($"Cannot use the username '{request.Username}'."));
}
var user = new User
{
Username = request.Username,
Secret = _hash.Hash(request.Password),
Permissions = _options.DefaultUserPermissions
};
await _users.UpdateAsync(user);
await _snapshot.CreatedAsync(user, default, SnapshotType.System, user.Id);
// POST api/CustomRegistration
public HttpResponseMessage Post(RegistrationRequest registrationRequest)
{
if (!Regex.IsMatch(registrationRequest.username, "^[a-zA-Z0-9]{4,}$"))
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid username (at least 4 chars, alphanumeric only)");
}
else if (registrationRequest.password.Length < 8)
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "Invalid password (at least 8 chars required)");
}
ToeTrackerTrainerMobContext context = new ToeTrackerTrainerMobContext();
Account account = context.Accounts.Where(a => a.Username == registrationRequest.username).SingleOrDefault();
if (account != null)
{
return this.Request.CreateResponse(HttpStatusCode.BadRequest, "That username already exists.");
}
else
{
byte[] salt = CustomLoginProviderUtils.generateSalt();
Account newAccount = new Account
{
Id = Guid.NewGuid().ToString(),
Username = registrationRequest.username,
Salt = salt,
SaltedAndHashedPassword = CustomLoginProviderUtils.hash(registrationRequest.password, salt),
FirstName = registrationRequest.FirstName,
LastName = registrationRequest.LastName,
Phone = registrationRequest.Phone,
Address = registrationRequest.Address,
Email = registrationRequest.Email,
Trainer= registrationRequest.Trainer
};
context.Accounts.Add(newAccount);
context.SaveChanges();
return this.Request.CreateResponse(HttpStatusCode.Created,"{\"UserCreation\":\"Success\"}");
}
}
public Task<RegistrationResult> Register(RegistrationRequest registrationRequest)
{
return Register(registrationRequest.Username, registrationRequest.Password);
}
public void RegisterNewCustomer_ShouldFailIfUserExists()
{
using (var transaction = new TransactionScope())
{
string login = "******";
string password = "******";
var customerDto = new CustomerDto()
{
Login = login,
Password = password
};
RegistrationRequest request = new RegistrationRequest()
{
NewCustomerData = customerDto
};
var response = _aptekaNetServiceClient.RegisterNewCustomer(request);
Assert.IsFalse(response.Success);
}
}
void RegisterUser(int num, RegistrationRequest rq, bool WritetoConsole = true)
{
requests.Remove(num);
var pname = NameTransform(rq.name);
var hash = Hash(rq.name, rq.password);
users.setValue(pname, hash);
users.Save(false);
var player = FindPlayer(rq.name);
if (player != null) // TODO: verify IP address
{
player.AuthenticatedAs = rq.name;
player.sendMessage("<Restrict> You are now registered.");
}
if(WritetoConsole)
Server.notifyOps("<Restrict> Registration request granted for: " + rq.name, true);
var duplicates = requests.Where(kv => kv.Value.name == rq.name).ToArray();
foreach (var kv in duplicates)
{
// deny other requests for the same name
requests.Remove(kv.Key);
}
}
void PlayerCommand(string command, ISender sender, string password)
{
if (! (sender is Player)) return;
var player = (Player) sender;
if (player.AuthenticatedAs != null && command == "reg")
{
sender.sendMessage ("<Restrict> Already registered, use /pass to change your password.", 255, 255, 180, 180);
return;
}
else if (player.AuthenticatedAs == null && command == "pass")
{
sender.sendMessage ("<Restrict> You are a guest, use /reg to submit a registration request.", 255, 255, 180, 180);
return;
}
if (password == null)
{
sender.sendMessage ("Error: password cannot be empty.", 255, 255, 180, 180);
return;
}
password = password.Trim();
if (password == "")
{
sender.sendMessage ("Error: password cannot be empty.", 255, 255, 150, 150);
return;
}
if (password.Length < 5)
{
sender.sendMessage ("Error: passwords must have at least 5 characters.", 255, 255, 150, 150);
return;
}
var name = player.Name;
var lp = password.ToLower();
if (lp == name.ToLower())
{
sender.sendMessage ("Error: passwords cannot be the same as your name.", 255, 255, 150, 150);
return;
}
if (obviousPasswords.Contains (lp))
{
sender.sendMessage ("Error: password not accepted, too obvious: " + lp, 255, 255, 150, 150);
return;
}
if (player.AuthenticatedAs != null)
{
var pname = NameTransform (name);
var oname = OldNameTransform (name);
var split = (users.getValue(pname) ?? users.getValue(oname)).Split(':');
var hash = Hash (name, password);
if (hash == split[0])
{
sender.sendMessage ("<Restrict> Already registered.");
return;
}
if (split.Length > 1 && split[1] == "op")
hash = hash + ":op";
users.setValue (oname, null);
users.setValue (pname, hash);
users.Save(false);
sender.sendMessage ("<Restrict> Your new password is: " + password);
return;
}
var address = NetPlay.slots[player.whoAmi].remoteAddress.Split(':')[0];
var previous = requests.Values.Where (r => r != null && r.address == address && r.name == name);
var cp = previous.Count ();
if (cp > 0)
{
if (cp > 1)
ProgramLog.Error.Log ("<Restrict> Non-fatal error: more than one identical registration request.");
var rq = previous.First();
if (password != rq.password)
{
rq.password = password;
sender.sendMessage ("<Restrict> Changed password on pending request to: " + password);
}
else
sender.sendMessage ("<Restrict> Request pending, your password: "******"<Restrict> Request submitted, your password: "******"<Restrict> New registration request ", requestCount, " for: ", name);
Server.notifyOps (msg, false);
ProgramLog.Users.Log (msg);
requestCount += 1;
}
public Task<RegistrationResult> Register(RegistrationRequest registrationRequest)
{
return _registration.Register(registrationRequest);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (ISOFile.FileExists("SignUpFirstPageDetails"))//read current SignUp First Page Details
{
using (IsolatedStorageFileStream fileStream = ISOFile.OpenFile("SignUpFirstPageDetails", FileMode.Open))
{
DataContractSerializer serializer = new DataContractSerializer(typeof(RegistrationRequest));
var ObjSignUpFirstPageData = (RegistrationRequest)serializer.ReadObject(fileStream);
//====================================================================================================================
// Read and Set first registration form details
//====================================================================================================================
// Parameters
RegistrationRequest obj = new RegistrationRequest();
//First Screen
obj.firstName = ObjSignUpFirstPageData.firstName;
obj.lastName = ObjSignUpFirstPageData.lastName;
obj.email = ObjSignUpFirstPageData.email;
obj.userName = ObjSignUpFirstPageData.userName;
obj.organizationName = ObjSignUpFirstPageData.organizationName;
obj.businessPhone = ObjSignUpFirstPageData.businessPhone;
// clear session info
var Settings = IsolatedStorageSettings.ApplicationSettings;
Settings.Remove("SignUpFirstPageDetails");
//Second Screen
ListPickerItem selectedItemState = this.listPickerState.ItemContainerGenerator.ContainerFromItem(this.listPickerState.SelectedItem) as ListPickerItem;
data_State SelecteddataState = selectedItemState.DataContext as data_State;
obj.state = Convert.ToInt32(SelecteddataState.stateId);
ListPickerItem selectedItemArea = this.listPickerArea.ItemContainerGenerator.ContainerFromItem(this.listPickerArea.SelectedItem) as ListPickerItem;
data_Area SelecteddataArea = selectedItemArea.DataContext as data_Area;
obj.area = Convert.ToInt32(SelecteddataArea.areaId);
ListPickerItem selectedItemCity = this.listPickerCity.ItemContainerGenerator.ContainerFromItem(this.listPickerCity.SelectedItem) as ListPickerItem;
data_City SelecteddatCity = selectedItemCity.DataContext as data_City;
obj.city = Convert.ToInt32(SelecteddatCity.zipId); // here zipId is cityID
obj.addressLine1 = txtStreet.Text.Trim();
obj.password = txtPassword.Password.Trim();
obj.isPointeMart = (chkRequest.IsChecked == true) ? 1 : 0;
obj.isPointePay = 1; // Always 1 since app itself is PointePay
obj.country = _countryId; // id of country (nigeria only)
obj.businessPhoneCode = _businessPhoneCode; //must add + before code e.g. +234
String data = "firstName=" + obj.firstName + "&lastName=" + obj.lastName + "&email=" + obj.email + "&userName="******"&organizationName=" + obj.organizationName + "&businessPhone=" + obj.businessPhone + "&state=" + obj.state + "&area=" + obj.area + "&city=" + obj.city + "&addressLine1=" + obj.addressLine1 + "&password="******"&isPointeMart=" + obj.isPointeMart + "&isPointePay=" + obj.isPointePay + "&country=" + obj.country + "&businessPhoneCode=" + obj.businessPhoneCode;
if (Validation() == true)
{
// Show Loader
myIndeterminateProbar.Visibility = Visibility.Visible;
//====================================================================================================================
// Submit Registration Form
//====================================================================================================================
//Initialize WebClient
WebClient webClient = new WebClient();
//Set Header
webClient.Headers[HttpRequestHeader.Authorization] = Utilities.GetAuthorization();
webClient.Headers["Content-Type"] = "application/x-www-form-urlencoded";
webClient.Headers[HttpRequestHeader.AcceptLanguage] = "en_US";
webClient.UploadStringAsync(new Uri(Utilities.GetURL("auth/signUp/")), "POST", data);
//Assign Event Handler
webClient.UploadStringCompleted += wc_UploadStringCompleted;
}
}
}
}
public void RegisterNewCustomer_ShouldSucceed()
{
string login = "******";
string password = "******";
var customerDto = new CustomerDto()
{
Login = login,
Password = password
};
RegistrationRequest request = new RegistrationRequest()
{
NewCustomerData = customerDto
};
var response = _aptekaNetServiceClient.RegisterNewCustomer(request);
Assert.IsTrue(response.Success);
}
