public async Task <JsonResult> Register([FromBody] RegisterModelView model)
{
if (ModelState.IsValid)
{
var user = new IdentityUser()
{
UserName = model.UserName,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, isPersistent : model.IsPersistent);
return(Json(user));
}
HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
return(Json(new ErrorMessage(result.Errors.Select(x => x.Description.ToString()))));
}
HttpContext.Response.StatusCode = StatusCodes.Status403Forbidden;
return(Json(new ErrorMessage(ViewData.ModelState.Values.Select(x => x.Errors)
.Select(x => x.Select(y => y.ErrorMessage).Aggregate((i, j) => i + "; " + j)))));
}
public ActionResult Edit(int id)
{
try
{
using (ISession session = database.MakeSession())
{
if (!IsLogged())
{
return(RedirectToAction("Login"));
}
//var userId = Int32.Parse(this.User.Identity.GetUserId());
var user = session.Get <User>(id);
if (user.Role == UserRole.READER_ROLE)
{
var reader = session.QueryOver <Reader>().Where(x => x.User == user).List <Reader>()[0];
var userData = new RegisterModelView(user, reader);
return(View("EditReader", userData));
}
else
{
var userData = new RegisterModelView(user);
return(View(userData));
}
}
}
catch (Exception e)
{
return(RedirectToAction("Index", "Home"));
}
}
public IActionResult EditProfile()
{
LogRestaurant();
if (TempData["ErrorMessage"] != null)
{
ViewBag.ErrorMessage = TempData["ErrorMessage"];
}
if (TempData["Message"] != null)
{
ViewBag.Message = TempData["Message"];
}
ClaimsPrincipal cp = this.User;
var claims = cp.Claims.ToList();
var userId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "UserID").Value);
var user = UsersManager.GetUserByUserId(userId);
var viewUser = new RegisterModelView
{
UserId = user.UserId,
Address = user.Address,
City = user.City,
Province = user.Province,
Country = user.Country,
Phone = user.Phone,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.Authentication.Username,
AuthId = user.AuthenticationId,
};
return(View(viewUser));
}
public async Task <ActionResult> Register(RegisterModelView model)
{
if (ModelState.IsValid)
{
UserDTO userDto = new UserDTO
{
Email = model.Email,
Login = model.Login,
Password = model.Password,
Roles = new List <string>()
{
"user"
},
Name = model.Name,
Surname = model.Surname,
Country = model.Country,
City = model.City,
LastIP = Request.UserHostAddress,
DateRegister = DateTime.Now,
DateLastVisit = DateTime.Now
};
OperationDetails operationDetails = await userService.CreateAsync(userDto);
if (operationDetails.Succedeed)
{
return(View("SuccessRegister"));
}
else
{
ModelState.AddModelError(operationDetails.Property, operationDetails.Message);
}
}
return(View(model));
}
void OnLoggedIn(RegisterModelView userModelView)
{
IsLoggedIn = true;
UserSignedUp?.Invoke();
CurrentUserModelView = new UserModelView(userModelView.UserName, userModelView.Email);
_network?.Connect(CurrentUserModelView.UserName);
}
//User Registration
public IActionResult Register()
{
if (TempData["Message"] != null)
{
ViewBag.Message = TempData["Message"];
}
if (TempData["ErrorMessage"] != null)
{
ViewBag.ErrorMessage = TempData["ErrorMessage"];
var viewRegister = new RegisterModelView();
if (TempData["FName"] != null)
{
viewRegister.FirstName = (string)TempData["FName"];
}
if (TempData["LName"] != null)
{
viewRegister.LastName = (string)TempData["LName"];
}
if (TempData["Address"] != null)
{
viewRegister.Address = (string)TempData["Address"];
}
if (TempData["City"] != null)
{
viewRegister.City = (string)TempData["City"];
}
if (TempData["Province"] != null)
{
viewRegister.Province = (string)TempData["Province"];
}
if (TempData["Country"] != null)
{
viewRegister.Country = (string)TempData["Country"];
}
if (TempData["Email"] != null)
{
viewRegister.Email = (string)TempData["Email"];
}
if (TempData["Phone"] != null)
{
viewRegister.Phone = (string)TempData["Phone"];
}
if (TempData["UserName"] != null)
{
viewRegister.Username = (string)TempData["UserName"];
}
return(View(viewRegister));
}
else
{
return(View());
}
}
public async Task <IActionResult> Signup([Bind("username,password,avt_path,lstname,fstname,phone,add_Info,subDistrict,District_town,City_Provine,email")] RegisterModelView registerModelView)
{
if (await service.RegisterAsync(registerModelView))
{
TempData["mes"] = $"Đăng ký Tài khoản {registerModelView.username} thành công";
}
else
{
TempData["mes"] = "Đăng ký không thành công";
}
return(View(registerModelView));
}
public async Task <ActionResult> Register(RegisterModelView NewClient)
{
if (ModelState.IsValid)
{
using (ApplicationDbContext db = new ApplicationDbContext())
{
Clients client = new Clients();
client.FirstName = NewClient.FirstName;
client.LastName = NewClient.LastName;
client.Email = NewClient.Email;
client.Password = NewClient.Password;
if (NewClient.file != null)
{
string pic = System.IO.Path.GetFileName(NewClient.file.FileName);
client.PathImage = "~/Client/ClientContent/" + client.Email + pic;
string path = System.IO.Path.Combine(Server.MapPath("~Client/ClientContent"), client.Email + pic);
NewClient.file.SaveAs(path);
try
{
using (MemoryStream ms = new MemoryStream())
{
NewClient.file.InputStream.CopyTo(ms);
byte[] array = ms.GetBuffer();
}
}
catch (Exception e)
{
ViewBag.Error = "Problem on uploading the image";
}
}
client = db.client.Add(client);
db.SaveChanges();
var roleManager = new RoleManager <Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
if (!roleManager.RoleExists("Client"))
{
var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
role.Name = "Client";
roleManager.Create(role);
}
return(RedirectToAction("/Login"));
}
}
return(View());
}
public ActionResult Register(RegisterModelView model)
{
try
{
using (ISession session = database.MakeSession())
{
if (ModelState.IsValid)
{
var user = new User()
{
UserName = model.UserName,
Email = model.Email,
Name = model.Name,
Surname = model.Surname,
Role = UserRole.READER_ROLE
};
var result = UserManager.Create(user, model.Password);
var reader = new Reader()
{
Pesel = model.Pesel,
Telephone = model.Telephone,
User = user,
RegistrationDate = DateTime.Now.ToString("dd.MM.yyyy")
};
if (result.Succeeded)
{
using (ITransaction transaction = session.BeginTransaction())
{
SignInManager.SignIn(user, false, false);
session.SaveOrUpdate(reader);
transaction.Commit();
}
return(RedirectToAction("Index", "Home"));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
}
return(View(model));
}
}
catch (Exception e)
{
return(View());
}
}
public IActionResult Register(RegisterModelView model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
try
{
_serviceAccount.CreateAccount(
new AccountDTO(model.RoleProfile, model.Email, model.Password, model.AvatarUrl, model.Name, model.NickName));
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
}
return(RedirectToAction("Books", "Book"));
}
public void SignUp(RegisterModelView registerModelView, Action <bool> onResponse)
{
if (IsLoggedIn)
{
onResponse(true);
return;
}
if (_isBusy)
{
_workingThreads.Enqueue(() => SignUp(registerModelView, onResponse));
return;
}
_isBusy = true;
_http.PostAsync <RegisterModelView, RegisterModelView>("auth/signUp", registerModelView,
(res) => OnSignUpResult(res, onResponse))
.ContinueWith(CallError);
}
public IActionResult EditAccount(RegisterModelView model, string op)
{
try
{
var accountDto = new AccountDTO(model.Id, model.RoleProfile, model.UserId, model.Email, model.Password, model.AvatarUrl, model.Name, model.NickName);
if ("Atualizar".Equals(op))
{
_serviceAccount.UpdateAccount(accountDto);
}
if ("Deletar".Equals(op))
{
_serviceAccount.DeleteAccount(accountDto);
}
ViewBag.Url = "/Account/Register";
return(PartialView("_SaveChangesConfirm"));
}
catch (Exception ex)
{
ViewBag.Error = ex.Message;
}
return(RedirectToAction("Books", "Book"));
}
public ActionResult Edit(int id, RegisterModelView model)
{
try
{
using (ISession session = database.MakeSession())
{
//var userId = Int32.Parse(this.User.Identity.GetUserId());
var userData = session.Get <User>(id);
userData.UserName = model.UserName;
userData.Email = model.Email;
using (ITransaction transaction = session.BeginTransaction())
{
session.SaveOrUpdate(userData);
if (userData.Role == UserRole.READER_ROLE)
{
var readerData = session.QueryOver <Reader>().Where(x => x.User == userData).List <Reader>()[0];
readerData.Telephone = model.Telephone;
session.SaveOrUpdate(readerData);
session.Flush();
transaction.Commit();
return(View("EditReader", model));
}
else
{
transaction.Commit();
return(View(model));
}
}
}
}
catch (Exception e)
{
return(View("Index", "Home"));
}
}
public async Task <IActionResult> Register(RegisterModelView user)
{
if (ModelState.IsValid)
{
AppUser appUser = new AppUser {
UserName = user.UserName,
FullName = user.FullName,
Age = user.Age,
Email = user.EMail
};
IdentityResult result = await _userManager.CreateAsync(appUser, user.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(user));
}
public ActionResult ReadersIndex()
{
try
{
if (!IsLogged())
{
return(RedirectToAction("Login"));
}
using (ISession session = database.MakeSession())
{
ValidateReaderForbiddenAccess(session);
var readers = session.QueryOver <Reader>().List();
var readersData = new List <RegisterModelView>();
foreach (var reader in readers)
{
var userId = reader.User.Id;
var user = session.Get <User>(reader.User.Id);
var readerData = new RegisterModelView(user, reader);
readersData.Add(readerData);
}
return(View(readersData));
}
}
catch (UnauthorizedAccessException)
{
return(RedirectToAction("Forbidden", "Error"));
}
catch (Exception e)
{
Debug.Write(e.Message);
return(RedirectToAction("Login"));
}
}
public async Task <bool> RegisterAsync(RegisterModelView modelView)
{
string idcus;
string idAcc;
var tran = this.ShoeEcommerceDBContext.Database.BeginTransaction();
try
{
//customer
var cusRepo = new CustomerRepository(this.ShoeEcommerceDBContext);
idcus = await cusRepo.GetNextId();
var cus = new Customer()
{
idCustomer = idcus,
fstname = modelView.fstname,
lstname = modelView.lstname,
phone = modelView.phone,
stt = true
};
cusRepo.Create(cus);
await cusRepo.SaveAsync();
//account
idAcc = await GetNextId();
var acc = new Account()
{
idAccount = idAcc,
username = modelView.username,
passwd = ExtensionTools.GetMD5(modelView.password),
avt_path = ExtensionTools.GetFullPath(modelView.avt_path),
rankVip = "default",
rate = 1,
IdMerchant = "noone",
idCustomer = idcus,
CreatedDate = DateTime.Now,
stt = true
};
Create(acc);
await SaveAsync();
//email
var EmailRepo = new EmailRepository(this.ShoeEcommerceDBContext);
EmailRepo.Create(new Email()
{
id = await EmailRepo.GetNextIdAsync(),
email = modelView.email,
IdAccount = idAcc,
stt = true
});
await EmailRepo.SaveAsync();
//Address
var AddressRepos = new AddressRepository(this.ShoeEcommerceDBContext);
AddressRepos.Create(new Address()
{
id = await AddressRepos.GetNextId(),
add_Info = modelView.add_Info,
City_Provine = modelView.City_Provine,
District_town = modelView.District_town,
subDistrict = modelView.subDistrict,
idAccount = idAcc,
stt = true
});
await AddressRepos.SaveAsync();
tran.Commit();
tran.Dispose();
return(true);
}
catch (Exception ex)
{
tran.Rollback();
tran.Dispose();
return(false);
}
}
public IActionResult EditProfile(RegisterModelView viewUser)
{
LogRestaurant();
ClaimsPrincipal cp = this.User;
var claims = cp.Claims.ToList();
var authId = Convert.ToInt32(claims.SingleOrDefault(p => p.Type == "AuthID").Value);
string id = Convert.ToString(viewUser.UserId);
if (viewUser.FirstName == "" || viewUser.FirstName == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "First Name is required.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
if (viewUser.LastName == "" || viewUser.LastName == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Last Name is required.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
if (viewUser.Email == "" || viewUser.Email == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Email is required.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
if (viewUser.Username == "" || viewUser.Username == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Username is required.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
if (viewUser.Username == "" || viewUser.Password == null)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Passord is required.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
var user = new Users
{
UserId = viewUser.UserId,
Address = viewUser.Address,
City = viewUser.City,
Province = viewUser.Province,
Country = viewUser.Country,
Phone = viewUser.Phone,
Email = viewUser.Email,
FirstName = viewUser.FirstName,
LastName = viewUser.LastName,
AuthenticationId = authId
};
UsersManager.UpdateUser(user);
var auth = new Authentication
{
Username = viewUser.Username,
Password = viewUser.Password,
Id = authId
};
bool username = UsersManager.UpdateAuthentication(auth);
if (!username)
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "Sorry!!! Username is already taken. Choose another one.";
return(RedirectToAction("EditProfile", new { id = viewUser.UserId }));
}
else
{
TempData["Message"] = "Your profile was Updated!!!";
TempData["ErrorMessage"] = null;
return(RedirectToAction("Profile", "Account"));
}
}
}
}
}
}
}
public async Task <bool> RegisterAsync(RegisterModelView modelView)
{
return(await Repositoty.RegisterAsync(modelView));
}
public IActionResult Register(RegisterModelView viewRegistration)
{
TempData["FName"] = viewRegistration.FirstName;
TempData["LName"] = viewRegistration.LastName;
TempData["Email"] = viewRegistration.Email;
TempData["UserName"] = viewRegistration.Username;
TempData["Address"] = viewRegistration.Address;
TempData["City"] = viewRegistration.City;
TempData["Province"] = viewRegistration.Province;
TempData["Country"] = viewRegistration.Country;
TempData["Phone"] = viewRegistration.Phone;
if (viewRegistration.FirstName == "" || viewRegistration.FirstName == null)
{
TempData["ErrorMessage"] = "First Name is required.";
return(RedirectToAction("Register", "Account"));
}
else
{
if (viewRegistration.LastName == "" || viewRegistration.LastName == null)
{
TempData["ErrorMessage"] = "Last Name is required.";
return(RedirectToAction("Register", "Account"));
}
else
{
if (viewRegistration.Email == "" || viewRegistration.Email == null)
{
TempData["ErrorMessage"] = "Email is required.";
return(RedirectToAction("Register", "Account"));
}
else
{
if (viewRegistration.Username == "" || viewRegistration.Username == null)
{
TempData["ErrorMessage"] = "Usernamel is required.";
return(RedirectToAction("Register", "Account"));
}
else
{
if (viewRegistration.Password == "" || viewRegistration.Password == null)
{
TempData["ErrorMessage"] = "Passord is required.";
return(RedirectToAction("Register", "Account"));
}
else
{
int id;
var auth = new Authentication
{
Username = viewRegistration.Username,
Password = viewRegistration.Password
};
lock (Lock)
{
id = UsersManager.CreateAuthentication(auth);
}
if (id > 0)
{
var user = new Users
{
Address = viewRegistration.Address,
AuthenticationId = id,
City = viewRegistration.City,
Country = viewRegistration.Country,
Email = viewRegistration.Email,
Province = viewRegistration.Province,
Phone = viewRegistration.Phone,
LastName = viewRegistration.LastName,
FirstName = viewRegistration.FirstName
};
UsersManager.CreateUser(user);
int UserId = UsersManager.GetUserIdByAuthId(id);
var customer = new Customers
{
UserId = UserId
};
CustomersManager.CreateCustomer(customer);
TempData["Message"] = "Regitration completed! Login to Access the TableReady portal.";
TempData["ErrorMessage"] = null;
return(RedirectToAction("Login", "Account"));
}
else
{
TempData["Message"] = null;
TempData["ErrorMessage"] = "USERNAME already exist.Try another one.";
return(RedirectToAction(nameof(Register)));
}
}
}
}
}
}
}
public IActionResult Index(RegisterModelView model)
{
return(View(model));
}