public Task <object> RegesterRaw(RegisterDto registerDto)
{
return(Task.FromResult(new object()));
}
private async Task <Activity> HandleSystemMessage(Activity message)
{
if (message.ServiceUrl == "https://directline.botframework.com/")
{
string input = "hello world, direct line";
Activity userMessage = new Activity
{
From = new ChannelAccount(),
Text = input,
Type = Connector.DirectLine.ActivityTypes.Message,
ChannelId = "8c8e13d4-fb54-4777-aea2-7b6ace72bd92"
};
//await Conversation.SendAsync(userMessage, () => new EchoDialog());
}
else if (message.Type == ActivityTypes.DeleteUserData)
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (message.Type == ActivityTypes.ConversationUpdate && message.MembersAdded != null && message.MembersAdded.Any(x => x.Name == null))
{
// Handle conversation state changes, like members being added and removed
// Use Activity.MembersAdded and Activity.MembersRemoved and Activity.Action for info
// Not available in all channels
// Fetch the members in the current conversation
//var connector = new ConnectorClient(new Uri("http://hack005.ngrok.io"));
var connector = new ConnectorClient(new Uri(message.ServiceUrl));
var members = await connector.Conversations.GetConversationMembersAsync(message.Conversation.Id);
var teamID = message.Conversation.Id;
var registerDto = new RegisterDto()
{
TeamId = teamID,
Members = members.Select(x => new TeamMemberDto()
{
Id = x.Properties.GetValue("objectId").ToString(),
Name = x.Name
}).ToList()
};
using (var httpclient = new HttpClient())
{
var response = await httpclient.PostAsJsonAsync("https://msopenhackeu.azurewebsites.net/api/trivia/register", registerDto);
}
Activity reply = message.CreateReply($"Welcome");
var msgToUpdate = await connector.Conversations.ReplyToActivityAsync(reply);
}
else if (message.Type == ActivityTypes.ContactRelationUpdate)
{
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
}
else if (message.Type == ActivityTypes.Typing)
{
// Handle knowing tha the user is typing
}
else if (message.Type == ActivityTypes.Ping)
{
}
return(null);
}
public async Task <ActionResult <UserDto> > RegisterUser(RegisterDto user) => await _iGenericRepository.InsertAsync(user);
public async Task <JsonResult> Register(RegisterDto dto)
{
var resultTask = _userSvc.RegisterAsync(dto);
return(Json(await resultTask));
}
public string RegisterRequest(RegisterDto registerDto)
{
throw new NotImplementedException();
}
public async Task Register(RegisterDto request)
{
string path = $"{getPath()}/register";
await path.PostJsonAsync(request);
}
public async Task <ApiResponse> Register(RegisterDto parameters)
{
try
{
if (!ModelState.IsValid)
{
return(new ApiResponse(400, "User Model is Invalid"));
}
var user = new ApplicationUser
{
UserName = parameters.UserName,
Email = parameters.Email
};
user.UserName = parameters.UserName;
var result = await _userManager.CreateAsync(user, parameters.Password);
if (!result.Succeeded)
{
return(new ApiResponse(400, "Register User Failed: " + result.Errors.FirstOrDefault()?.Description));
}
else
{
var claimsResult = _userManager.AddClaimsAsync(user, new Claim[] {
new Claim(Policies.IsUser, ""),
new Claim(JwtClaimTypes.Name, parameters.UserName),
new Claim(JwtClaimTypes.Email, parameters.Email),
new Claim(JwtClaimTypes.EmailVerified, "false", ClaimValueTypes.Boolean)
}).Result;
}
//Role - Here we tie the new user to the "User" role
await _userManager.AddToRoleAsync(user, "User");
if (Convert.ToBoolean(_configuration["BlazorBoilerplate:RequireConfirmedEmail"] ?? "false"))
{
#region New User Confirmation Email
try
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = string.Format("{0}/Account/ConfirmEmail/{1}?token={2}", _configuration["BlazorBoilerplate:ApplicationUrl"], user.Id, token);
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email = EmailTemplates.BuildNewUserConfirmationEmail(email, user.UserName, user.Email, callbackUrl, user.Id.ToString(), token); //Replace First UserName with Name if you want to add name to Registration Form
_logger.LogInformation("New user registered: {0}", user);
await _emailService.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
#endregion
return(new ApiResponse(200, "Register User Success"));
}
#region New User Email
try
{
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email = EmailTemplates.BuildNewUserEmail(email, user.UserName, user.Email, parameters.Password); //Replace First UserName with Name if you want to add name to Registration Form
_logger.LogInformation("New user registered: {0}", user);
await _emailService.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
#endregion
return(await Login(new LoginDto
{
UserName = parameters.UserName,
Password = parameters.Password
}));
}
catch (Exception ex)
{
_logger.LogError("Register User Failed: {0}", ex.Message);
return(new ApiResponse(400, "Register User Failed"));
}
}
public Task <OperationResult <Unit> > RegisterOrganizationOwner(RegisterDto registerDto)
{
return(authService.RegisterOrganizationOwner(registerDto.Email, registerDto.Username, registerDto.Password));
}
public Task <OperationResult <Unit> > RegisterRegularUser(string code, RegisterDto registerDto)
{
return(authService.RegisterUser(code, registerDto.Email, registerDto.Username, registerDto.Password));
}
public async Task <IActionResult> Register(RegisterDto register)
{
register.Username = register.Username.ToLower();
List <string> exist = await _repo.UserExists(register.Username, register.Email, register.Phone);
if (exist.Count > 0)
{
return(BadRequest(String.Join(", ", exist.ToArray()) + " already exists"));
}
User new_user = new User()
{
Username = register.Username,
Phone = register.Phone,
Email = register.Email,
Name = register.Name,
Surname = register.Surname,
Registered = DateTime.Now,
Confirmed = false,
RoleID = 1,
Password = _repo.HashPassword(register.Password)
};
await _context.Users.AddAsync(new_user);
await _context.SaveChangesAsync();
if (register.isPremium)
{
Subscription s = new Subscription {
StartDate = DateTime.Now, EndDate = DateTime.Now.AddDays(7), User = new_user, RenewalType = register.RenewalType
};
switch (register.RenewalType)
{
case 1:
s.EndDate = DateTime.Now.AddDays(7);
break;
case 2:
s.EndDate = DateTime.Now.AddMonths(1);
break;
case 3:
s.EndDate = DateTime.Now.AddMonths(3);
break;
case 4:
s.EndDate = DateTime.Now.AddYears(1);
break;
default:
break;
}
await _context.Subscriptions.AddAsync(s);
await _context.SaveChangesAsync();
}
var code = RandomString(25);
await _context.Confirmations.AddAsync(new Confirmation { Code = code, Expiration = DateTime.Now.AddDays(1), Type = 1, User = new_user });
var url = String.Format("https://testurlforpasswordreset.com/confirm/{0}/{1}", code, new_user.Email);
SendMail(new_user.Email, "Qeydiyyat", new_user.Name, new EmailGeneratorDto {
Button = "Hesabımı aktivləşdir", Header = "Qeydiyyatınız uğurludur!", Text = "Hesabınızı aktivləşdirmək üçün aşağıdakı keçidə klikləyin.", Url = url
});
return(Ok("Successfully created"));
}
public async Task <IActionResult> Register(RegisterDto registerDto)
{
return(this.GenerateResponse(await _authService.Register(registerDto)));
}
public async Task <IActionResult> Register([FromBody] RegisterDto model)
{
return(Ok(await _authApplicationService.PerformRegistration(model)));
}
public bool Register(RegisterDto registerDto)
{
return(_userRepository.Register(registerDto));
}
public bool Register(RegisterDto user)
{
return(_accountRepo.Register(user));
}
public GenericOperationResult <bool> RegisterUser(RegisterDto user)
{
var registerValidator = new RegisterValidator();
var res = registerValidator.Validate(user);
var result = new GenericOperationResult <bool>();
if (res.IsValid)
{
try
{
if (!unitOfWork.Authentication.UserExists(user.UserName, user.PhoneNumber))
{
var registerUser = MapUser(user);
User registeredUser = new User();
registeredUser = unitOfWork.Authentication.Register(registerUser, user.Password);
VerifyUserModel model = new VerifyUserModel
{
User = registeredUser,
Password = user.Password
};
if (registeredUser != null)
{
httpContext.HttpContext.Session.SetString(user.PhoneNumber, JsonConvert.SerializeObject(model));
MessageModel messageModel = new MessageModel
{
From = new PhoneNumber("+12284564506"),
//Twilio license
To = new PhoneNumber("+201121736295"),
Body = "Verification code of your account is: 0000"
};
var message = SendMessage(messageModel);
//ObjectCache cache = MemoryCache.Default;
//cache.Add("CachedValueKey", "Some value to cache", new CacheItemPolicy());
//cache.Add(user.PhoneNumber, user.Password, new CacheItemPolicy());
result.Status = OperationResultStatusEnum.Succeeded;
result.Messages.Add("Suceeded");
return(result);
}
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("Failed");
return(result);
}
else
{
result.Status = OperationResultStatusEnum.Failed;
result.Messages.Add("User already exists");
return(result);
}
}
catch (ArgumentNullException e)
{
throw new BusinessException("Argument is null ", e);
}
catch (SqlException e)
{
throw new BusinessException("Database error ", e);
}
catch (NullReferenceException e)
{
throw new BusinessException("Object Refrence is null ", e);
}
catch (Exception e)
{
throw new BusinessException("error Occured ", e);
}
}
result.Messages = res.Errors.Select(e => e.ErrorMessage).ToList();
result.Status = OperationResultStatusEnum.Validation;
return(result);
}
public async Task <HttpResponseMessage> Register(RegisterDto registerDto)
{
string registerUrl = $"{baseUrl}register";
return(await customHttpClient.PostAsync(registerUrl, registerDto));
}
public async Task <IActionResult> Register([FromBody] RegisterDto registerDto) => Ok(await _userService.Register(registerDto));
public async Task <ApiResponseDto> Register(RegisterDto registerParameters)
{
return(await _httpClient.PostJsonAsync <ApiResponseDto>("api/Account/Register", registerParameters));
}
public async Task <ActionResult <string> > Register(RegisterDto dto) => Result(await AuthManager.RegisterAsync(dto));
public async Task <ApiResponse> Create(RegisterDto parameters)
{
try
{
var user = new ApplicationUser
{
UserName = parameters.UserName,
Email = parameters.Email
};
user.UserName = parameters.UserName;
var result = await _userManager.CreateAsync(user, parameters.Password);
if (!result.Succeeded)
{
return(new ApiResponse(Status400BadRequest, "Register User Failed: " + string.Join(",", result.Errors.Select(i => i.Description))));
}
else
{
var claimsResult = _userManager.AddClaimsAsync(user, new Claim[] {
new Claim(Policies.IsUser, string.Empty),
new Claim(JwtClaimTypes.Name, parameters.UserName),
new Claim(JwtClaimTypes.Email, parameters.Email),
new Claim(JwtClaimTypes.EmailVerified, "false", ClaimValueTypes.Boolean)
}).Result;
}
//Role - Here we tie the new user to the "User" role
await _userManager.AddToRoleAsync(user, "User");
if (Convert.ToBoolean(_configuration["SpotToSpotMuzik:RequireConfirmedEmail"] ?? "false"))
{
try
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
var token = await _userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = string.Format("{0}/Account/ConfirmEmail/{1}?token={2}", _configuration["SpotToSpotMuzik:ApplicationUrl"], user.Id, token);
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email = EmailTemplates.BuildNewUserConfirmationEmail(email, user.UserName, user.Email, callbackUrl, user.Id.ToString(), token); //Replace First UserName with Name if you want to add name to Registration Form
_logger.LogInformation("New user created: {0}", user);
await _emailManager.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
return(new ApiResponse(Status200OK, "Create User Success"));
}
try
{
var email = new EmailMessageDto();
email.ToAddresses.Add(new EmailAddressDto(user.Email, user.Email));
email.BuildNewUserEmail(user.FullName, user.UserName, user.Email, parameters.Password);
_logger.LogInformation("New user created: {0}", user);
await _emailManager.SendEmailAsync(email);
}
catch (Exception ex)
{
_logger.LogInformation("New user email failed: {0}", ex.Message);
}
var userInfo = new UserInfoDto
{
UserId = user.Id,
IsAuthenticated = false,
UserName = user.UserName,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
//ExposedClaims = user.Claims.ToDictionary(c => c.Type, c => c.Value),
Roles = new List <string> {
"User"
}
};
return(new ApiResponse(Status200OK, "Created New User", userInfo));
}
catch (Exception ex)
{
_logger.LogError($"Create User Failed: {ex.Message}");
return(new ApiResponse(Status400BadRequest, "Create User Failed"));
}
}
public async Task Register(RegisterDto model)
{
await _integrationManager.Post <RegisterDto, object>("/Account/Register", model);
}
public async Task Given_valid_register_dto_Register_should_return_Ok_response(RegisterDto registerDto)
{
// Given
var response = new HttpResponseMessage(HttpStatusCode.OK);
GetMock <IAccountApi>().Setup(x => x.Register(registerDto)).Returns(Task.FromResult(response));
// when
var result = await ClassUnderTest.Register(registerDto);
// then
Assert.That(result.StatusCode, Is.EqualTo(HttpStatusCode.OK));
}
public void Post([FromBody] RegisterDto dto, [FromServices] IRegisterUserCommand command)
{
_executor.ExecuteCommand(command, dto);
}
public async Task <object> Register([FromBody] RegisterDto model)
{
var reponseModel = new RegisterDto();
reponseModel.Email = model.Email;
var InputEmail = model.Email;
var code = "";
if (Util.IsPhoneNumber(model.Email))
{
InputEmail = $"{model.Email}@hanoma.vn";
}
//Check input Email Pass
if (String.IsNullOrEmpty(model.Email) || String.IsNullOrEmpty(model.Password))
{
reponseModel.ErrorCode = "ACC006";
reponseModel.Message = ConstMessage.GetMsgConst("ACC006");
return(reponseModel);
}
//Check exists User with not confirm
if (_repositoryWrapper.AspNetUsers.CheckExistsUserNotConfirmed(model.Email))
{
//reponseModel.ErrorCode = "ACC013";
//reponseModel.Message = ConstMessage.GetMsgConst("ACC013");
//SentCode if not confirm
var user = new ApplicationUser
{
UserName = model.Email,
Email = InputEmail
};
//if (!Util.IsPhoneNumber(model.Email))
//{
// code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.Email);
//}
//else
//{
// code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.Email);
//}
//await SendCode(Util.IsPhoneNumber(model.Email) ? "Phone" : "Email", model.Email, code);
reponseModel.ErrorCode = "00";
reponseModel.Message = "Đã gửi code xác nhận";
return(reponseModel);
}
//Check exists User
if (_repositoryWrapper.AspNetUsers.CheckExistsUser(model.Email))
{
reponseModel.ErrorCode = "ACC009";
reponseModel.Message = ConstMessage.GetMsgConst("ACC009");
return(reponseModel);
}
if (!Util.IsEmailOrPhone(model.Email))
{
_logger.LogError($"[AccountController] {model.Email}" + ConstMessage.GetMsgConst("ACC010"));
reponseModel.ErrorCode = "ACC010";
reponseModel.Message = ConstMessage.GetMsgConst("ACC010");
return(reponseModel);
}
else
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = InputEmail
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
//Set EnableTwoFactorAuthentication
//await _userManager.SetTwoFactorEnabledAsync(user, true);
//Update Account Code
var userRegister = _repositoryWrapper.AspNetUsers.FirstOrDefault(x => x.Id.Equals(user.Id));
userRegister.AccountCode = $"84{model.Email}";
_hanomaContext.SaveChanges();
_logger.LogInfo($"[AccountController] Đăng ký thành công {model.Email} ");
try
{
//Create User Profile
_repositoryWrapper.AspNetUsers.CreateNewUserProfile(user.Id, user.Email, null, 1);
}
catch (Exception ex)
{
_logger.LogError($"[Account Controller] {ex}");
}
if (!Util.IsPhoneNumber(model.Email))
{
code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.Email);
}
else
{
code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.Email);
}
//Thay đổi luồng verify số điện thoại trước
//await SendCode(Util.IsPhoneNumber(model.Email) ? "Phone" : "Email", model.Email, code);
reponseModel.Email = model.Email;
reponseModel.Password = model.Password;
reponseModel.ErrorCode = "00";
reponseModel.Message = "Đăng ký thành công";
return(reponseModel);
}
}
throw new ApplicationException("UNKNOWN_ERROR");
}
public async Task <IActionResult> Register([FromBody] RegisterDto model)
{
var responseModel = await _identityService.RegisterAsync(model);
return(new CustomActionResult(responseModel));
}
public Task <HttpResponseMessage> Register(RegisterDto registerDto)
{
return(Task.FromResult(new HttpResponseMessage()));
}
public bool Register(RegisterDto register)
{
return(userService.Register(register));
}
private User MapUser(RegisterDto registerUser)
{
var user = mapper.Map <User>(registerUser);
return(user);
}
public async Task <ActionResult <UserDto> > PutUser(int id, [FromBody] RegisterDto user) => await _iGenericRepository.UpdateAsync(id, user);
public async Task <ActionResult <UserDto> > Register(RegisterDto registerDto)
{
return(await _accountService.Register(registerDto));
}
