public ActionResult MyProfile(UserSignUpModel userSignUpModel)
{
if (!ModelState.IsValid)
{
return(View(userSignUpModel));
}
else
{
UserSignUpDto userSignUpDto = new UserSignUpDto();
userSignUpDto.UserId = userSignUpModel.UserId;
userSignUpDto.Name = userSignUpModel.Name;
userSignUpDto.EmailId = userSignUpModel.EmailId;
userSignUpDto.Password = userSignUpModel.Password;
userSignUpDto.MobileNo = userSignUpModel.MobileNo;
userSignUpDto.Gender = userSignUpModel.Gender;
int i = userSignUpDal.SaveUserDetails(userSignUpDto);
if (i > 0)
{
ViewBag.successText = "Successfully Profile Updated.";
}
else
{
ViewBag.failureText = "Your Profile Has Not Updated. Please Try after Sometime ";
}
List <ItemGroupDto> lstItemGroupDto = itemGroupDal.GetAndEditItemGroup(0, 1);
ViewBag.ItemGroups = lstItemGroupDto;
return(View());
}
}
public async Task <ResponseModel <UserViewModel> > UpdateAsync(UserSignUpModel entity, SecurityModel securityModel)
{
ResponseModel <UserViewModel> response = new ResponseModel <UserViewModel>();
try
{
var user = await _dynamodbUserContext.GetByIdAsync(entity.Id);
user.FirstName = entity.FirstName;
user.LastName = entity.LastName;
user.MobileNumber = entity.MobileNumber;
user.Suburb = entity.Suburb;
user.State = entity.State;
user.PostCode = entity.PostCode;
user.Country = entity.Country;
user.UpdatedBy = securityModel.EmailAddress;
user.UpdatedOn = DateTime.UtcNow;
await _dynamodbUserContext.SaveAsync(user);
response.Entity = _mapper.Map <UserViewModel>(user);
response.Status = true;
response.ReturnMessage.Add("User has been updated sucessfully.");
}
catch (Exception ex)
{
response.Status = false;
response.ReturnMessage.Add(ex.Message);
throw new Exception($"Amazon error in table operation! Error: {ex}");
}
return(response);
}
public JsonResult SaveProfileInfo(UserSignUpModel user)
{
var status = false;
using (ApplicationDbContext dc = new ApplicationDbContext())
{
dc.Configuration.ProxyCreationEnabled = false;
var Id = User.Identity.GetUserId();
if (Id != null)
{
var v = dc.Userss.Where(a => a.Id == Id).FirstOrDefault();
if (v != null)
{
v.FirstName = user.FirstName;
v.LastName = user.LastName;
v.BirthDate = user.BirthDate;
//v.Image = user.Image;
}
}
else
{
dc.Userss.Add(user);
}
dc.SaveChanges();
status = true;
}
return(new JsonResult {
Data = new { status = status }
});
}
public async Task <UserModel> CreateStudentAsync(UserSignUpModel studentModel)
{
var isUserExists = await _context.Users.Where(u => u.Email == studentModel.Email)
.SingleOrDefaultAsync();
if (isUserExists != null)
{
return(null);
}
var user = _mapper.Map <UserSignUpModel, User>(studentModel, cfg =>
cfg.AfterMap((src, dest) =>
{
dest.RegisteredDate = DateTime.Now;
dest.RoleId = (int)RoleType.Student;
}));
if (user != null)
{
_context.Users.Add(user);
await _context.SaveChangesAsync();
return(_mapper.Map <UserModel>(user));
}
return(null);
}
public async Task <bool> SignUp(UserSignUpModel model)
{
var registrationDate = DateTimeOffset.Now;
var containerName = new string(model.UserName.Where(char.IsLetterOrDigit).ToArray()).ToLower();
var user = new User
{
UserName = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
DateOfBirth = model.DateOfBirth,
PhoneNumber = model.PhoneNumber,
DateOfLastLogin = registrationDate,
DateOfRegistration = registrationDate,
Gender = model.Gender,
Email = model.Email,
ContainerId = containerName + Guid.NewGuid().ToString()
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await SignInManager.SignInAsync(user, false);
return(true);
}
else
{
return(false);
}
}
public async Task <ActionResult> SignUp(UserSignUpModel userView)
{
var user = new User(userView);
IdentityResult result = await userManager.CreateAsync(user, userView.Password);
if (result.Succeeded)
{
await userManager.AddToRoleAsync(user, userView.Role);
string token = await userManager.GenerateEmailConfirmationTokenAsync(user);
string callbackUrl = Url.Action(
"ConfirmEmail",
"Account",
new { userId = user.Id, token },
protocol: HttpContext.Request.Scheme
);
try
{
EmailService emailService = new EmailService();
await emailService.SendEmailAsync(
user.Email,
"Email confirmation",
$"<a href='{callbackUrl}'>Confirm your email</a>"
);
}
catch (OperationCanceledException ex)
{
logger.LogError(ex.Message);
}
logger.LogInformation($"Account/SignUp: {user.Email} confirmation link {callbackUrl}");
return(Ok());
}
return(UnprocessableEntity(result));
}
public async Task <UserModel> SignUpAsync(UserSignUpModel userSignUpModel)
{
var isUserExists = await _context.Users.Where(u => u.Email == userSignUpModel.Email)
.SingleOrDefaultAsync();
if (isUserExists != null)
{
return(null);
}
var user = _mapper.Map <UserSignUpModel, User>(userSignUpModel, cfg =>
cfg.AfterMap((src, dest) =>
{
dest.RegisteredDate = DateTime.Now;
dest.RoleId = (int)RoleType.Student;
}));
if (user != null)
{
_context.Users.Add(user);
await _context.SaveChangesAsync();
var userValidation = _mapper.Map <UserModel>(user);
string callBackUrl = await _mailService.GenerateConfirmationLinkAsync(userValidation);
await _mailService.SendConfirmationLinkAsync(userValidation.Email,
$"Confirm registration following the link: <a href='{callBackUrl}'>Confirm email NOW</a>");
return(userValidation);
}
return(null);
}
public async Task <IActionResult> KayitOl(UserSignUpModel model)
{
if (ModelState.IsValid)
{
AppUser user = new AppUser
{
Email = model.Email,
Name = model.Name,
SurName = model.SurName,
UserName = model.UserName
};
//burada test etmek için ctor oluşturuyoruz.
var result = await _userManager.CreateAsync(user, model.Password);//passwordu burada vermeliyiz. bizim için şifrelemeyi kendi yapıcak.
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
return(View(model));
}
// POST api/<controller>
public UserSignUpModel Post(UserSignUpModel user)
{
_loginHelper = new LoginHelper();
var createdUser = _loginHelper.SignUpUser(user);
var userRegType = _loginHelper.SendRegisterUserConfirmation(createdUser);
switch (userRegType)
{
case ApplicationMessages.UserRegisterationType.EMAILWITHERROR:
// return Json(new { messagetype = ApplicationMessages.UserRegisterationType.EMAILWITHERROR, message = "Unable to deliver the email to your mailbox. Please contact administrator (call helpline) to know your OTP." }, JsonRequestBehavior.AllowGet);
case ApplicationMessages.UserRegisterationType.EMAIL:
return(new UserSignUpModel()
{
Name = user.Name, UserID = createdUser.UserID, Message = "user_created", user = user.user
});
case ApplicationMessages.UserRegisterationType.MOBILE:
//return Json(new { messagetype = ApplicationMessages.UserRegisterationType.MOBILE, message = "success" }, JsonRequestBehavior.AllowGet);
case ApplicationMessages.UserRegisterationType.MOBILEWITHERROR:
//return Json(new { messagetype = ApplicationMessages.UserRegisterationType.MOBILEWITHERROR, message = "success" }, JsonRequestBehavior.AllowGet);
case ApplicationMessages.UserRegisterationType.USEREXIST:
return(new UserSignUpModel()
{
Message = "user_exist"
});
}
return(null);
}
public ActionResult SignUp()
{
if (ApplicationHelper.LoggedUser != null)
{
return(RedirectToAction("Index", "Home"));
}
var model = new UserSignUpModel();
return(View(model));
}
public int SignUp([System.Web.Http.FromBody] UserSignUpModel model)
{
int ret = -1;
User u = null;
if (model != null && !string.IsNullOrEmpty(model.Email) && !string.IsNullOrEmpty(model.Password))
{
using (var repo = Resolver.Resolve <IUserRepository>())
{
// External Id matches the user's email (otherwise we might select the wrong user).
u = repo.SelectByExternalId(model.Email);
if (u != null)
{
throw new System.Web.HttpException((int)System.Net.HttpStatusCode.Conflict, "Conflict");
}
else
{
u = new User();
u.Created = System.DateTime.UtcNow;
u.Name = model.Name ?? model.Email;
u.ExternalId = model.Email;
u.Email = model.Email;
u.Subscription = Resolver.Resolve <Payments.IPaymentProcessor>().CreateDefaultSubscription(model.SignUpSubscriptionType);
u.Password = new UserPasswordDetails();
u.Password.Hash = Crypto.GetHash(model.Password);
u.Password.ConfirmToken = Crypto.GetHash(Guid.NewGuid().ToString());
u = repo.Update(u);
ret = u.Id;
MessageQueueManager.Current.GetQueue(MessageQueueType.Email).AddMessages(new Message[] { new Message()
{
Id = Guid.NewGuid().ToString(),
Subject = Ifly.Resources.Frontpage.Email_ValidateEmail_Subject,
Body = new GenericMessageBody
(
new Tuple <string, string>("Recipient", model.Email),
new Tuple <string, string>("Body", string.Format(Ifly.Resources.Frontpage.Email_ValidateEmail_Body, string.Format("{0}://{1}/validate-email?email={2}&token={3}",
Request.Url.Scheme, Request.Url.Authority, Server.UrlEncode(model.Email), u.Password.ConfirmToken)))
).ToString()
} });
}
}
}
else
{
throw new System.Web.HttpException((int)System.Net.HttpStatusCode.BadRequest, "Bad request");
}
return(ret);
}
public async Task <IdentityResult> RegisterUser(UserSignUpModel userModel)
{
IdentityUser user = new IdentityUser
{
UserName = userModel.UserName
};
var result = await _userManager.CreateAsync(user, userModel.Password);
return(result);
}
// PUT api/<controller>/5
public bool Put(UserSignUpModel user)
{
_loginHelper = new LoginHelper();
try
{
return(_loginHelper.VerifyOtp(user, true));
}
catch (Exception ex) {
return(false);
}
}
// POST api/<controller>
public bool Post(UserSignUpModel user)
{
try
{
_loginHelper = new LoginHelper();
return(_loginHelper.VerfiyOtpForgotPassword(user));
}
catch (Exception ex) {
return(false);
}
}
// PUT api/<controller>/5
public bool Put(UserSignUpModel user)
{
try
{
_loginHelper = new LoginHelper();
return(_loginHelper.ChangePassword(user));
}
catch (Exception ex) {
return(false);
}
}
public IActionResult Put([FromServices] IAuthenticationService authService, [FromBody] UserSignUpModel signUpModel)
{
try
{
authService.SignUp(signUpModel);
return(Ok());
}
catch
{
return(BadRequest());
}
}
public async Task <IActionResult> CreateStudent(UserSignUpModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { title = "Model is not valid" }));
}
var student = await _adminService.CreateStudentAsync(userModel);
if (student != null)
{
return(Ok(student));
}
return(BadRequest(new { title = "Couldnt create student" }));
}
/// <summary>
/// Converts UserSignUpModel to UserSignUp.
/// </summary>
/// <param name="uSUModel"></param>
/// <returns></returns>
public UserSignUp ConvertFromUserSignUpModelToSignUp(UserSignUpModel uSUModel)
{
UserSignUp uSU = new UserSignUp
{
UserName = uSUModel.UserName,
Email = uSUModel.Email,
Phone = uSUModel.Phone,
ZipCode = uSUModel.ZipCode,
Region = uSUModel.Region,
Password = uSUModel.Password
};
return(uSU);
}
public FileContentResult RenderImage(string userId)
{
object profileId = Request.RequestContext.RouteData.Values["Id"];
UserSignUpModel userModel = null;
if (!string.IsNullOrWhiteSpace(userId))
{
userModel = userRepository.Get(userId);
}
else
{
userModel = userRepository.Get((string)profileId);
}
return(new FileContentResult(userModel.Image, "image/jpeg"));
}
public bool VerfiyOtpForgotPassword(UserSignUpModel model)
{
_context = new karrykartEntities();
var otp = _context.OTPHolders.Where(x => x.OTPAssignedTo == model.user && x.OTPValue == model.Otp).FirstOrDefault();
if (otp != null)
{
CommonHelper.RemoveOTP(model.user);
_context = null;
return(true);
}
return(false);
}
public bool ChangePassword(UserSignUpModel userModel)
{
using (_context = new karrykartEntities()) {
var user = _context.Users.Where(u => u.EmailAddress == userModel.user).FirstOrDefault();
if (user != null)
{
user.Password = EncryptionManager.ConvertToUnSecureString(EncryptionManager.EncryptData(userModel.pwd));
user.LastUpdated = DateTime.Now;
_context.Entry(user).State = System.Data.Entity.EntityState.Modified;
_context.SaveChanges();
return(true);
}
return(false);
}
}
public ActionResult SignUp(UserSignUpModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
_usersRepo.SaveSignUpUser(model);
//autentifica userul
this.Authenticate(new UserAuthenticationModel {
Email = model.Email, Password = model.Password
});
return(RedirectToAction("Index", "Home"));
}
}
public static int SignUp(UserSignUpModel model)
{
using (var context = new MakeMyCodeEntities())
{
context.Users.Add(new Users()
{
FirstName = model.firstName,
LastName = model.lastName,
Email = model.email,
Password = model.password,
IsActive = 1
});
return(0);
//return context.SaveChanges();
}
}
public void SaveSignUpUser(UserSignUpModel model)
{
var pas = EncryptPassword(model.Password);
_db.Users.Add(new User
{
IsDeleted = false,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Password = pas,
PhoneNumber = model.PhoneNumber,
RoleId = (int)Roles.Utilizator
});
_db.SaveChanges();
}
public ActionResult Index()
{
string currentUserId = User.Identity.GetUserId();
object profileId = Request.RequestContext.RouteData.Values["Id"];
UserSignUpModel user = null;
if (!string.IsNullOrWhiteSpace((string)profileId))
{
var allFriends = friendRepository.GetAllFriendsForUser((string)profileId);
user = userRepository.Get((string)profileId);
ViewBag.ProfileId = (string)profileId;
ViewBag.CurrentUserId = currentUserId;
ViewBag.Request = requestRepository.PendingRequest(currentUserId, (string)profileId);
ViewBag.Friendship = friendRepository.AlreadyFriends(currentUserId, (string)profileId);
if (allFriends.Count > 0)
{
ViewBag.AllFriends = allFriends;
ViewBag.hasFriends = true;
}
else
{
ViewBag.hasFriends = false;
}
}
else
{
var allFriends = friendRepository.GetAllFriendsForUser(currentUserId);
user = userRepository.Get(currentUserId);
ViewBag.ProfileId = currentUserId;
ViewBag.CurrentUserId = currentUserId;
ViewBag.Request = requestRepository.PendingRequest(currentUserId, (string)profileId);
ViewBag.Friendship = friendRepository.AlreadyFriends(currentUserId, (string)profileId);
if (allFriends.Count > 0)
{
ViewBag.AllFriends = allFriends;
ViewBag.hasFriends = true;
}
else
{
ViewBag.hasFriends = false;
}
}
return(View(user));
}
public IHttpActionResult SignUp(UserSignUpModel usermodel)
{
try
{
User objUser = new DbAccess.User();
int UserSignUpresult = DbAccess.User.UserSignUp(usermodel.Firstname, usermodel.Lastname, usermodel.Email, usermodel.Password, usermodel.Residency, usermodel.city);
return(Ok(new ResponseModel
{
status = UserSignUpresult.ToString()
}));
}
catch (Exception e)
{
return(new ErrorResult("Error in request", HttpStatusCode.InternalServerError));
}
}
public async Task <IHttpActionResult> Register(UserSignUpModel userModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityResult result = await _repo.RegisterUser(userModel);
IHttpActionResult errorResult = GetErrorResult(result);
if (errorResult != null)
{
return(errorResult);
}
return(Ok());
}
public IActionResult SignUp(UserSignUpModel u)
{
TutorProfileModel tp = new TutorProfileModel();
UserDB udb = new UserDB();
tp.TutorProfile = udb.UserSignUp(u.LegalFN, u.LegalLN, u.Email, u.Password, u.CountryId, GetConfiguration().GetConnectionString("DefaultConnection"));
if (tp.TutorProfile != null)
{
HttpContext.Session.SetString("UserName", tp.TutorProfile.FirstName + "." + tp.TutorProfile.LastName);
HttpContext.Session.SetInt32("UserId", (int)tp.TutorProfile.UserId);
return(RedirectToAction("Questionnaire", "TutorProfile"));
}
else
{
ViewData["Message"] = "User Login Details failed !!";
}
return(View());
}
public async Task <IActionResult> Register(UserSignUpModel userSignUpModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { title = "Model is not valid" }));
}
var user = await _authService.SignUpAsync(userSignUpModel);
if (user != null)
{
return(Ok(new
{
title = "User was successfully registered"
}));
}
return(BadRequest(new { title = "User was not registered" }));
}
public ActionResult SignUp(UserSignUpModel model)
{
try
{
if (ModelState.IsValid)
{
var users = new ForumUser();
var data = new byte[model.File.ContentLength];
model.File.InputStream.Read(data, 0, model.File.ContentLength);
model.Image = data;
users.Image = model.Image;
users.FirstName = model.FirstName;
users.LastName = model.LastName;
users.UserName = model.UserName;
users.Country = model.Country;
users.Email = model.Email;
users.Password = model.Password;
_db.ForumUser.Add(users);
_db.SaveChanges();
var pi = new PostInformation();
var u = _db.ForumUser.SingleOrDefault(m => m.UserName.Equals(model.UserName));
if (u != null)
{
pi.UserId = u.UserId;
}
pi.TotalAnsPost = 0;
pi.TotalCommentPost = 0;
pi.TotalQuesPost = 0;
pi.TotalValidPost = 0;
_db.PostInformation.Add(pi);
_db.SaveChanges();
return(RedirectToAction("Login", "Account"));
}
}
catch (Exception)
{
Response.Write("<div id='logDialog'>");
Response.Write("You must upload your Image.And Image must be of jpg typed");
Response.Write("</div>");
return(View(model));
}
return(View());
}
