public async Task <IActionResult> Register([FromBody] RegisterModelDTO model)
{
if (ModelState.IsValid)
{
var userExists = await _userManager.FindByNameAsync(model.Email);
if (userExists != null)
{
return(BadRequest("User already exists!"));
}
ApplicationUser user = new ApplicationUser()
{
Email = model.Email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = model.Email,
};
var result = await _userManager.CreateAsync(user, model.Password);
if (!result.Succeeded)
{
return(BadRequest("User creation failed! Please check user details and try again."));
}
return(Ok("User created successfully!"));
}
return(BadRequest(ModelState));
}
public ActionResult Register()
{
ViewBag.StatesList = WebUI.Common.Common.GetStates();
RegisterModelDTO model = new RegisterModelDTO()
{
Address = new AddressModelDTO()
};
return(View(model));
}
public async Task <IActionResult> Register([FromServices] IHostingEnvironment env, RegisterModel model, IFormFile upload)
{
await SetInitialDataAsync();
if (ModelState.IsValid)
{
RegisterModelDTO rm = new RegisterModelDTO()
{
FirstName = model.FirstName,
LastName = model.LastName,
Email = model.Email,
Password = model.Password,
Role = "user"
};
if (upload != null && upload.Length > 0)
{
using (var reader = new BinaryReader(upload.OpenReadStream()))
{
rm.HasAvatar = true;
rm.Avatar = new FileDTO()
{
FileName = Path.GetFileName(upload.FileName),
ContentType = upload.ContentType,
Content = reader.ReadBytes((int)upload.Length)
};
}
}
else
{
var webRoot = env.WebRootPath;
var p = Path.Combine(webRoot, "Images/pf.jpg");
rm.Avatar = new FileDTO()
{
FileName = "pf.jpg",
ContentType = "image/jpeg",
Content = System.IO.File.ReadAllBytes(p)
};
}
OperationDetails operationDetails = await accountService.Create(rm);
if (operationDetails.Succedeed)
{
return(RedirectToAction("Login"));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
}
}
return(View(model));
}
public async Task <IActionResult> Add(RegisterModelDTO createDto)
{
var userDto = await service.CreateAsync(createDto);
if (userDto != null)
{
return(Ok());
}
else
{
return(BadRequest($"{nameof(userDto)} is null"));
}
}
public IdentityResult AddUser(RegisterModelDTO registerModelDTO)
{
var user = new User
{
UserName = registerModelDTO.UserName,
Email = registerModelDTO.Email,
};
IdentityResult result = _userManager.CreateAsync(user, registerModelDTO.Password).Result;
if (result.Succeeded)
{
_userManager.AddToRoleAsync(user, "User").Wait();
}
return(result);
}
public IActionResult Register([FromBody] RegisterModelDTO model)
{
if (_context.Users.Any(u => u.UserName == model.UserName || u.Email == model.Email))
{
return(BadRequest(new { message = "Username with that email or username already exists" }));
}
if (model.UserName == null || model.Email == null || model.Password == null)
{
return(BadRequest(new { message = "Username or password is incorrect" }));
}
var isAdded = _userService.AddUser(model);
if (!isAdded.Succeeded)
{
return(BadRequest(new { message = "Invalid Username or Password" }));
}
return(Ok());
}
public IActionResult Register([FromBody] RegisterModelDTO model)
{
// map model to entity
var user = _mapper.Map <User>(model);
if (user.Role == Role.Admin || string.IsNullOrWhiteSpace(user.Role))
{
user.Role = Role.User;
}
try
{
// create user
_userService.Create(user, model.Password);
return(Ok());
}
catch (AppException ex)
{
// return error message if there was an exception
return(BadRequest(new { message = ex.Message }));
}
}
public ActionResult Register(RegisterModelDTO registerModelDTO)
{
var culture = System.Threading.Thread.CurrentThread.CurrentCulture;
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
var responseMessage = httpClient.PostAsJsonAsync("/api/AccountAPI", registerModelDTO).Result;
//If registration worked, then need to send email confirmation
if (responseMessage.IsSuccessStatusCode)
{
var confirmationToken = JsonConvert.DeserializeObject <string>(responseMessage.Content.ReadAsStringAsync().Result);
var confURL = WebUI.Common.Common.GetDomainFromRequest(HttpContext.Request) + "/Account/RegisterConfirmation/" + confirmationToken.ToString();
MessagingService.RegistrationConfirmation(registerModelDTO.Email, registerModelDTO.FirstName, confURL);
return(RedirectToAction("RegisterStepTwo"));
}
else
{
var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage.Content.ReadAsStringAsync().Result);
ModelState.AddModelError(responseMessage.ReasonPhrase, error.Message);
}
}
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
// If we got this far, something failed, redisplay form
ViewBag.StatesList = WebUI.Common.Common.GetStates();
return(View(registerModelDTO));
}
public async Task <UserDTO> CreateAsync(RegisterModelDTO model)
{
if (string.IsNullOrWhiteSpace(model.Password))
{
throw new Exception("Password is required");
}
if (await unitOfWork.UserRepository.GetByEmailAsync(model.Email) != null)
{
throw new Exception("This email is already registered");
}
var User = new User
{
FirstName = model.FirstName,
LastName = model.LastName,
DateOfBirth = model.DateOfBirth,
Email = model.Email,
DeliveryAddress = model.DeliveryAddress,
PhoneNumber = model.PhoneNumber,
};
PasswordHash ph = await hasher.CreatePasswordHash(model.Password);
User.PasswordHash = ph.Hash;
User.PasswordSalt = ph.Salt;
User.Role = Role.User;
await unitOfWork.UserRepository.Add(User);
await basketService.Create(User.Id);
await unitOfWork.SaveChangesAsync();
return(UserConverter.Convert(User));
}
// POST api/AccountAPI
// Register a new account method
public HttpResponseMessage PostAccount(RegisterModelDTO registerModelDTO)
{
if (ModelState.IsValid)
{
//Check for valid unused email address.
if (db.UserProfiles.Where(usr => usr.Email == registerModelDTO.Email).Any())
{
return(Request.CreateErrorResponse(HttpStatusCode.Conflict, "Email address already exists"));
}
var userProfile = MapperFacade.MapperConfiguration.Map <RegisterModelDTO, UserProfile>(registerModelDTO);
userProfile.Id = Guid.NewGuid(); //Assign new ID on save.
//By default set current address to be same as home address
userProfile.CurrentAddress = new Address
{
Line1 = userProfile.Address.Line1,
Suburb = userProfile.Address.Suburb,
State = userProfile.Address.State,
Postcode = userProfile.Address.Postcode,
Line2 = userProfile.Address.Line2,
PlaceId = userProfile.Address.PlaceId,
PlaceLatitude = userProfile.Address.PlaceLatitude,
PlaceLongitude = userProfile.Address.PlaceLongitude
};
var confirmationToken = Crypto.GenerateToken();
//Create QR code for the employee
System.Drawing.Bitmap qrCodeImage = WebUI.Common.Common.GenerateQR(userProfile.Id.ToString());
using (System.IO.MemoryStream memory = new System.IO.MemoryStream())
{
qrCodeImage.Save(memory, System.Drawing.Imaging.ImageFormat.Jpeg);
userProfile.QRCode = memory.ToArray();
}
//Set up corresponding Membership entry
userProfile.Membership = new security_Membership
{
CreateDate = WebUI.Common.Common.DateTimeNowLocal(),
IsConfirmed = false,//true,
ConfirmationToken = confirmationToken,
Password = Crypto.Hash(registerModelDTO.Password),
PasswordFailuresSinceLastSuccess = 0,
PasswordChangedDate = WebUI.Common.Common.DateTimeNowLocal(),
};
userProfile.UserPreferences = new UserPreferences
{
InternalAvailableShifts = true,
ExternalShiftInfo = true,
ExternalAvailableShifts = true,
DistanceTravel = 10,
ShiftReminderLength = 24,
NotifyByApp = true,
NotifyByEmail = true,
NotifyBySMS = true,
TimeFormat24Hr = false,
MonthCalView = false,
ImageData = (registerModelDTO.ImageData == null? new Byte [0] : registerModelDTO.ImageData),
ImageType = registerModelDTO.ImageType
};
//If there is external hashed login data (OAuth)
if (!String.IsNullOrEmpty(registerModelDTO.ExternalProvider) && !String.IsNullOrEmpty(registerModelDTO.ExternalProviderUserId))
{
userProfile.OAuthMemberships.Add(new security_OAuthMembership
{
Provider = registerModelDTO.ExternalProvider,
ProviderUserId = registerModelDTO.ExternalProviderUserId
});
}
db.UserProfiles.Add(userProfile);
db.SaveChanges();
MessagingService.RegistrationAdminConfirmation(userProfile.Email, userProfile.FirstName, userProfile.LastName);
return(Request.CreateResponse(HttpStatusCode.OK, confirmationToken));
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public async Task <OperationDetails> Create(RegisterModelDTO rm)
{
VcksUser user = await userManager.FindByNameAsync(rm.Email);
if (user == null)
{
var original = new File()
{
FileName = rm.Avatar.FileName,
ContentType = rm.Avatar.ContentType,
Content = rm.Avatar.Content,
};
var square = new File()
{
FileName = rm.Avatar.FileName,
ContentType = rm.Avatar.ContentType,
Content = ImageHelpers.GetCroppedImage(rm.Avatar.Content),
};
var square_100 = new File()
{
FileName = rm.Avatar.FileName,
ContentType = rm.Avatar.ContentType,
Content = ImageHelpers.GetCroppedImage(rm.Avatar.Content, 100),
};
var square_300 = new File()
{
FileName = rm.Avatar.FileName,
ContentType = rm.Avatar.ContentType,
Content = ImageHelpers.GetCroppedImage(rm.Avatar.Content, 100),
};
var square_600 = new File()
{
FileName = rm.Avatar.FileName,
ContentType = rm.Avatar.ContentType,
Content = ImageHelpers.GetCroppedImage(rm.Avatar.Content, 100),
};
user = new VcksUser()
{
Email = rm.Email, UserName = rm.Email
};
user.Files = new List <File>()
{
original, square, square_100, square_300, square_600
};
user.Profile = new VcksUserProfile()
{
FirstName = rm.FirstName, LastName = rm.LastName, Email = rm.Email,
Avatar = new Avatar {
Default = !rm.HasAvatar, Original = original, Square = square, Square_100 = square_100, Square_300 = square_300, Square_600 = square_600
}
};
var result = await userManager.CreateAsync(user, rm.Password);
if (result.Errors.Count() > 0)
{
return(new OperationDetails(false, result.Errors.FirstOrDefault().Description, ""));
}
await userManager.AddToRoleAsync(user, rm.Role);
return(new OperationDetails(true, "Регистрация успешно пройдена", ""));
}
else
{
return(new OperationDetails(false, "Пользователь с таким логином уже существует", "Email"));
}
}
public ActionResult ExternalLoginConfirmation(RegisterModelDTO model, string profileImageUrl, string returnUrl)
{
if (User.Identity.IsAuthenticated || !OAuthWebSecurity.TryDeserializeProviderUserId(model.ExternalLoginData, out string provider, out string providerUserId))
{
return(RedirectToAction("Manage"));
}
model.ExternalProvider = provider;
model.ExternalProviderUserId = providerUserId;
//Download the image for profile pic
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(profileImageUrl);
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
// Check that the remote file was found. The ContentType
// check is performed since a request for a non-existent
// image file might be redirected to a 404-page, which would
// yield the StatusCode "OK", even though the image was not
// found.
if ((response.StatusCode == HttpStatusCode.OK ||
response.StatusCode == HttpStatusCode.Moved ||
response.StatusCode == HttpStatusCode.Redirect) &&
response.ContentType.StartsWith("image", StringComparison.OrdinalIgnoreCase))
{
Stream inputStream = null;
try
{
inputStream = response.GetResponseStream();
//get the bytes from the content stream of the file
byte[] thePictureAsBytes = new byte[response.ContentLength];
using (BinaryReader theReader = new BinaryReader(inputStream))
{
inputStream = null;
thePictureAsBytes = theReader.ReadBytes(int.Parse(response.ContentLength.ToString()));
}
model.ImageData = thePictureAsBytes;
model.ImageType = response.ContentType;
}
finally
{
if (inputStream != null)
{
inputStream.Dispose();
}
}
}
if (ModelState.IsValid)
{
// Attempt to register the user
try
{
using (HttpClientWrapper httpClient = new HttpClientWrapper(Session))
{
var responseMessage = httpClient.PostAsJsonAsync("/api/AccountAPI", model).Result;
//If registration worked, then need to send email confirmation
if (responseMessage.IsSuccessStatusCode)
{
var confirmationToken = JsonConvert.DeserializeObject <string>(responseMessage.Content.ReadAsStringAsync().Result);
var confURL = WebUI.Common.Common.GetDomainFromRequest(HttpContext.Request) + "/Account/RegisterConfirmation/" + confirmationToken.ToString();
MessagingService.RegistrationConfirmation(model.Email, model.FirstName, confURL);
return(RedirectToAction("RegisterStepTwo"));
}
else
{
var error = JsonConvert.DeserializeObject <System.Web.Http.HttpError>(responseMessage.Content.ReadAsStringAsync().Result);
ModelState.AddModelError(responseMessage.ReasonPhrase, error.Message);
}
}
}
catch (MembershipCreateUserException e)
{
ModelState.AddModelError("", ErrorCodeToString(e.StatusCode));
}
}
ViewBag.ProviderDisplayName = OAuthWebSecurity.GetOAuthClientData(provider).DisplayName;
ViewBag.ReturnUrl = returnUrl;
ViewBag.StatesList = WebUI.Common.Common.GetStates();
return(View(model));
}