public ActionResult Register(string Username, string Password)
{
var db = new UserDb();
if (db.CreateUser(Username, Password))
return RedirectToAction("Index");
else return RedirectToAction("Register");
}
public void UserTestGetData()
{
var path = "ibox";
if (!Directory.Exists(path))
Directory.CreateDirectory(path);
using (var server = new DB(path))
{
var config = server.GetConfig();
config.EnsureTable<User>(TableName.Users, "username");
var db = server.Open();
Booker.Database.Interface.IUserDb userDb = new UserDb(db) as IUserDb;
var user = userDb.Get("gool");
}
}
//This is the function to verify if the user is the right one.
public bool Authenticate(string userName, string password)
{
using (var context = new UserDb())
{
//Compare the encoded type-in password with the encoded password in DB.
var user = from u in context.Users where (u.UserName == UserName) && (u.Password == Utilities.Encode(password)) select u;
//If the user exists in DB, return true
if (user != null)
{
return true;
}
else
return false;
}
}
public ActionResult Create([Bind(Include = "IDUser,IDGroup,Email,HoTen,Phone,PassWord,RePassWord,Status,Admin")] User user)
{
if (ModelState.IsValid)
{
var us = new UserDb().GetUserByEmail(user.Email);
ViewBag.IDGroup = new SelectList(db.Groups, "ID", "Name", user.IDGroup);
if (us == null)
{
user.PassWord = Encryptor.MD5Hash(user.PassWord);
user.RePassWord = Encryptor.MD5Hash(user.RePassWord);
db.Users.Add(user);
db.SaveChanges();
if (user.IDGroup == "MEMBER" || user.IDGroup == "ADMIN")
{
NhanVien nh = new NhanVien();
nh.Email = user.Email;
nh.TenNV = user.HoTen;
nh.IDUser = user.IDUser;
nh.SoDT = user.Phone;
db.NhanViens.Add(nh);
db.SaveChanges();
TempData["tk"] = "Đăng ký tài khoản thành công !";
return(View());
}
}
else
{
TempData["tk"] = "Email đã tồn tại !";
return(View());
}
return(RedirectToAction("Index"));
}
return(View(user));
}
public ActionResult Register(UsersNew form)
{
User user = new User();
user.SetPassword(form.Password);
user.Type = "user";
user.Username = form.Username;
user.Country = form.Country;
user.City = form.City;
user.SchoolName = form.SchoolName;
UserDb db = new UserDb();
if (!db.AddUser(user))
{
return(View(new UsersNew
{
DuplicateUserMessage = "This username already exists in database. Please choose a different one.",
}));
}
Session["userName"] = form.Username;
return(RedirectToRoute("WelcomePage"));
}
protected async Task UpdateUserNameAsync(UserDb userDb, string newUserName)
{
var isUsernameUpdate = newUserName != userDb.UserName;
if (isUsernameUpdate)
{
var usernameExist = await _userManager.FindByNameAsync(newUserName) != null;
if (usernameExist)
{
throw new JoggingTrackerBadRequestException(ErrorMessages.UserNameExists);
}
userDb.UserName = newUserName;
var result = await _userManager.UpdateAsync(userDb);
if (!result.Succeeded)
{
throw new JoggingTrackerBadRequestException(ErrorMessages.UserCantBeUpdated);
}
}
}
public IActionResult Login(string email, string password)
{
var db = new UserDb(_connectionString);
var user = db.Login(email, password);
if (user == null)
{
TempData["Error"] = "Invalid login!";
return(Redirect("/account/login"));
}
//this code logs in the current user!
var claims = new List <Claim>
{
new Claim("user", email)
};
HttpContext.SignInAsync(new ClaimsPrincipal(
new ClaimsIdentity(claims, "Cookies", "user", "role"))).Wait();
return(Redirect("/home/newad"));
}
public void should_call_generate_new_refresh_token()
{
List <RefreshToken> tokens = new() { new RefreshTokenBuilder().Build() };
User user = new UserBuilder().WithRefreshTokens(tokens).Build();
UserDb userFromDb = user.Map();
var usersFromDb = new List <UserDb> {
userFromDb
};
DateTime now = DateTime.UtcNow;
bool generatedRefreshToken = false;
Action <string> generateRefreshtoken = (ip) => { generatedRefreshToken = true; };
_users.Setup(n => n.Get(It.IsAny <Expression <Func <UserDb, bool> > >(), null, "")).Returns(usersFromDb);
_mapper.Setup(n => n.Map <User>(userFromDb)).Returns(user);
_dateTimeProvider.Setup(n => n.Now).Returns(now);
_jwtUtils.Setup(n => n.GenerateRefreshToken(IP_ADDRESS)).Callback(generateRefreshtoken);
_sut.Invoking(n => n.RefreshToken(tokens.Last().Token, IP_ADDRESS)).Should().Throw <Exception>();
generatedRefreshToken.Should().BeTrue();
}
public void getUser()
{
UserDb users = new UserDb();
int number;
data.text = string.Empty;
if (int.TryParse(check.text, out number))
{
System.Data.IDataReader reader = users.getDataById(number);
int fieldCount = reader.FieldCount;
while (reader.Read())
{
UserEntity entity = new UserEntity(int.Parse(reader[0].ToString()),
reader[1].ToString(),
reader[2].ToString());
Debug.Log("name: " + entity._firstName);
data.text += entity._id + " " + entity._firstName + " " + entity._lastName;
}
}
else
{
System.Data.IDataReader reader = users.getDataByString(check.text);
int fieldCount = reader.FieldCount;
while (reader.Read())
{
UserEntity entity = new UserEntity(int.Parse(reader[0].ToString()),
reader[1].ToString(),
reader[2].ToString());
Debug.Log("name: " + entity._firstName);
data.text += entity._id + " " + entity._firstName + " " + entity._lastName + "\n";
}
}
}
public void Update(UserDb user, bool removePassword)
{
EntityORM entity = EntityMapping.Map(user, attributes);
// Making sure that ID value is not touched.
entity.attributeValue.Remove("ID");
if (removePassword) //Remove password field
{
entity.attributeValue.Remove("PASSWORD");
}
bool ifUpdated = crud.Update(user.Id, table, idColumn, entity);
if (ifUpdated)
{
logger.Info($"User with id={user.Id} was successfully updated.");
}
else
{
logger.Info($"Updating user with id={user.Id} was failed.");
}
}
/// <summary>
/// Send json request to check a user in DB exist with this email
/// </summary>
/// <param name="Email"></param>
/// <returns>Json</returns>
public JsonResult IsEmailExist(string Email, int?IdUser)
{
UserDb dbUser = new UserDb();
User userFound = new User();
userFound = dbUser.GetUserByEmail(Email);
int id = 0;
string email = "";
CustomerDb dbCustomer = new CustomerDb();
var claimIdentity = User.Identity as ClaimsIdentity;
if (claimIdentity.GetUserId() != null)
{
id = Convert.ToInt32(claimIdentity.FindFirst(ClaimTypes.NameIdentifier).Value);
email = Convert.ToString(claimIdentity.FindFirst(ClaimTypes.Email).Value);
}
// Check if the account is the same of account edited by the admin
if (IdUser != null && userFound.IdUser == IdUser)
{
return(Json(true, JsonRequestBehavior.AllowGet));
}
// Check if the edit email is the same of the connected account
if (id > 0 && userFound.Email == email)
{
return(Json(true, JsonRequestBehavior.AllowGet));
}
if (userFound.Username != null)
{
return(Json(false, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(true, JsonRequestBehavior.AllowGet));
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var user = new UserDb {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public ActionResult Index(User model)
{
if (ModelState.IsValid)
{
if (model.RePassWord == model.PassWord)
{
var db = new UserDb();
var result = db.GetUserByEmail(model.Email);
if (model.Status == true)
{
if (result == null)
{
var password = Encryptor.MD5Hash(model.PassWord);// mã hóa pass
model.PassWord = password;
model.IDGroup = "CUSTOMER";
model.RePassWord = Encryptor.MD5Hash(model.RePassWord);
db.InsertUser(model);
TempData["create"] = "Tạo Tài Khoản Thành Công !";
//return RedirectToAction("Index", "UserLogin");
}
else
{
ModelState.AddModelError("", "Email Đã Tồn Tại !");
}
}
else
{
ModelState.AddModelError("", "Hãy Nhấn xác nhận đăng ký để thành công !");
}
}
else
{
ModelState.AddModelError("", "Mật khẩu phải giống nhau chứ !");
}
}
return(View());
}
public async Task <bool> RegisterUserAsync(UserReg regUser)
{
var users = await _storage.GetAllAsync();
var dbUser = users.FirstOrDefault(user => user.Login == regUser.Login);
if (dbUser != null)
{
throw new UserException("User already exists");
}
if (String.IsNullOrWhiteSpace(regUser.Login) ||
String.IsNullOrWhiteSpace(regUser.Name) ||
String.IsNullOrWhiteSpace(regUser.Surname) ||
String.IsNullOrWhiteSpace(regUser.Password) ||
String.IsNullOrWhiteSpace(regUser.Email))
{
throw new ArgumentException("Login, Password, Name, Surname or Email is Empty");
}
dbUser = new UserDb(regUser.Login, Encryption.Encrypt(regUser.Password, regUser.Password), regUser.Name, regUser.Surname, regUser.Email);
await _storage.AddOrUpdateAsync(dbUser);
return(true);
}
//////////////////////////
///edit Order
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(HttpNotFound());
}
else
{
UserDb UserSession = (UserDb)Session["User"];
var editdbOrder = await db.Orders.FirstOrDefaultAsync(f => f.Id == id && f.UserDbId == UserSession.Id);
if (editdbOrder == null)
{
return(HttpNotFound());
}
else
{
ViewBag.Category = await db.Categories.ToListAsync();
return(PartialView(editdbOrder));
}
}
}
/// <summary>
/// Creates new instance of UserBuilder to create a new Customer.
/// </summary>
/// <returns>
/// null object.
/// </returns>
public User CreateNewUser()
{
try
{
//New instance of UserBuilder. Returns user of Customer type.
var user = new UserDb().Build(2);
//User inserted into the database.
Console.Clear();
Console.WriteLine("New user created. Use id and password to sign in.\n");
Console.WriteLine(user);
Console.WriteLine("\nPress enter to continue.");
}
catch (System.Exception ex)
{
Console.Clear();
Console.WriteLine(ex.Message);
Console.WriteLine("Failed to create a new user.\nPress enter to continue.");
}
Console.ReadLine();
Console.Clear();
return(null);
}
public ActionResult Registration(UserDb u)
{
if (ModelState.IsValid)
{
#region//Email is already Exist
var isExist = IsEmailExist(u.EmailID);
if (isExist)
{
ViewBag.emailexist = "email already exist";
return(View(u));
}
#endregion
}
#region //save to database
using (MVCEntities dc = new MVCEntities())
{
dc.UserDbs.Add(u);
dc.SaveChanges();
}
#endregion
ViewBag.success = "registered successful";
return(View(u));
}
public ActionResult <UserDb> EditUserInfo(Guid userId, [FromBody] UserDb info)
{
var user = _userContext.User.Find(userId);
if (user == null)
{
return(BadRequest(new { message = "ID does not exist" }));
}
foreach (var field in typeof(UserDb).GetProperties().Where(p => (p.GetValue(info) != null)))
{
if (field.Name == "Password")
{
return(Unauthorized(new { message = "You are not authorized to change the password from this endpoint" }));
}
else if (!(field.PropertyType == typeof(DateTime) && field.GetValue(info).ToString() == new DateTime().ToString()))
{
field.SetValue(user, field.GetValue(info));
}
}
_userContext.SaveChanges();
return(Ok(new{ user = user }));
}
public async Task <IActionResult> UpdateUser([FromBody] UserInfo createUser)
{
Logger.LogInformation($"{nameof(UserController)}.{nameof(UpdateUser)}.Start");
if (!ModelState.IsValid)
{
return(new BadResponseResult(ModelState));
}
var user = await UserDb.GetUser(createUser.PhoneIMEI);
if (user == null)
{
return(new NotFoundResponseResult("The user with id doesn't exist"));
}
var personalTone = new PersonalColorTypeQualifier().GetPersonalColorType(createUser.EyeColor, createUser.HairColor, createUser.SkinTone);
user.PersonalColorTypeId = (int)personalTone;
user = await UserDb.UpdateUser(user);
Logger.LogInformation($"{nameof(UserController)}.{nameof(UpdateUser)}.End");
return(new OkResponseResult("Updated user.", user));
}
public UserDb Map(User user)
{
UserDb user_newType = new UserDb();
#region Transfer main attributes
user_newType.Id = user.Id;
user_newType.Name = user.Name;
user_newType.Nickname = user.Nickname;
user_newType.PhotoURL = user.PhotoURL;
user_newType.Email = user.Email;
user_newType.IsVerified = user.IsVerified;
user_newType.IsCreator = user.IsCreator;
user_newType.IsBanned = user.IsBanned;
user_newType.EndBanDate = user.EndBanDate;
user_newType.PlatformLanguage = user.PlatformLanguage;
user_newType.PlatformTheme = user.PlatformTheme;
#endregion
return(user_newType);
}
protected override void Seed(BulbaCourses.Podcasts.Data.PodcastsContext context)
{
// This method will be called after migrating to the latest version.
// You can use the DbSet<T>.AddOrUpdate() helper extension method
// to avoid creating duplicate seed data.
var user1 = new UserDb()
{
Id = "8C7362B6-AAD5-42F7-B366-CE45304D03A5",
IsAdmin = true,
Name = "*****@*****.**",
Avatar = null,
BoughtCourses = null,
UploadedCourses = null,
Comments = null,
Description = "",
RegistrationDate = DateTime.Now,
Email = "",
};
context.Users.Add(user1);
base.Seed(context);
}
public void should_return_new_jwt_and_refresh_token()
{
List <RefreshToken> tokens = new() { new RefreshTokenBuilder().Build() };
User user = new UserBuilder().WithRefreshTokens(tokens).Build();
UserDb userFromDb = user.Map();
var usersFromDb = new List <UserDb> {
userFromDb
};
DateTime now = DateTime.UtcNow;
var newRefreshToken = new RefreshTokenBuilder().Build();
string newJwtToken = "new jwt token";
AuthenticateResponse expectedResult = new(user, newJwtToken, newRefreshToken.Token);
_users.Setup(n => n.Get(It.IsAny <Expression <Func <UserDb, bool> > >(), null, "")).Returns(usersFromDb);
_mapper.Setup(n => n.Map <User>(userFromDb)).Returns(user);
_dateTimeProvider.Setup(n => n.Now).Returns(now);
_jwtUtils.Setup(n => n.GenerateRefreshToken(IP_ADDRESS)).Returns(newRefreshToken);
_jwtUtils.Setup(n => n.GenerateJwtToken(user)).Returns(newJwtToken);
var result = _sut.RefreshToken(tokens.First().Token, IP_ADDRESS);
result.Should().BeEquivalentTo(expectedResult);
}
public User MapToWebService(UserDb userDb)
{
if (userDb == null)
{
Log.Warning($"In UserMapper.MapToWebService(): Unexpected null input. userDb==null");
return(null);
}
var user = new User
{
Username = userDb.Username,
Id = userDb.UserId,
Address = userDb.Address,
City = userDb.City,
Email = userDb.Email,
Name = userDb.FirstName,
Surname = userDb.Surname,
PersonalCodeNumber = userDb.PersonalIdentityNumber,
Phonenumber = userDb.PhoneNumber,
Picture = userDb.PictureUrl,
ZipCode = userDb.ZipCode,
};
return(user);
}
//
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
var identity = new ClaimsIdentity(context.Options.AuthenticationType);
var user = UserDb.Login(context.UserName, context.Password);
if (context.UserName == user.Email && context.Password == user.Password)
{
identity.AddClaim(new Claim(ClaimTypes.Role, user.Id.ToString()));
identity.AddClaim(new Claim("username", user.Email));
identity.AddClaim(new Claim(ClaimTypes.Name, user.Name));
context.Validated(identity);
}
//else if(context.UserName=="user" && context.Password == "321")
//{
// identity.AddClaim(new Claim(ClaimTypes.Role, "user"));
// identity.AddClaim(new Claim("username", "user"));
// identity.AddClaim(new Claim(ClaimTypes.Name, "A R Shopon"));
// context.Validated(identity);
//}
else
{
context.SetError("invalid_grant", "User name or password is incorrect!");
}
}
public UserBs()
{
objDb = new UserDb();
}
public bool IfUserExists(long id)
{
UserDb user = Get(id);
return(user != null);
}
public bool IfPasswordCorrect(long id, string password)
{
UserDb user = Get(id);
return(user.Password == password);
}
public bool IfEmailExists(string email)
{
UserDb user = GetByEmail(email);
return(user != null);
}
public bool IfNicknameExists(string nickname)
{
UserDb user = GetByNickname(nickname);
return(user != null);
}
public ActionResult Index(string Username, string Password)
{
var db = new UserDb();
Session["User"] = db.LoginUser(char.ToUpper(Username[0]) + Username.Substring(1), Password);
return RedirectToAction("Index");
}
public void Update(UserDb user)
{
Update(user, removePassword: false);
}
public MyRoleProvider()
{
ObjDb = new UserDb();
}
static void Main(string[] args)
{
UserDb db = new UserDb();
var user = db.getUsers();
}
public async Task <IActionResult> _RegisterSection(RegiserModel model)
{
if (ModelState.IsValid)
{
//-------------- Save Image to Database
//UserImgDb userImg = new UserImgDb();
//using (var memoryStream = new MemoryStream())
//{
// await model.ImgPic.CopyToAsync(memoryStream);
// userImg.UserImg = memoryStream.ToArray();
//}
//-------------- Save Image to Image Folder in the Web Hosting Enivornment
string uniqueFileName = UploadedFile(model);
UserImgDb userImg = new UserImgDb
{
UserImg = uniqueFileName
};
bool result = await _repo.CreateUserImgAsync(userImg);
if (result)
{
UserDb user = new UserDb
{
UserName = model.AccountName,
UserEmail = model.AccountEmail,
UserAddress = model.AccountAddress,
UserCity = model.AccountCity,
UserCountry = model.AccountCountry,
UserDescription = model.AccountDescription,
ImageId = userImg.ImageId
};
if (model.IsShop)
{
user.IsShop = true;
}
var identityResult = await userManager.CreateAsync(user, model.AccountPassword);
if (identityResult.Succeeded)
{
ViewBag.Set = "You are all Set to LogIn";
// return Request.
// return RedirectToAction("Index", "Account");
}
else
{
foreach (IdentityError error in identityResult.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
}
}
//return PartialView(""model);
// return View("AccountManagement", model);
return(View("AccountManagement", new AccountPort {
RegiserModel = model
}));
//return View(model);
}
public UserHandler()
{
userDb = new UserDb();
this.allStudentsList = new List<student22>();
}
