public ActionResult SubmitStudent(string user_name, string first_name, string last_name, string dob, string email)
{
studentprofile sprofile = new studentprofile()
{
iD = 0,
FirstName = first_name,
LastName = last_name,
DoB = Convert.ToDateTime(dob),
Emailaddress = email,
Optional = "A",
useriD = UserValidation.FindUserId(user_name)
};
bool result = UserValidation.CreateStudent(sprofile);
return(View("Create"));
}
public ActionResult EditStudent(int id, string user_name, string first_name, string last_name, string dob, string email)
{
studentprofile sprofile = new studentprofile()
{
iD = id,
FirstName = first_name,
LastName = last_name,
DoB = DateTime.ParseExact(dob, "MM/dd/yyyy HH:mm:ss tt", null),
Emailaddress = email,
Optional = "A",
useriD = UserValidation.FindUserId(user_name)
};
bool result = UserValidation.ModifyStudent(sprofile);
return(View("Index", assessmentdb.studentprofile.ToList()));
}
public UserValidation GetUserStatus(string apiKey, int UserId)
{
UserValidation uVal = new UserValidation();
if (apiKey == ConfigurationManager.AppSettings["reasonkey"])
{
try
{
uVal = _agentbal.GetUserStatus(UserId);
}
catch (Exception ex)
{
LogBal.ErrorLog(this.GetType().Name, MethodBase.GetCurrentMethod().Name, ex.Message, 0);
}
}
return(uVal);
}
public void TestValidateEmail(string email, bool pass)
{
UserValidation userValidation = GetUserValidation();
User user = new User()
{
Email = email
};
if (pass)
{
Valid(user, userValidation.ValidateEmail);
}
else
{
Invalid(user, userValidation.ValidateEmail);
}
}
public void TestValidatePhoneNumber(string phoneNumber, bool pass)
{
UserValidation userValidation = GetUserValidation();
User user = new User()
{
PhoneNumber = phoneNumber
};
if (pass)
{
Valid(user, userValidation.ValidatePhoneNumber);
}
else
{
Invalid(user, userValidation.ValidatePhoneNumber);
}
}
public ActionResult ValidateUser(UserValidation userValidation)
{
if (!ModelState.IsValid)
{
return(View(new UserValidation()));
}
string UserId = userService.ValidateUserByNitAndNitDate(userValidation.Nit, userValidation.NitDate);
if (!string.IsNullOrEmpty(UserId))
{
return(RedirectToAction("InfoUser", "User", new { id = UserId }));
}
ModelState.AddModelError("InvalidUser", "Usuario no encontrado en el sistema");
return(View("ValidateUser", new UserValidation()));
}
public ActionResult ValidateUser(string login, string password)
{
//if (UserValidation.ValidateCredential(login, password))
if (UserValidation.ValidateCredential(login, password) == true)
{
Session["InvalidUser"] = "******";
Session["LoginedUser"] = login;
//return View("Index");
return(RedirectToAction("Index", "Home"));
}
else
{
Session["InvalidUser"] = "******";
Session["LoginedUser"] = "";
return(View("LogIn"));
}
}
public void Submit()
{
//compiles list of existing users
List <string> existingUsernames = new List <string>();
for (int i = 0; i < UserValidation.userList.Count; i++)
{
existingUsernames.Add(UserValidation.userList[i].username);
}
//if username entered does not exist
if (!existingUsernames.Contains(username))
{
deleteText.GetComponent <Text>().text = username + " Does Not Exist";
deleteText.GetComponent <Text>().color = Color.red;
deleteText.SetActive(true);
displayTime = 2.5f;
}
//can't delete admin
else if (username == "admin")
{
deleteText.GetComponent <Text>().text = "Cannot Delete Admin";
deleteText.GetComponent <Text>().color = Color.red;
deleteText.SetActive(true);
displayTime = 2.5f;
}
//remove user
else
{
UserValidation.userList.RemoveAt(existingUsernames.IndexOf(username));
UserValidation.Save();
deleteUserIN.text = "";
deleteText.GetComponent <Text>().text = username + " Deleted";
deleteText.GetComponent <Text>().color = Color.green;
deleteText.SetActive(true);
displayTime = 2.5f;
DisplayList();
}
active = false;
}
public ActionResult RegisterUser(RegisterUserModel user)
{
try
{
var security = new SqlSecurity(ConfigurationManager.ConnectionStrings["WhosOnFirstDb"].ConnectionString);
var userValidation = new UserValidation();
var person = new Person();
userValidation.UserName = user.UserName;
userValidation.Password = user.Password;
if (user.UserRole == "Coach")
{
user.IsPlayer = false;
user.IsCoach = true;
}
else if (user.UserRole == "Player")
{
user.IsPlayer = true;
user.IsCoach = false;
}
else
{
user.IsPlayer = true;
user.IsCoach = false;
}
person.IsPlayer = user.IsPlayer;
person.IsCoach = user.IsCoach;
person.IsValid = true;
person.IsAdmin = false;
person.FirstName = user.FirstName;
person.LastName = user.LastName;
person.EMail = user.EMail;
person.PhoneNumber = user.PhoneNumber;
//TempData["RegistrationInfo"] = user;
security.RegisterUserAsync(userValidation, person);
return(RedirectToAction("Index"));
}
catch (Exception)
{
ViewBag.Warning = "Invalid or Blank registration! Try again.";
return(View());
}
}
public async Task <IActionResult> UpdateAsync([FromBody] UserDTO userDTO)
{
List <ValidateString> validations = UserValidation.UpdateUser(userDTO);
//User bliver valideret, og hvis listen af fejl beskeder er over 0, returneres et badrequest med alle fejl beskederne.
if (InputValidator.StringInputValidation(validations).Count > 0)
{
return(BadRequest(InputValidator.StringInputValidation(validations)));
}
var createRequest = await _unitOfWork.Users.UpdateAsync(this._mapper.Map <User>(userDTO));
if (createRequest > 0)
{
return(Ok("User successfully updated"));
}
return(BadRequest("User was not updated"));
}
public IActionResult UpdateUser(Guid guid, string name, string email, string login)
{
if (userGetByIdUseCase.GetById(guid) == null)
{
return(BadRequest());
}
var user = new Domain.Entities.User.User(guid, name, email, login);
var validationResult = new UserValidation().Validate(user);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
userUpdateUseCase.Update(user);
return(new OkObjectResult(user));
}
public void Submit()
{
//compiles list of blocked users and a list of their corresponding indexes
List <string> blocked = new List <string>();
List <int> blockedIndex = new List <int>();
for (int i = 0; i < UserValidation.userList.Count; i++)
{
if (UserValidation.userList[i].status == "BLOCKED")
{
blocked.Add(UserValidation.userList[i].username);
blockedIndex.Add(i);
}
}
//If user is not blockeds
if (!blocked.Contains(username))
{
unblockText.GetComponent <Text>().text = username + " Not On Block List";
unblockText.GetComponent <Text>().color = Color.red;
unblockText.SetActive(true);
displayTime = 2.5f;
}
//if user is blocked
else
{
//Status changed and password changed to username
UserValidation.userList[blockedIndex[blocked.IndexOf(username)]].status = "NEW";
UserValidation.userList[blockedIndex[blocked.IndexOf(username)]].password = username;
UserValidation.numTrials[blockedIndex[blocked.IndexOf(username)]] = 3;
UserValidation.Save();
unblockUserIN.text = "";
unblockText.GetComponent <Text>().text = username + " Unblocked";
unblockText.GetComponent <Text>().color = Color.green;
unblockText.SetActive(true);
displayTime = 2.5f;
DisplayList();
}
active = false;
}
public static bool Create(RegisterModel data)
{
if (_userMethods.UserExists(data.Username))
{
return(false);
}
if (_userMethods.EmailExists(data.Email))
{
return(false);
}
var newUser = new User {
Username = data.Username,
DisplayName = data.Username,
Email = data.Email,
Salt = UserValidation.GenerateSalt(),
HasGravatar = false,
ProfilePic = ""
};
newUser.Password = UserValidation.HashText(data.Password, newUser.Salt, new SHA512CryptoServiceProvider());
_userMethods.CreateUser(newUser);
if (!_userMethods.UserExists(newUser.Username))
{
return(false);
}
var user = _userMethods.GetUserByUsername(newUser.Username);
var verification = UserValidation.GenerateSalt();
_userMethods.AddVerification(user.Id, verification);
Email.Send("Registration", data.Email, "Verification", new Dictionary <string, string> {
{ "username", data.Username }, { "verification", verification }, { "url", Settings.Url }
}, _emailTemplateMethods);
return(true);
}
public void Submit()
{
//compiles list of existing usernames to check validation
List <string> existingUsernames = new List <string>();
for (int i = 0; i < UserValidation.userList.Count; i++)
{
existingUsernames.Add(UserValidation.userList[i].username);
}
//invalid if username is null
if (username == null || username == "")
{
usernameText.GetComponent <Text>().text = "Invalid Username";
usernameText.GetComponent <Text>().color = Color.red;
usernameText.SetActive(true);
displayTime = 2.5f;
}
//invalid if username already exists
else if (existingUsernames.Contains(username))
{
usernameText.GetComponent <Text>().text = "Username Already Exists";
usernameText.GetComponent <Text>().color = Color.red;
usernameText.SetActive(true);
displayTime = 2.5f;
}
//valid username
else
{
//add to list of users
UserValidation.userList.Add(new User(username, username, "NEW"));
UserValidation.numTrials.Add(3);
UserValidation.Save();
createUserIN.text = "";
usernameText.GetComponent <Text>().text = "User Created";
usernameText.GetComponent <Text>().color = Color.green;
usernameText.SetActive(true);
displayTime = 2.5f;
}
active = false;
}
public void AppleDestroyed()
{
GameObject[] tAppleArray = GameObject.FindGameObjectsWithTag("Apple");
foreach (GameObject tGO in tAppleArray)
{
Destroy(tGO);
}
int basketIndex = basketList.Count - 1;
GameObject tBasketGO = basketList[basketIndex];
basketList.RemoveAt(basketIndex);
Destroy(tBasketGO);
if (basketList.Count == 0)
{
UserValidation.userList[UserValidation.activeUserIndex].AddGame("Apple Picker", Basket.score, UserValidation.userList[UserValidation.activeUserIndex].username, dateTime);
UserValidation.Save();
SceneManager.LoadScene("Main Player Menu");
}
}
public ActionResult UserProfile(Users user)
{
UserValidation userValidation = new UserValidation();
ValidationResult result = userValidation.Validate(user);
if (result.IsValid == false)
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(error.PropertyName, error.ErrorMessage);
}
return(View());
}
else
{
_userService.UpdateUser(user);
TempData["Success"] = "Bilgiler başarıyla güncellendi";
return(View(user));
}
}
private void RenderUserValidationFields()
{
UserValidation userValidation = new UserValidation(Path.Combine(
Request.PhysicalApplicationPath,
"App_Data",
"UserValidation",
Global.Core.ClientName + ".xml"
));
Dictionary <string, List <object[]> > values = Global.Core.UserValidationFieldValues.ExecuteReaderDict <string>(
"SELECT Field, Value FROM [UserValidationFieldValues] WHERE IdUser={0}",
new object[] { Guid.Parse(Request.Params["val"]) }
);
TableRow tr;
TableCell td;
string value;
foreach (string field in userValidation.Fields.Keys)
{
value = null;
if (values.ContainsKey(field))
{
value = (string)values[field][0][1];
}
tr = new TableRow();
td = new TableCell();
td.Text = "<span class=\"Color1\">" + Global.LanguageManager.GetText("UserValidation" + field) + "</span>";
tr.Controls.Add(td);
td = new TableCell();
td.Controls.Add(userValidation.Fields[field].Render(value));
tr.Controls.Add(td);
//tblContent.Controls.AddAt(6, tr);
tblContent.Controls.Add(tr);
}
}
public AccountValidation()
{
_contextFake = new ContextFake().CreateContext();
_dataFake = new DataFake();
_userRepository = new UserRepository(_contextFake);
var accountRepository = (IAccountRepository) new AccountRepository(_contextFake);
var movementRepository = (IMovementRepository) new MovementRepository(_contextFake);
var configurationRepository = (IConfigurationRepository) new ConfigurationRepository(_contextFake);
var userValidation = new UserValidation(_userRepository, configurationRepository);
var sharedService = new SharedService(_userRepository, accountRepository);
IMapper mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap <UserModel, User>();
}).CreateMapper();
_movementService = new MovementService(movementRepository, sharedService);
_accountService = new AccountService(accountRepository, _movementService, sharedService);
_userService = new UserService(_userRepository, accountRepository, _movementService, mapper, userValidation);
}
public void ValidateUserPost()
{
// Arrange
var userService = new Moq.Mock <IUserService>();
userService.Setup(p => p.ValidateUserByNitAndNitDate("", DateTime.Now)).Returns("");
var userValidation = new UserValidation()
{
NitDate = DateTime.Now, Nit = null
};
UserController controller = new UserController(userService.Object);
// Act
ViewResult result = controller.ValidateUser(userValidation) as ViewResult;
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Model);
Assert.AreEqual("Usuarios", result.ViewBag.title);
}
static void Main(string[] args)
{
Console.WriteLine("Login");
var user = new User();
var userInput = new UserInput(user);
userInput.DoInput();
var userValidation = new UserValidation();
if (userValidation.Validation(user))
{
Console.WriteLine("You are login");
}
else
{
Console.WriteLine("Login failed");
}
}
public ActionResult Login(UserValidation user)
{
var useractive = db.Users.Where(x => x.Email == user.Email).FirstOrDefault();
if (useractive.IsActive == false)
{
TempData["Error"] = "გააქტიურე ელ.ფოსტა";
return(RedirectToAction("Login"));
}
string pass = MainHelper.CalculateMD5Hash(user.Password + AuthSecret);
User Us = db.Users.Where(x => x.Email == user.Email && x.Password == pass).FirstOrDefault();
if (Us == null)
{
TempData["Error"] = "ასეთი მომხამარებელი არ არსებობს";
return(RedirectToAction("Login"));
}
Session["user"] = Us;
return(RedirectToAction("Index", "Home"));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
var validator = new UserValidation();
var resultValid = validator.Validate(model);
if (ModelState.IsValid && resultValid.IsValid)
{
var user = new ApplicationUser {
UserName = model.Email, Email = model.Email, City = model.City, PESEL = model.PESEL, PhoneNumber = model.PhoneNumber, SecondName = model.SecondName, FirstName = model.FirstName
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
UserManager.AddToRole(user.Id, "User");
await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);
// Aby uzyskać więcej informacji o sposobie włączania potwierdzania konta i resetowaniu hasła, odwiedź stronę https://go.microsoft.com/fwlink/?LinkID=320771
// Wyślij wiadomość e-mail z tym łączem
// string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
// var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
// await UserManager.SendEmailAsync(user.Id, "Potwierdź konto", "Potwierdź konto, klikając <a href=\"" + callbackUrl + "\">tutaj</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
else
{
foreach (ValidationFailure failer in resultValid.Errors)
{
ModelState.AddModelError(failer.PropertyName, failer.ErrorMessage);
}
}
// Dotarcie do tego miejsca wskazuje, że wystąpił błąd, wyświetl ponownie formularz
return(View(model));
}
private void updateClick_Click(object sender, RoutedEventArgs e)
{
try
{
UserValidation.RegistrationValidation(name1TextBox.Text, name2TextBox.Text, name3TextBox.Text, passportSeriaTextBox.Text, passportNumberTextBox.Text, issuedByTextBox.Text,
date5TextBox.Text, identNumberTextBox.Text, sexComboBox.SelectedIndex + 1, houseTextBox.Text, housingTextBox.Text, flatTextBox.Text, zipCodeTextBox.Text, phoneNumberTextBox.Text,
emailTextBox.Text, regionTextBox.Text, districtTextBox.Text, townTypeComboBox.SelectedIndex + 1, townTextBox.Text, streetTypeComboBox.SelectedIndex + 1,
streetTextBox.Text, "1", "1");
if (housingTextBox.Text.Length == 0)
{
housingTextBox.Text = "0";
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
try
{
this.userService.UpdateUser(name1TextBox.Text, name2TextBox.Text, name3TextBox.Text, passportSeriaTextBox.Text, Convert.ToInt32(passportNumberTextBox.Text), issuedByTextBox.Text,
date5TextBox.Text, identNumberTextBox.Text, sexComboBox.SelectedIndex + 1, houseTextBox.Text, Convert.ToInt32(housingTextBox.Text), flatTextBox.Text, Convert.ToInt32(zipCodeTextBox.Text), Convert.ToInt64(phoneNumberTextBox.Text),
emailTextBox.Text, regionTextBox.Text, districtTextBox.Text, townTypeComboBox.SelectedIndex + 1, townTextBox.Text, streetTypeComboBox.SelectedIndex + 1,
streetTextBox.Text, this.userService.AuthorizedUser);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
return;
}
this.Hide();
LoginedWindows loginedWindows = new LoginedWindows(this.userService, this.mainWindow);
loginedWindows.Show();
}
public async void RegisterUserAsync(UserValidation userValidation, Person person)
{
using (var connection = new SqlConnection(connectionString))
{
await connection.OpenAsync();
using (var command = new SqlCommand())
{
command.Connection = connection;
command.CommandText = "INSERT INTO Person (FirstName, LastName, PhoneNumber, EMail, IsPlayer, IsCoach, IsAdmin, IsValid) " +
"VALUES (@firstName, @lastName, @phoneNumber, @eMail, @IsPlayer, @IsCoach, @IsAdmin, @IsValid)";
command.Parameters.AddWithValue("@firstName", person.FirstName);
command.Parameters.AddWithValue("@lastName", person.LastName);
command.Parameters.AddWithValue("@phoneNumber", person.PhoneNumber);
command.Parameters.AddWithValue("@eMail", person.EMail);
command.Parameters.AddWithValue("@IsPlayer", person.IsPlayer);
command.Parameters.AddWithValue("@IsCoach", person.IsCoach);
command.Parameters.AddWithValue("@IsAdmin", person.IsAdmin);
command.Parameters.AddWithValue("@IsValid", person.IsValid);
await command.ExecuteNonQueryAsync();
command.CommandText = "SELECT * FROM Person WHERE FirstName = @firstName AND LastName = @lastName " +
"AND PhoneNumber = @phoneNumber AND EMAIL = @eMail";
using (var reader = await command.ExecuteReaderAsync())
{
await reader.ReadAsync();
person.PersonId = reader.GetInt32(0);
}
command.CommandText =
"INSERT INTO UserValidation (UserName, PersonId, Password) " +
"VALUES (@userName, @personId, @password)";
command.Parameters.AddWithValue("@userName", userValidation.UserName);
command.Parameters.AddWithValue("@personId", person.PersonId);
command.Parameters.AddWithValue("@password", userValidation.Password);
await command.ExecuteNonQueryAsync();
}
}
}
public bool Add(string firstName, string lastName, DateTime birthdate, string email, string userName, string password)
{
using (StoreContext stContext = new StoreContext())
{
var isExist = stContext.UserList.FirstOrDefault(u => u.UserName == userName);
if (isExist == null && UserValidation.Validation(firstName, lastName, email, password, birthdate))
{
stContext.UserList.Add(new User()
{
Birthdate = birthdate,
FirstName = firstName,
LastName = lastName,
Email = email,
UserName = userName,
Password = password
});
stContext.SaveChanges();
return(true);
}
return(false);
}
}
void BindData()
{
int EnterpriseId = 0;
if (ddlEnterprise.SelectedIndex > 0)
{
EnterpriseId = Convert.ToInt32(ddlEnterprise.SelectedValue);
}
ePower.Core.PagingInfo paging = new ePower.Core.PagingInfo(PageSize, CurrentPage);
UserValidation mem = new UserValidation();
DataTable dt = new MemberService().FindList(Convert.ToInt32(mem.OrgId), EnterpriseId, null, null, null, txtKeyword.Text.Trim(), paging);
grvAdmin.DataSource = dt;
grvAdmin.DataBind();
paging.RowsCount = Convert.ToInt32(dt.Rows[0]["Total"]);
Paging.PageSize = PageSize;
Paging.CurrentPage = CurrentPage;
Paging.TotalRecord = Convert.ToInt32(dt.Rows[0]["Total"]);
Paging.DataLoad();
if (dt != null && dt.Rows.Count > 0)
{
if (Paging.TotalPages <= 1)
{
ltTotal.Text = "Có tổng số " + paging.RowsCount + " tài khoản";
Paging.Visible = false;
}
else
{
ltTotal.Text = "Có " + dt.Rows.Count + " trong tổng số " + paging.RowsCount + " tài khoản";
Paging.Visible = true;
}
}
else
{
ltTotal.Text = "Có tổng số " + paging.RowsCount + " tài khoản";
Paging.Visible = false;
}
}
private bool Validate()
{
var validationResult = UserValidation.Validate(
textBox_Create_Login.Text,
passwordBox_Create_Password.Password,
passwordBox_Create_Password_Copy.Password);
if (validationResult.IsValid)
{
if (_userBusinessComponent.Exists(textBox_Create_Login.Text))
{
MessageBox.Show("A user with such username already exists!");
return(false);
}
return(true);
}
else
{
MessageBox.Show(validationResult.Error);
return(false);
}
}
/// <summary>
/// This method user register details
/// </summary>
/// <param name="user">The user</param>
/// <param name="password">The password</param>
/// <returns></returns>
public async Task <UsersResult> RegisterUser(ApplicationUser user, string password)
{
UserValidation.ValidateUserDetails(user);
List <Errors> errorsList = new List <Errors>();
var identityResult = await this.userDataService.RegisterUser(user, password);
if (identityResult.Errors != null)
{
foreach (var identity in identityResult.Errors)
{
var error = new Errors();
error.Code = identity.Code;
error.Description = identity.Description;
errorsList.Add(error);
}
}
var useResult = new UsersResult {
ErrorList = errorsList, Status = identityResult.Succeeded
};
return(useResult);
}
private void btnAddUser_Click(object sender, EventArgs e)
{
bool success;
var uv = new UserValidation();
//function to validate all user inputs when registering and give error messages if invalid
bool valid = uv.ValidationMessages(txtName.Text, txtUsername.Text, txtPassword.Text, txtPassword2.Text, txtEmail.Text);
//access functions pertaining to registration
var rd = new RegistrationDatabase();
//if validation of all user inputs are valid
if (valid)
{
if (checkboxAdmin.Checked)
{
//insert admin into accounts database table
var admin = new Admins(txtName.Text, txtUsername.Text, txtPassword.Text, txtEmail.Text);
success = rd.AddAccount(admin);
}
else
{
//insert user into accounts database table
var user = new Users(txtName.Text, txtUsername.Text, txtPassword.Text, txtEmail.Text);
success = rd.AddAccount(user);
}
//if added successfully then let user know
if (success)
{
MessageBox.Show("User created successfuly");
Close();
}
else
{
MessageBox.Show("There was a problem while creating this user");
}
}
}
public Task <User> CreateUserAsync(User user, string cep)
{
Console.WriteLine("Iniciando método CreateUserAsync");
try
{
UserValidation userValidation = new UserValidation(user);
FluentResultAdapter.VerificaErros(userValidation.Validate(user));
_repository.CreateUserAsync(user, cep);
return(Task.FromResult(user));
}
catch (BusinessException ex)
{
Console.WriteLine(ex.Message);
throw new BusinessException(ex.Message);
}
finally
{
Console.WriteLine("Método CreateUserAsync finalizado.");
}
}
