public void setAllLoginData(SignUpDTO signobj)
{
try
{
SignUp obj = new SignUp();
obj.Address = signobj.Address;
obj.Email = signobj.Email;
obj.FullName = signobj.FullName;
obj.LoginType = signobj.LoginType;
obj.Password = signobj.Password;
obj.PhoneNumber = signobj.PhoneNumber;
if (obj.LoginType == "User")
{
obj.Active = true;
}
else
{
obj.Active = false;
}
_db.SignUps.Add(obj);
_db.SaveChanges();
}
catch (Exception ex)
{
throw;
}
}
private async Task <User> SignUpPostTest()
{
// Arrange
var signUpDTO = new SignUpDTO
{
Email = "*****@*****.**",
Password = "******",
Name = "User123"
};
var content = JsonConvert.SerializeObject(signUpDTO);
var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
// Act
var response = await _client.PostAsync("/api/Account/signup", stringContent);
// Assert
response.EnsureSuccessStatusCode();
var responseString = await response.Content.ReadAsStringAsync();
var user = JsonConvert.DeserializeObject <User>(responseString);
Assert.NotNull(user);
return(user);
}
public async Task <IActionResult> Signup([FromBody] SignUpDTO obj)
{
return(Ok(new
{
userID = await _context.SignUp(obj.userName, obj.password, obj.firstName, obj.lastName, obj.postalCode, obj.address, obj.cellphone, obj.email)
}));
}
public async Task <AuthResult <Token> > SignUp(SignUpDTO signUpDto)
{
if (signUpDto == null ||
string.IsNullOrEmpty(signUpDto.Username) ||
string.IsNullOrEmpty(signUpDto.Password) ||
string.IsNullOrEmpty(signUpDto.ConfirmPassword) ||
string.IsNullOrEmpty(signUpDto.FullName) ||
string.IsNullOrEmpty(signUpDto.Email) ||
signUpDto.Password != signUpDto.ConfirmPassword
)
{
return(AuthResult <Token> .UnvalidatedResult);
}
var newUser = new TUser {
Username = signUpDto.Username, Email = signUpDto.Email, FullName = signUpDto.FullName
};
var succeeded = await userManager.CreateAsync(newUser, signUpDto.Password);
if (succeeded)
{
if (newUser.Id > 0)
{
await userManager.AddToRoleAsync(newUser.Id, Roles.User);
var token = jwtManager.GenerateToken(newUser);
return(AuthResult <Token> .TokenResult(token));
}
}
return(AuthResult <Token> .UnauthorizedResult);
}
public async Task <IActionResult> SignUp([FromBody] SignUpDTO signUpDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest("Error: Model state is not valid."));
}
// Email validation
if (signUpDTO.Email == null || signUpDTO.Email == String.Empty)
{
return(BadRequest("Error: Empty Email."));
}
if (!IsValidEmail(signUpDTO.Email))
{
return(BadRequest("Error: Email is not valid."));
}
// Password validatition
if (signUpDTO.Password == null || signUpDTO.Password == String.Empty)
{
return(BadRequest("Error: Empty Password"));
}
if (signUpDTO.Password.Length < 6)
{
return(BadRequest("Error: Short Password"));
}
// Name validation
if (signUpDTO.Name == null || signUpDTO.Name == String.Empty)
{
return(BadRequest("Error: Empty Name"));
}
User existUser = await _context.GetUserByEmail(signUpDTO.Email);
if (existUser != null)
{
return(BadRequest("Error: User with this email already exist."));
}
User user = new User(signUpDTO.Name, signUpDTO.Email, signUpDTO.Password);
user.TodoLists = new List <Models.TodoList>();
_context.AddUser(user);
if (Extensions.Extensions.IsUnitTest)
{
return(Created("localhost", user));
}
// Get URL patch of object
string webRootPath = $"{this.Request.Scheme}://{this.Request.Host}{this.Request.PathBase}";
string objectLocation = webRootPath + "/" + "api/TodoLists/" + user.Id.ToString();
return(Created(objectLocation, user));
}
public async Task <IActionResult> GivenFromSiteForm([FromBody] IEnumerable <SiteFormField> fields)
{
SiteFormModel model = null;
// Convert to Model
try
{
model = fields.Adapt <SiteFormModel>(mapper);
logger.LogInformation("Получена модель с форм сайта {@Model}", model);
}
catch (Exception ex)
{
logger.LogError(ex, "Ошибка маппинга модели данных формы с сайта {@Model}", new { Params = fields });
}
// Check Model
var validateResults = new List <ValidationResult>();
var context = new ValidationContext(model);
if (!Validator.TryValidateObject(model, context, validateResults, true))
{
foreach (var error in validateResults)
{
ModelState.AddModelError("errors", error.ErrorMessage);
}
logger.LogError("Модель не прошла валидацию - {@Errors}", validateResults.Select(e => e.ErrorMessage));
return(BadRequest(ModelState));
}
SignUpDTO dto = null;
try
{
dto = model.Adapt <SignUpDTO>();
}
catch (Exception ex)
{
logger.LogError(ex, "Ошибка маппинга модели данных формы в модель DTO {@Model}", model);
}
try
{
var result = await logic.AddLead(dto);
return(Created("", result));
}
catch (Exception ex)
{
ModelState.AddModelError("errors", ex.Message);
logger.LogError(ex, "Ошибка в логике создания сделки", model);
return(BadRequest(ModelState));
}
}
public async Task <IActionResult> SignUp([FromBody] SignUpDTO signUpModel)
{
if (!ModelState.IsValid)
{
return(BadRequest("The provided user model is not valid."));
}
UserDTO user = await _accountService.Register(signUpModel);
return(CreatedAtAction(nameof(SignUp), user));
}
public Response <LoginResultDTO> SignUp(SignUpDTO request)
{
LoginResultDTO result = null;
BusinessProcess.Current.Process(p =>
{
result = IoC.Get <IAccountBusiness>().SignUp(request);
});
return(BusinessProcess.Current.ToResponse(result));
}
public async Task <IActionResult> SignUp([FromBody] SignUpDTO model)
{
var user = new User
{
Email = model.Email,
Password = model.Password
};
await UserManager.CreateAsync(user);
return(Ok());
}
public async Task <IHttpActionResult> SignUp(SignUpDTO signUpDto)
{
var result = await authService.SignUp(signUpDto);
if (result.Succeeded)
{
return(Ok(new { token = result.Data }));
}
return(BadRequest());
}
public ActionResult Edit(SignUpDTO obj, int id)
{
try
{
_userData.SaveEditDetail(obj);
return(RedirectToAction("Details", "User", new { id = id }));
}
catch
{
return(View());
}
}
public async Task <IActionResult> SignUpAsync([FromBody] SignUpDTO model)
{
UserManagerResponse response;
if (!ModelState.IsValid)
{
response = CreateResponse.Create("Some model properties are not valid", false, null);
return(BadRequest(response));
}
if (model.Password != model.ConfirmPassword)
{
response = CreateResponse.Create("Passwords do not match", false, null);
return(BadRequest(response));
}
var emailMatch = await _userManager.FindByEmailAsync(model.Email);
if (emailMatch != null)
{
response = CreateResponse.Create("Email already taken", false, null);
return(BadRequest(response));
}
var user = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
PhoneNumber = model.PhoneNumber,
UserName = model.Email,
};
var createUser = await _userManager.CreateAsync(user, model.Password);
if (createUser.Succeeded)
{
await _userManager.AddToRoleAsync(user, model.Role);
response = CreateResponse.Create("User created", true, null);
return(Ok(response));
}
var errors = createUser.Errors.Select(e => e.Description);
response = CreateResponse.Create("User was not created", false, errors);
return(BadRequest(response));
}
public async Task <IActionResult> SignupPro(SignUpDTO signUpDTO)
{
if (ModelState.IsValid)
{
var result = await _accountService.CreateUserAsync(signUpDTO);
if (!result.Succeeded)
{
foreach (var errorMessage in result.Errors)
{
ModelState.AddModelError("", errorMessage.Description);
}
return(View(signUpDTO));
}
var user = await userManager.FindByNameAsync(signUpDTO.Email);
if (signUpDTO.Role == 0)
{
var permissionLibrarian = new List <Claim>(ClaimsStore.AllClaims);
permissionLibrarian.RemoveAt(6);
permissionLibrarian.RemoveAt(4);
permissionLibrarian.RemoveAt(3);
var claim = await userManager.AddClaimsAsync(user, permissionLibrarian);
if (claim.Succeeded)
{
System.Diagnostics.Debug.WriteLine(claim);
return(RedirectToAction("Login", "Account"));
}
return(View(signUpDTO));
}
else
{
var permissionAdmin = new List <Claim>(ClaimsStore.AllClaims);
permissionAdmin.RemoveAt(5);
var claim = await userManager.AddClaimsAsync(user, permissionAdmin);
if (claim.Succeeded)
{
System.Diagnostics.Debug.WriteLine(claim);
return(RedirectToAction("Login", "Account"));
}
return(View(signUpDTO));
}
//var claim = await userManager.AddClaimAsync(user, new System.Security.Claims.Claim("Admin", "Admin"));
}
return(View(signUpDTO));
}
public IHttpActionResult SignUp(SignUpDTO request)
{
try
{
logger.InfoFormat("data SignUp controller is {0}", Newtonsoft.Json.JsonConvert.SerializeObject(request, Newtonsoft.Json.Formatting.Indented));
var result = _Service.SignUp(request);
return(Ok(result.ToJsonResult(result.Data)));
}
catch (Exception ex)
{
logger.Error("SignUp Exception is {0}", ex);
return(null);
}
}
public async Task <IActionResult> SignUp([FromBody] SignUpDTO dto)
{
var response = await _httpClient.PostAsJsonAsync(ApiRoutes.ApiSignUp, dto);
if (response.IsSuccessStatusCode)
{
var token = JsonSerializer.Deserialize <JwtTokenDTO>(await response.Content.ReadAsStringAsync(), _jsonOptions);
await UpdateServerStateAsync(accessToken : token.Token, loggedIn : true);
return(Ok());
}
return(BadRequest(await response.Content.ReadAsStringAsync()));
}
public void SaveEditDetail(SignUpDTO obj)
{
SignUp SelectUser = _db.SignUps.Where(x => x.SignUpId == obj.SignUpId).FirstOrDefault();
SelectUser.Address = obj.Address;
SelectUser.Email = obj.Email;
SelectUser.FullName = obj.FullName;
SelectUser.Password = obj.Password;
SelectUser.PhoneNumber = obj.PhoneNumber;
SelectUser.SignUpId = obj.SignUpId;
_db.SignUps.Update(SelectUser);
_db.SaveChanges();
}
public SignUpDTO GetUserDetail(int id)
{
SignUp SelectUser = _db.SignUps.Where(x => x.SignUpId == id).FirstOrDefault();
SignUpDTO GetDetail = new SignUpDTO();
GetDetail.Address = SelectUser.Address;
GetDetail.Email = SelectUser.Email;
GetDetail.FullName = SelectUser.FullName;
GetDetail.Password = SelectUser.Password;
GetDetail.PhoneNumber = SelectUser.PhoneNumber;
GetDetail.SignUpId = SelectUser.SignUpId;
return(GetDetail);
}
public async Task <IActionResult> SignUp(SignUpDTO signUpDto)
{
var result = await authService.SignUp(signUpDto);
if (result.Succeeded)
{
return(Ok(new { token = result.Data }));
}
if (result.IsModelValid)
{
return(Unauthorized());
}
return(BadRequest());
}
public void EditDetails(SignUpDTO obj)
{
SignUp signupobj = _db.SignUps.Where(x => x.SignUpId == obj.SignUpId).FirstOrDefault();
signupobj.Active = obj.Active;
signupobj.Address = obj.Address;
signupobj.Email = obj.Email;
signupobj.FullName = obj.FullName;
signupobj.LoginType = obj.LoginType;
signupobj.Password = obj.Password;
signupobj.PhoneNumber = obj.PhoneNumber;
signupobj.SignUpId = obj.SignUpId;
_db.Entry(signupobj).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_db.SaveChanges();
}
public ActionResult EditShop(SignUpDTO obj)
{
if (ModelState.IsValid)
{
try
{
_adminData.EditDetails(obj);
return(RedirectToAction("Active", "Admin"));
}
catch (Exception ex)
{
throw;
}
}
return(View());
}
public SignUpDTO GetUserDetails(int id)
{
SignUp Getobj = _db.SignUps.Where(x => x.SignUpId == id).FirstOrDefault();
SignUpDTO GetDetails = new SignUpDTO();
GetDetails.Active = Getobj.Active;
GetDetails.Address = Getobj.Address;
GetDetails.Email = Getobj.Email;
GetDetails.FullName = Getobj.FullName;
GetDetails.LoginType = Getobj.LoginType;
GetDetails.Password = Getobj.Password;
GetDetails.PhoneNumber = Getobj.PhoneNumber;
GetDetails.SignUpId = Getobj.SignUpId;
return(GetDetails);
}
public LoginResultDTO SignUp(SignUpDTO request)
{
if (string.IsNullOrEmpty(request.Email))
{
base.AddError("Please input Email");
return(null);
}
if (string.IsNullOrEmpty(request.Password))
{
base.AddError("Please input Password");
return(null);
}
var m_accountRepository = UnitOfWork.Repository <DB_TB_ACCOUNTS>();
var emailExist = m_accountRepository.GetQueryable().Where(a => a.ACC_EMAIL == request.Email).FirstOrDefault();
if (emailExist != null)
{
if (emailExist.ACC_IS_ACTIVED)
{
base.AddError("Email existed !");
return(null);
}
else
{
emailExist.ACC_IS_ACTIVED = true;
emailExist.ACC_PASSWORD = request.Password;
m_accountRepository.Update(emailExist);
}
}
else
{
var newAccount = new DB_TB_ACCOUNTS()
{
ACC_EMAIL = request.Email,
ACC_PASSWORD = request.Password,
ACC_IS_ACTIVED = true,
ACC_RESGISTRANTION_ID = request.DeviceKey,
};
m_accountRepository.Add(newAccount);
}
UnitOfWork.Commit();
return(Relogin(request.Email));
}
public SignUpDTO ShopDetailId(int id)
{
SignUpDTO ViewSignUpShopData = new SignUpDTO();
SignUp ShopSignUpData = _db.SignUps.Where(x => x.SignUpId == id).FirstOrDefault();
ViewSignUpShopData.FullName = ShopSignUpData.FullName;
ViewSignUpShopData.Active = ShopSignUpData.Active;
ViewSignUpShopData.LoginType = ShopSignUpData.LoginType;
ViewSignUpShopData.Password = ShopSignUpData.Password;
ViewSignUpShopData.SignUpId = ShopSignUpData.SignUpId;
ViewSignUpShopData.Email = ShopSignUpData.Email;
ViewSignUpShopData.PhoneNumber = ShopSignUpData.PhoneNumber;
ViewSignUpShopData.Address = ShopSignUpData.Address;
return(ViewSignUpShopData);
}
public async Task <IdentityResult> CreateUserAsync(SignUpDTO signUpDTO)
{
var user = new AppUser()
{
//mapping trực tiếp
HoNV = signUpDTO.HoNV,
TenNV = signUpDTO.TenNV,
DoBNV = signUpDTO.DoBNV,
PhoneNumber = signUpDTO.PhoneNumber,
Email = signUpDTO.Email,
UserName = signUpDTO.Email
};
var result = await _userManager.CreateAsync(user, signUpDTO.Password);
return(result);
}
public List <SignUpDTO> GetPendingShop()
{
List <SignUpDTO> PendingShopListSignUpDTO = new List <SignUpDTO>();
List <SignUp> Pendingshoplist = _db.SignUps.Where(x => x.Active == false && x.LoginType == "Shop").ToList();
foreach (var item in Pendingshoplist)
{
SignUpDTO obj = new SignUpDTO();
obj.Active = item.Active;
obj.Address = item.Address;
obj.Email = item.Email;
obj.FullName = item.FullName;
obj.LoginType = item.LoginType;
obj.Password = item.Password;
obj.PhoneNumber = item.PhoneNumber;
obj.SignUpId = item.SignUpId;
PendingShopListSignUpDTO.Add(obj);
}
return(PendingShopListSignUpDTO);
}
public List <SignUpDTO> GetUser()
{
List <SignUpDTO> UserListSignUpDTO = new List <SignUpDTO>();
List <SignUp> UserList = _db.SignUps.Where(x => x.LoginType == "User").ToList();
foreach (var item in UserList)
{
SignUpDTO obj = new SignUpDTO();
obj.Active = item.Active;
obj.Address = item.Address;
obj.Email = item.Email;
obj.FullName = item.FullName;
obj.LoginType = item.LoginType;
obj.Password = item.Password;
obj.PhoneNumber = item.PhoneNumber;
obj.SignUpId = item.SignUpId;
UserListSignUpDTO.Add(obj);
}
return(UserListSignUpDTO);
}
public List <SignUpDTO> SearchActiveShop(string searchName)
{
List <SignUpDTO> SearchActiveShopSignUpDTO = new List <SignUpDTO>();
List <SignUp> SearchActiveShopList = _db.SignUps.Where(x => x.FullName.Contains(searchName) && x.LoginType == "Shop" && x.Active == true).ToList();
foreach (var item in SearchActiveShopList)
{
SignUpDTO obj = new SignUpDTO();
obj.Active = item.Active;
obj.Address = item.Address;
obj.Email = item.Email;
obj.FullName = item.FullName;
obj.LoginType = item.LoginType;
obj.Password = item.Password;
obj.PhoneNumber = item.PhoneNumber;
obj.SignUpId = item.SignUpId;
SearchActiveShopSignUpDTO.Add(obj);
}
return(SearchActiveShopSignUpDTO);
}
public async Task <ApiResponse> Register([FromBody] SignUpDTO arg)
{
try
{
var userId = await userService.SignUpAsync(arg);
return(new ApiResponse(InfoMessages.UserCreated, userId, HttpStatusCode.OK.ToInt()));
}
catch (ValidationException ex)
{
throw new ApiException(ex.Errors, ex.StatusCode);
}
catch (CustomException ex)
{
throw new ApiException(ex, ex.StatusCode);
}
catch (Exception ex)
{
throw new ApiException(ex);
}
}
public async Task <IActionResult> Signup(SignUpDTO signUpDTO)
{
if (ModelState.IsValid)
{
var result = await _accountService.CreateUserAsync(signUpDTO);
if (!result.Succeeded)
{
foreach (var errorMessage in result.Errors)
{
ModelState.AddModelError("", errorMessage.Description);
}
return(View(signUpDTO));
}
ModelState.Clear();
return(RedirectToAction("Login", "Account"));
}
return(View(signUpDTO));
}
public async Task <AuthResult <Token> > SignUp(SignUpDTO signUpDto)
{
try
{
if (signUpDto == null ||
string.IsNullOrEmpty(signUpDto.Email) ||
string.IsNullOrEmpty(signUpDto.Password) ||
string.IsNullOrEmpty(signUpDto.ConfirmPassword) ||
string.IsNullOrEmpty(signUpDto.FirstName) ||
string.IsNullOrEmpty(signUpDto.LastName) ||
signUpDto.Password != signUpDto.ConfirmPassword
)
{
return(AuthResult <Token> .UnvalidatedResult);
}
var newUser = new TUser
{
SecondName = signUpDto.LastName, FirstName = signUpDto.FirstName, Email = signUpDto.Email, UserName = signUpDto.Email
};
var result = await userManager.CreateAsync(newUser, signUpDto.Password);
if (result.Succeeded)
{
//await userManager.AddToRoleAsync(newUser, "User");
var token = jwtManager.GenerateToken(newUser);
return(AuthResult <Token> .TokenResult(token));
}
return(AuthResult <Token> .UnauthorizedResult);
}
catch (Exception e)
{
Console.Write(e.Message);
throw;
}
}
