public IActionResult Register([FromBody] SignupRequest data)
{
#region Logging
if (Server.config.EnableFileLogging)
{
fileLogger.Log(LogLevel.Information, "[{0}] {1,6} {2} {3}",
DateTime.Now.ToString("HH:mm:ss dd.MM.yyyy"),
this.Request.Method,
this.Response.StatusCode,
this.Request.Path
);
}
consoleLogger.Log(LogLevel.Debug, "{0,6} {1} {2}",
this.Request.Method,
this.Response.StatusCode,
this.Request.Path
);
#endregion
AuthResponse response = new AuthResponse();
if (Server.usersStorage.ContainsKey(data.acc.login)) // user already registered and tries again
{
response.code = ApiErrCodes.LoginTaken;
response.defaultMessage = "Registered account with the same login already exists.";
}
else
{
if (Server.usersStorage.TryAdd(
data.acc.login,
(
hasher.HashPassword(data.acc, data.acc.password),
new User($"{data.nickname}#{ProvideUserID(Server.UsersList, data.nickname)}")
)
))
{
response.code = ApiErrCodes.Success;
response.defaultMessage = "OK";
Server.usersStorage[data.acc.login].user.groupsIDs.Add(0U); // bind group membership on User side
response.usr = Server.usersStorage[data.acc.login].user;
response.token = BitConverter.ToString(ComputeHash(response.usr.ToString(), Encoding.UTF8)).Replace("-", String.Empty); // experimental as hash is not used by client
Server.groupsStorage[0U].group.members.Add(response.usr); // add registered user to the group chat
//Server.groups.Find(g => g.groupID == 0U).members.Add(response.usr); 1
if (Server.config.EnableVerboseConsole)
{
consoleLogger.Log(LogLevel.Warning, $"New Account registered: {response.usr}" + Environment.NewLine +
$"{data.acc.login}:{Server.usersStorage[data.acc.login].passHash}" + Environment.NewLine
);
}
// update data stored in file
FileWorker.SaveToFileAsync(
Path.Combine(Directory.GetCurrentDirectory(), "UsersStorage.json"),
Server.usersStorage
);
}
public AquariumUser AddUser(SignupRequest signupRequest)
{
if (signupRequest.Password != signupRequest.Password2)
{
throw new Exception("Passwords do not match.");
}
if (_aquariumDao.GetUserByEmail(signupRequest.Email) != null)
{
throw new Exception("There is already account with this email.");
}
if (_aquariumDao.GetUserByUsername(signupRequest.Username) != null)
{
throw new Exception("Sorry, this username is already taken. Please try another one.");
}
signupRequest.Password = _encryptionService.Encrypt(signupRequest.Password);
signupRequest.Account = new AquariumUser()
{
Username = signupRequest.Username,
Email = signupRequest.Email,
Role = "User",
SeniorityDate = DateTime.Now.ToUniversalTime(),
Profile = new AquariumProfile()
};
var user = _aquariumDao.AddAccount(signupRequest);
return(user);
}
public CreateNewUser()
{
InitializeComponent();
SignupRequest vSignUpRequest = new SignupRequest();
this.BindingContext = vSignUpRequest;
}
public async void SignUp(SignupRequest signupRequest, Action success, Action <SignupResponse> failed)
{
bool IsNetwork = true;//await DependencyService.Get<IMediaService>().CheckNewworkConnectivity();
if (IsNetwork)
{
var url = string.Format("{0}register.php", _settingsManager.ApiHost);
await Task.Factory.StartNew(() =>
{
var result = _apiProvider.Post <SignupResponse, SignupRequest>(url, signupRequest).Result;
if (result.IsSuccessful)
{
if (success != null)
{
signupResponse = result.Result;
success.Invoke();
}
}
else
{
failed.Invoke(result.Result);
}
});
}
else
{
UserDialogs.Instance.HideLoading(); UserDialogs.Instance.Alert(error, null, "OK");
}
}
public async Task <IActionResult> PostUser(
[FromBody] SignupRequest request,
[FromServices] IOptions <ApiBehaviorOptions> apiBehaviorOptions)
{
User user = new User
{
Username = request.Username,
Email = request.Email,
Password = Encoding.UTF8.GetBytes(request.Password)
};
try
{
user = await _userService.CreateUser(user);
}
catch (DbUpdateException)
{
if (await _userService.IsAnExistingUserAsync(user.Email))
{
ModelState.AddModelError(nameof(user.Email), "That email address is already in use");
return(apiBehaviorOptions.Value.InvalidModelStateResponseFactory(ControllerContext));
}
else
{
throw;
}
}
return(CreatedAtAction(nameof(GetUser), new { id = user.Id }, _userService.ItemToDTO(user)));
}
public async Task <IActionResult> Signup([FromBody] SignupRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Email, FirstName = model.FirstName, LastName = model.LastName, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _userManager.AddToRoleAsync(user, model.Role);
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.FirstName + " " + user.LastName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", model.Role));
//await _userRepository.InsertEntity(model.Role, user.Id, user.FullName);
return(Ok(new SignupResponse(user, model.Role)));
}
private void BindParams(MySqlCommand cmd, SignupRequest request)
{
cmd.Parameters.Add(new MySqlParameter
{
ParameterName = "@username",
DbType = DbType.String,
Value = request.Username,
});
cmd.Parameters.Add(new MySqlParameter
{
ParameterName = "@email",
DbType = DbType.String,
Value = request.Email,
});
cmd.Parameters.Add(new MySqlParameter
{
ParameterName = "@name",
DbType = DbType.String,
Value = request.Displayname,
});
cmd.Parameters.Add(new MySqlParameter
{
ParameterName = "@password",
DbType = DbType.String,
Value = request.Password,
});
}
public async Task <IActionResult> Register(SignupRequest request, CancellationToken cancellationToken)
{
try
{
var apiResponse = await _authService.RegisterAsync(request, cancellationToken);
if (apiResponse.Success)
{
await _mailService.SendEmailAsync(request.Email, "New user registration", "<p>New user" + DateTime.Now + "</p>", cancellationToken);
return(Ok(apiResponse));
}
else if (apiResponse.Errors[0].Code == StatusCodes.Status404NotFound)
{
return(NotFound(apiResponse));
}
return(BadRequest(apiResponse));
}
catch (Exception exception)
{
return(_actionResultMapper.Map(exception));
}
}
public async Task <IActionResult> Signup([FromBody] SignupRequest request)
{
var cmd = new SignupCommand(new ProjectData("", ""), request.EmailAddress, request.Password, request.Username);
var result = await mediator.Send(cmd);
return(result.Match <IActionResult>(user => Ok(), BadRequest));
}
public async Task <IActionResult> SignupUser([FromBody] SignupRequest request)
{
try
{
if (request != null)
{
bool emailAvailable = await UserHandler.EmailNotInUse(request.User.Email);
if (!emailAvailable)
{
return(StatusCode(505, new ErrorResponse()
{
Message = "There is already an account associated with that email address"
}));
}
var user = await UserHandler.InsertUser(request.User, request.Password);
if (user == null)
{
return(Unauthorized());
}
Logger.LogWarning("User added");
return(Ok(user));
}
return(StatusCode(404));
}
catch (Exception ex)
{
Logger.LogError(ex.ToString());
return(StatusCode(505, ex.Message));
}
}
public IActionResult SingUp(SignupRequest request)
{
Console.WriteLine(request.Login + " " + request.Password);
User user = _context.SignUp(request);
return(Created("", "You signed up successfully"));
}
public async Task <IActionResult> Siginup([FromBody] SignupRequest request)
{
if (ModelState.IsValid)
{
var user = _mapper.Map <User>(request);
if (await _userManager.FindByEmailAsync(user.Email) == null)
{
var newUser = new User
{
FirstName = user.FirstName,
LastName = user.LastName,
UserName = user.Email,
Email = user.Email
};
newUser.Id = Guid.NewGuid().ToString();
var result = await _userManager.CreateAsync(newUser, request.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(newUser, "Visitor");
return(StatusCode(201, new ApiResponse {
Status = true, Message = "Success"
}));
//var token = await _userManager.GenerateEmailConfirmationTokenAsync(newUser);
//var callBackLink = Url.ActionLink("ConfirmEmail", "Auth", new { token, userId = newUser.Id }, Request.Scheme);
//await _sendMail.SendMailAsync(_appSettings.Value.FromAddress, request.Email, "Confirm your email address...", callBackLink);
}
ModelState.AddModelError("Signup", string.Join("", result.Errors.Select(e => e.Description)));
}
}
return(BadRequest(new ApiResponse {
Status = false, Message = "Validation Error"
}));
}
public async Task <IActionResult> Post([FromBody] SignupRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new AppUser {
UserName = model.Email, FullName = model.FullName, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest(result.Errors));
}
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("userName", user.UserName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("name", user.FullName));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("email", user.Email));
await _userManager.AddClaimAsync(user, new System.Security.Claims.Claim("role", model.Role));
// Insert in entity table
//var commandText = $"INSERT {model.Role + "s"} (Id,Created,FullName) VALUES (@Id,getutcdate(),@FullName)";
//var id = new SqlParameter("@Id", user.Id);
//var name = new SqlParameter("@FullName", user.FullName);
//await _appIdentityDbContext.Database.ExecuteSqlRawAsync(commandText, id, name);
return(Ok(new SignupResponse(user, model.Role)));
}
public async Task <SignupResponse> SignupAsync(SignupRequest request)
{
var iuser = new ChatIdentityUser(request.Username);
var result = await _userManager.CreateAsync(iuser, request.Password);
if (!result.Succeeded)
{
return new SignupResponse
{
Success = false,
Detail = string.Join("\n", result.Errors.Select(e => e.Description))
}
}
;
iuser = await _userManager.FindByNameAsync(request.Username);
var user = new User(iuser.Id, iuser.UserName);
_userRepo.Add(user);
await _userRepo.SaveChangesAsync();
_eventBus.Publish(new UserSignupEvent {
UserId = user.Id
});
return(new SignupResponse
{
Success = true,
UserId = user.Id
});
}
}
public async Task <IActionResult> Signup([FromBody] SignupRequest auth)
{
User newUser = new User
{
BirthDate = auth.BirthDate,
Height = auth.Height,
Login = auth.Login,
Name = auth.Name,
Password = auth.Password,
Sex = auth.Sex,
Surname = auth.Surname,
Weight = auth.Weight
};
try
{
await _context.Users.AddAsync(newUser);
await _context.SaveChangesAsync();
}
catch (Exception)
{
return(BadRequest());
}
AuthResponse authResponse = await Authenticate(newUser);
return(Ok(authResponse));
}
public async Task <IActionResult> SinginAsync(SignupRequest request)
{
try
{
var response = new SignupResponse();
var user = userService.FindUser(request.Name, request.LastName, request.Email);
if (user != null)
{
response.Code = 202;
response.Message = "User already exist.";
return(Ok(response));
}
user = new User {
Name = request.Name, LastName = request.LastName, Email = request.Email
};
await userService.Save(user);
response.Success = true;
response.Message = "The user has successfully registered.";
response.Code = 200;
return(Ok(response));
}
catch (Exception ex)
{
_logger.LogError("An error has occurred on " + ex);
throw;
}
}
public User(SignupRequest request, string defaultProfilePicture)
{
FirstName = request.FirstName;
LastName = request.LastName;
Email = request.Email.ToLower();
Password = BCrypt.Net.BCrypt.HashPassword(request.Password);
ProfilePicture = defaultProfilePicture;
}
public string SignUp(SignupRequest request)
{
User user = new User(request, env.DefaultProfilePicture);
context.Users.Add(user);
context.SaveChanges();
return(GenerateJwt(user));
}
public async Task AddUserAsync(SignupRequest request)
{
var UserModel = new User()
{
Email = request.Email,
Name = request.Name,
Password = request.Password
};
await gateway.AddUser(UserModel);
}
public static async Task <SignupResponse> SignupAsync(SignupRequest signupRequest)
{
try
{
if (!await VerifyUsername(signupRequest.Username))
{
using (var conn = Connection)
{
conn.Open();
DynamicParameters parameters = new DynamicParameters();
parameters.Add("UserId", signupRequest.UserId);
parameters.Add("Username", signupRequest.Username);
parameters.Add("FirstName", signupRequest.FirstName);
parameters.Add("LastName", signupRequest.LastName);
parameters.Add("Email", signupRequest.EmailAddress);
parameters.Add("PasswordHash", GetHash.HashCode(signupRequest.Password));
parameters.Add("Gender", signupRequest.Gender);
parameters.Add("BirthDate", signupRequest.BirthDate);
parameters.Add("Nationality", signupRequest.Nationality);
parameters.Add("PhoneNumber", signupRequest.PhoneNumber);
parameters.Add("Location", signupRequest.Location);
parameters.Add("PrimaryGenre", signupRequest.PrimaryGenre);
parameters.Add("Biography", signupRequest.Biography);
parameters.Add("Website", signupRequest.Website);
parameters.Add("ProfileImagePath", signupRequest.ProfileImagePath);
parameters.Add("CoverImagePath", signupRequest.CoverImagePath);
parameters.Add("DateCreated", signupRequest.DateCreated);
await conn.ExecuteAsync("SignupProcedure", parameters, commandType : System.Data.CommandType.StoredProcedure);
return(new SignupResponse(true, new List <ServiceResponse>
{
new ServiceResponse("200", "Successful", null)
}));
}
}
else
{
return(new SignupResponse(false, new List <ServiceResponse>
{
new ServiceResponse("200", "Username already exists", null)
}));
}
}
catch (Exception ex)
{
return(new SignupResponse(false, new List <ServiceResponse>
{
new ServiceResponse("400", "Error Signing Up", new List <Error>()
{
new Error(ex.GetHashCode().ToString(), ex.Message)
})
}));
}
}
public async Task <APIResponse <string> > SignupRequest(SignupRequest data)
{
APIResponse <string> response = null;
var request = GenerateRequest(new Uri(Constants.BASE_URL + SigngUpEndpoint), HttpMethod.Post, null, data);
var _raw = await sender.SendAsync(request);
response = ExtractData <string>(_raw);
return(response);
}
public async Task <IActionResult> Register([FromBody] SignupRequest request)
{
request.IsManager = false;
var errors = await accountService.SignUpAsync(request);
if (errors.Count != 0)
{
return(BadRequest(errors));
}
return(Ok("Registration Successful!"));
}
public async Task <IActionResult> Signup([FromBody] SignupRequest credentials)
{
var res = await _authService.Register(credentials);
if (res.IsFailed)
{
return(BadRequest(res.Errors));
}
return(Ok(res.Successes));
}
private string SendSignupRequest(HttpClient client, string emailAddress)
{
SignupRequest request = new SignupRequest().WithEmailAddress(emailAddress);
string json = request.ToString();
HttpResponseMessage responseMessage = client.PostAsync("http://localhost:12345/api/v1/customer/signup", new JsonContent(json))
.Result;
string response = responseMessage.Content.ReadAsStringAsync()
.Result;
return(response);
}
private void MapRequestToUser(SignupRequest signupRequest, User user)
{
user.DateOfBirth = signupRequest.UserDto.DateOfBirth;
user.Email = signupRequest.UserDto.Email;
user.FirstName = signupRequest.UserDto.FirstName;
user.LastName = signupRequest.UserDto.LastName;
user.Phone = signupRequest.UserDto.Phone;
user.Gender = signupRequest.UserDto.Gender;
user.Password = signupRequest.UserDto.Password;
user.Role = false;
}
public async Task <UserProfile> CreateUserProfile(SignupRequest model, int userId, string fileName)
{
var now = DateTime.UtcNow;
UserProfile userProfile = new UserProfile
{
ProfileId = 0,
ProfileGuid = System.Guid.NewGuid(),
UserId = userId,
//FirstName = model.FirstName,
//LastName = model.LastName,
//Email = model.Email,
ProfilePhoto = fileName,
Gender = null,
City = null,
State = null,
Country = null,
ZipCode = null,
//Specialities = String.Join(",", model.Specialities),
Qualification = null,
Education = null,
IsFeature = null,
Ranked = null,
BriefBio = model.BriefBio,
InstagramProfile = model.InstagramProfile,
LinkedInProfile = model.LinkedInProfile,
FaceBookProfile = model.FaceBookProfile,
ContactNo1 = null,
ContactNo2 = null,
//AcceptedDate = null,
//AcceptedBy = null,
CreatedDate = now,
ModifiedDate = null,
CreatedBy = userId,
ModifiedBy = null,
PractitionerSince = null,
Description = null,
IsActive = false,
IsDeleted = false,
Language = null,
IsDeactivated = false,
PublicProfile = true
};
try
{
await this.authRepo.CreateUserProfileAsync(userProfile);
}
catch (Exception ex)
{
throw ex;
}
return(userProfile);
}
public async Task <IActionResult> Signup([FromForm] SignupRequest credentials)
{
var res = await _authService.Register(credentials);
if (res.IsFailed)
{
ViewData["error"] = "Signup Fail";
}
ViewData["error"] = "Signup Success";
return(View());
}
/// <summary>
/// Calls the Signup Api in authentication repo to create users in Cognito as well as Cassandra
/// </summary>
/// <param name="profileInfo">contains information needed to sign the customer up</param>
/// <returns></returns>
public Task <IRestResponse <OkResult> > SignUpCustomer(WebProfile profileInfo)
{
var signUpInfo = new SignupRequest
{
BPId = profileInfo.BPId,
Username = profileInfo.CustomerCredentials.UserName,
Password = profileInfo.CustomerCredentials.Password,
Email = profileInfo.Email
};
return(SignUpCustomer(signUpInfo));
}
public async Task <HttpResponse> Signup(SignupRequest model)
{
try
{
return(await _http.Post("/api/signup", model));
}
catch (Exception ex)
{
Console.WriteLine("Error has occurred.");
return(null);
}
}
public async Task <ActionResult> Signup(SignupRequest request)
{
var authResponse = await _accountService.RegisterAsync(request.Name, request.Email, request.Password);
if (!authResponse.Success)
{
return(BadRequest(new BusinessErrorResponse {
Errors = authResponse.ErrorMessages
}));
}
return(Ok(SuccessResponse.DefaultOkResponse()));
}
public SignupViewModel Get(SignupRequest request)
{
return new SignupViewModel();
}
public Response Signup(SignupRequest request)
{
var newUser = _repository.Select<User>()
.FirstOrDefault(u => u.Email == request.Email);
if (newUser != null)
{
throw Errors.User_EmailAlreadyExists;
}
newUser = new User
{
Email = request.Email,
Password = _crypto.ComputeHash(request.Password),
SignupDate = DateTime.UtcNow
};
_repository.Insert(newUser);
var login = CreateLogin(newUser);
object note = null;
if (!string.IsNullOrEmpty(request.UnsavedNoteContent))
{
var newNote = _repository.SaveNote(request.UnsavedNoteContent, newUser);
note = newNote.ToItem();
}
return Response.Success.WithData(new
{
Notes = new[] { note },
login.Token
});
}
