public void UpdateShouldNotCreateNewEntryTest()
{
var repository = _fixture.Container.GetInstance <IRepository <PasswordEntity> >();
repository.EnsureRepository();
var passwordEntity = new PasswordEntity
{
CommonName = "Amazon",
Url = "www.amazon.com",
UserName = "******",
Password = "******"
};
string id = repository.Insert(passwordEntity);
var recordCount = repository.GetAll().Count();
bool success = repository.Update(new PasswordEntity
{
Id = id,
CommonName = "UpdateAmazon",
Url = "Updatewww.amazon.com",
UserName = "******",
Password = "******"
});
success.ShouldBe(true);
repository.GetAll().Count().ShouldBe(recordCount);
var updateItem = repository.GetById(id, Cloner);
updateItem.UserName.ShouldBe("*****@*****.**");
}
//public Object SignOut(Boolean pManualEclockLogout)
//{
// try
// {
// SessionManager.CurrentUser = null;
// SessionManager.AbandonSession();
// HttpContext.Current.Response.Cache.SetCacheability(HttpCacheability.NoCache);
// HttpContext.Current.Response.Cache.SetExpires(DateTime.UtcNow.AddSeconds(-1));
// HttpContext.Current.Response.Cache.SetNoStore();
// if (HttpContext.Current.Request.Cookies["breadcrumbs"] != null)
// {
// HttpCookie myCookie = new HttpCookie("breadcrumbs");
// myCookie.Expires = DateTime.UtcNow.AddDays(-1d);
// HttpContext.Current.Response.Cookies.Add(myCookie);
// }
// return ResponseResult.GetSuccessObject();
// //var result = new
// //{
// // success = true,
// // error = ""
// //};
// //return (result);
// }
// catch (Exception ex)
// {
// CustomUtility.HandleException(ex);
// return ResponseResult.GetErrorObject("Email not correct");
// }
//}
public ResponseResult ResetPassword(PasswordEntity pass)
{
if (PUCIT.AIMRL.SFP.UI.Common.SessionManager.LogsInAsOtherUser == true)
{
return(ResponseResult.GetErrorObject("You Are Not Allowed"));
}
try
{
var password = pass.NewPassword;
if (GlobalDataManager.IgnoreHashing == false)
{
password = PasswordSaltedHashingUtility.HashPassword(pass.NewPassword);
}
var flag = DataService.UpdatePassword(pass.Token, "", password, 0, DateTime.UtcNow, false);
if (flag)
{
return(ResponseResult.GetSuccessObject(null, "Password is reset"));
}
else
{
return(ResponseResult.GetErrorObject("Reset is failed"));
}
}
catch (Exception ex)
{
CustomUtility.HandleException(ex);
return(ResponseResult.GetErrorObject());
}
}
public void UpdateWithCopierShouldNotCreateNewEntryTest()
{
//Update
var repository = _fixture.Container.GetInstance <IRepository <PasswordEntity> >();
repository.EnsureRepository();
var passwordEntity = new PasswordEntity
{
CommonName = "Amazon",
Url = "www.amazon.com",
UserName = "******",
Password = "******"
};
string id = repository.Insert(passwordEntity);
var recordCount = repository.GetAll().Count();
var item = repository.Update(id, entity =>
{
entity.CommonName = "UpdateCommonName";
entity.Password = "******";
entity.Url = "UpdatedUrl";
entity.UserName = "******";
});
item.ShouldNotBeNull();
repository.GetAll().Count().ShouldBe(recordCount);
var updateItem = repository.GetById(id, Cloner);
updateItem.UserName.ShouldBe("UpdatedUserName");
}
public async Task <IActionResult> Create([FromBody] HeaderRequest request)
{
UsernameEntity user = new UsernameEntity()
{
Username = request.Username,
Email = request.Email
};
bool check = await _user.CheckUser(user);
if (check)
{
string id = await _user.addUser(user);
if (!string.IsNullOrEmpty(id))
{
PasswordEntity pass = new PasswordEntity()
{
UserId = id,
Password = BCrypt.Net.BCrypt.HashPassword(request.Password, 11)
};
int wait = await _pass.CreatePassword(pass);
return(Ok());
}
}
return(BadRequest("User"));
}
public async Task <LogicResult> ChangePassword(ChangePasswordDto dto)
{
SessionService.CheckSession(dto.Session);
int userId = dto.Session.UserId.GetValueOrDefault();
IEnumerable <PasswordEntity> passwords = await PasswordRepo.GetByUserId(userId);
PasswordEntity lastPassword = passwords.OrderByDescending(pwd => pwd.ChangeDateTime).FirstOrDefault();
if (lastPassword == null || lastPassword.Value != dto.Password)
{
PasswordEntity newPassword = new PasswordEntity()
{
AccountId = userId,
ChangeDateTime = DateTime.Now,
Value = dto.Password
};
await PasswordRepo.Insert(newPassword);
return(LogicResult.TRUE_RESULT);
}
return(LogicResult.FALSE_RESULT);
}
public async void unit_test_PostPassword_Success_Content(string username, string pass)
{
//Arrange
UsernameEntity user = new UsernameEntity()
{
Username = username
};
//Act
var PostUser = await _uut.PostUsername(user);
var OkUser = PostUser as OkObjectResult;
var userId = OkUser.Value as string;
PasswordEntity test = new PasswordEntity()
{
Password = pass, UserId = userId
};
var result = await _uut.PostPassword(test);
var okResult = result as OkObjectResult;
var JWT = okResult.Value as string;
//Assert
Xunit.Assert.Equal(316, JWT.Length);
}
public async Task <IActionResult> Update([FromBody] HeaderRequest request)
{
int wait = 0;
UsernameEntity user = new UsernameEntity();
user.UserId = User.Identity.Name;
if (request.Username != null)
{
user.Username = request.Username;
wait = await _user.updateUsername(user);
}
if (request.Email != null)
{
user.Email = request.Email;
wait = await _user.updateEmail(user);
}
if (request.Password != null)
{
PasswordEntity pass = new PasswordEntity();
pass.UserId = User.Identity.Name;
pass.Password = request.Password;
wait = await _pass.updatePassword(pass);
}
if (wait > 0)
{
return(Ok());
}
return(BadRequest());
}
/// <summary>
/// Add a new password-element to the XML.
/// </summary>
/// <param name="password">The password with all the properties.</param>
/// <returns>If the XML has been added or not.</returns>
public bool AddNewPassword(PasswordEntity password)
{
XElement newPassword = GetNewPasswordElement(password);
_xmlDocument.Element("Passwords").Add(newPassword);
_xmlDocument.Save(_filename);
return(true);
}
public JsonResult forgotpassword(string Email, string resetPasswordUrl)
{
LoginRadiusApiOptionalParams _apiOptionalParams = new LoginRadiusApiOptionalParams();
_apiOptionalParams.ResetPasswordUrl = resetPasswordUrl;
_apiOptionalParams.EmailTemplate = "emailTemplate";
var apiResponse = new PasswordEntity().ForgotPassword(Email, _apiOptionalParams);
return(Json(apiResponse, JsonRequestBehavior.AllowGet));
}
public PasswordEntity Put(string id, [FromBody] PasswordEntity entity)
{
return(_repository.Update(id, passwordEntity =>
{
passwordEntity.CommonName = entity.Password;
passwordEntity.Password = entity.Password;
passwordEntity.Url = entity.Url;
passwordEntity.UserName = entity.UserName;
}));
}
public JsonResult ChangePassword(string OldPassword, string NewPassword)
{
ChangePasswordModel model = new ChangePasswordModel();
model.OldPassword = OldPassword;
model.NewPassword = NewPassword;
var response = new PasswordEntity().ChangePassword(Session["access_token"].ToString(), model);
return(Json(response, JsonRequestBehavior.AllowGet));
}
private PasswordEntity Cloner(PasswordEntity passwordEntity)
{
return(new PasswordEntity
{
Id = passwordEntity.Id,
Password = passwordEntity.Password,
UserName = passwordEntity.UserName,
Url = passwordEntity.Url,
CommonName = passwordEntity.CommonName
});
}
/// <summary>
/// Add a password
/// </summary>
/// <param name="passwordItem"></param>
public PasswordEntity AddPassword(PasswordEntity passwordItem)
{
if (passwordItem == null)
{
throw new ArgumentNullException(nameof(passwordItem));
}
_context.Passwords.Add(passwordItem);
return(passwordItem);
}
public void Post(PasswordEntity item)
{
//Todo A good coder would put error handling in here...
async void Insert()
{
TableOperation insertOperation = TableOperation.Insert(item);
await passwordsTable.ExecuteAsync(insertOperation);
}
Insert();
}
/// <summary>
/// Get a new password-element for XML.
/// </summary>
/// <param name="password">The password with all the properties.</param>
/// <returns>The element for XML.</returns>
private XElement GetNewPasswordElement(PasswordEntity password)
{
var element = new XElement("PasswordEntity",
GetNewXmlElement("Title", password.Title),
GetNewXmlElement("Username", password.Username),
GetNewXmlElement("Password", password.Password),
GetNewXmlElement("Url", password.Url),
GetNewXmlElement("Extra", password.Extra));
element.SetAttributeValue("Id", password.Id.ToString());
return(element);
}
public async Task <IActionResult> PostPassword([FromBody] PasswordEntity data)
{
bool valid = await _pass.validatePassword(data);
if (valid)
{
TokenControl myToken = new TokenControl(_configuration);
string token = myToken.GenerateToken(data.UserId);
return(Ok(token));
}
return(BadRequest());
}
/// <summary>
/// Create a basic XML-file.
/// </summary>
private void CreateBasicXmlFile()
{
PasswordEntity emptyPassword = new PasswordEntity();
emptyPassword.Title = "New password";
emptyPassword.Username = "******";
emptyPassword.Password = "******";
XElement xml = new XElement("Passwords",
GetNewPasswordElement(emptyPassword));
_xmlDocument.Add(xml);
_xmlDocument.Save(_filename);
}
public async void unit_test_ValidatePassword(string id, string password, bool exp)
{
//Arrange
PasswordEntity test = new PasswordEntity()
{
UserId = id,
Password = password
};
//Act
var result = await _uut.validatePassword(test);
//Assert
Xunit.Assert.Equal(exp, result);
}
public async Task <string> Handle(CreatePasswordCommand request, CancellationToken cancellationToken)
{
var passwordEntity = new PasswordEntity
{
Id = Guid.NewGuid().ToString(),
CreatedDate = DateTime.UtcNow,
Hash = _passwordHelper.ComputeHash(request.Password),
UserId = request.UserId
};
await _passwordRepository.CreatePasswordAsync(passwordEntity, cancellationToken);
return(passwordEntity.Id);
}
public Object changePassword(PasswordEntity pass)
{
if (PUCIT.AIMRL.TLS.UI.Common.SessionManager.LogsInAsOtherUser == true)
{
return(new
{
success = false,
error = "You Are Not Allowed"
});
}
try
{
// var emailid = EncryptDecryptUtility.Decrypt(pass.ID);
var id = DataService.changePassword(pass);
if (id == 0)
{
return(new
{
data = new
{
Id = id
},
success = false,
error = "Wrong Password"
});
}
else
{
return(new
{
data = new
{
Id = id
},
success = true,
error = "Password Changed"
});
}
}
catch (Exception ex)
{
return(new
{
success = false,
error = "Some Error has occurred"
});
}
}
public PasswordEntity UpdatePassword(int originalId, PasswordEntity newPasswordItem)
{
var originalPasswordItem = _context.Passwords.FirstOrDefault(it => it.Id == originalId);
if (originalPasswordItem == null)
{
AddPassword(newPasswordItem);
}
originalPasswordItem = newPasswordItem;
_context.Update(originalPasswordItem);
return(newPasswordItem);
}
public void RepositoryEntityReferenceTest()
{
var repository = _fixture.Container.GetInstance <IRepository <PasswordEntity> >();
repository.EnsureRepository();
var passwordEntity = new PasswordEntity
{
CommonName = "Amazon",
Url = "www.amazon.com",
UserName = "******",
Password = "******"
};
repository.Insert(passwordEntity).ShouldNotBeNullOrEmpty();
}
/// <summary>
/// Updates the values for a specific password.
/// </summary>
/// <param name="password">The password with all the properties.</param>
/// <returns>If the XML has been updated or not.</returns>
public bool UpdatePassword(PasswordEntity password)
{
bool result = DeletePassword(password);
if (!result)
{
return(false);
}
result = AddNewPassword(password);
if (!result)
{
return(false);
}
return(true);
}
public Task <IActionResult> SavePassword([FromBody] PasswordEntity password)
{
return(this.JsonInvokeAsync(() => {
if (password == null)
{
throw new InvalidOperationException("No data!");
}
if (string.IsNullOrEmpty(password.Old))
{
throw new InvalidOperationException("Old password cannot be empty!");
}
if (string.IsNullOrEmpty(password.New))
{
throw new InvalidOperationException("New password cannot be empty!");
}
if (string.IsNullOrEmpty(password.Confirm))
{
throw new InvalidOperationException("Confirm password cannot be empty!");
}
if (!password.New.Equals(password.Confirm))
{
throw new InvalidOperationException("Different confirm password!");
}
var userId = password.UserId ?? this.CurrentUser().Id;
var collection = this.GetMonCollection <User>();
var user = collection.FindOne(x => x.Id.Equals(userId));
if (!this.LoginManager().VerifyPassword(user, password.Old))
{
throw new InvalidOperationException("Invalid old password!");
}
collection.ReplaceOne(x => x.Id.Equals(user.Id),
this.LoginManager().SetPassword(user, password.New));
}));
}
public ActionResult resetpasword(ReSetPasswordModel model)
{
model.resettoken = model.VToken;
var apiResponse = new PasswordEntity().ReSetPassword(model);
if (apiResponse.Response != null)
{
if (apiResponse.Response.IsPosted)
{
return(RedirectToAction("Index"));
}
else
{
return(View(model));
}
}
else
{
return(View(model));
}
}
public async void unit_test_CreatePassword()
{
//Arrange
PasswordEntity test = new PasswordEntity()
{
UserId = "Test-id-1",
Password = BCrypt.Net.BCrypt.HashPassword("TestPass")
};
PasswordEntity control = new PasswordEntity()
{
UserId = "Test-id-1",
Password = "******"
};
//Act
var create = await _uut.CreatePassword(test);
var result = await _uut.validatePassword(control);
//Assert
Xunit.Assert.Equal(true, result);
}
public int changePassword(PasswordEntity pass)
{
var username = SessionManager.GetUserLogin();
using (var db = new PRMDataContext())
{
var query = db.Users.Where(x => (x.Login == username) && (x.Password == pass.CurrentPassword)).FirstOrDefault();
if (query != null)
{
query.Password = pass.NewPassword;
db.SaveChanges();
return(1);
}
else
{
return(0);
}
}
}
public async void unit_test_PostPassword_fail()
{
//Arrange
UsernameEntity user = new UsernameEntity()
{
Username = "******"
};
//Act
var PostUser = await _uut.PostUsername(user);
var OkUser = PostUser as OkObjectResult;
var userId = OkUser.Value as string;
PasswordEntity test = new PasswordEntity()
{
Password = "******", UserId = userId
};
var result = await _uut.PostPassword(test);
//Assert
Xunit.Assert.IsType <BadRequestResult>(result);
}
public async void unit_test_PostPassword_Success(string username, string pass)
{
//Arrange
UsernameEntity user = new UsernameEntity()
{
Username = username
};
//Act
var PostUser = await _uut.PostUsername(user);
var OkUser = PostUser as OkObjectResult;
var userId = OkUser.Value as string;
PasswordEntity test = new PasswordEntity()
{
Password = pass, UserId = userId
};
var result = await _uut.PostPassword(test);
//Assert
Xunit.Assert.IsType <OkObjectResult>(result);
}
/// <summary>
/// Delete a password from XML.
/// </summary>
/// <param name="password">The password with all its properties.</param>
/// <returns>If the XML has been changed or not.</returns>
public bool DeletePassword(PasswordEntity password)
{
XElement element = null;
foreach (var item in _xmlDocument.Descendants("PasswordEntity"))
{
if (Guid.Parse(item.Attribute("Id").Value) == password.Id)
{
element = item;
break;
}
}
if (element == null)
{
return(false);
}
element.Remove();
_xmlDocument.Save(_filename);
return(true);
}
private UserContext AddUserToDatabase(string firstName, string lastName, string login, string password, UserRole role)
{
if (String.IsNullOrEmpty(firstName))
throw new ArgumentNullException("firstName is null");
if (String.IsNullOrEmpty(lastName))
throw new ArgumentNullException("lastName is null");
if (String.IsNullOrEmpty(login))
throw new ArgumentNullException("login is null");
if (String.IsNullOrEmpty(password))
throw new ArgumentNullException("password is null");
UserContextEntity newUser = null;
using (var db = new DataAccessProvider())
{
//sprawdzenie czy dany login już istnieje
var userSameLogin = db.Users.FirstOrDefault(u => u.Role == role && u.Login == login);
if (userSameLogin != null)
throw new ArgumentException(String.Format("There already is an user with login = {0}.", login));
newUser = new UserContextEntity()
{
Login = login,
FirstName = firstName,
LastName = lastName,
Role = role
};
newUser = db.Users.Add(newUser);
db.SaveChanges();
var userPassword = new PasswordEntity() { UserId = newUser.Id, Hash = HashClass.CreateSecondHash(password) };
db.Passwords.Add(userPassword);
db.SaveChanges();
}
return new UserContext(newUser);
}
public UserContext AddWaiter(int managerId, string firstName, string lastName, string login, string password)
{
if (!CheckHasUserRole(managerId, UserRole.Manager))
throw new SecurityException(String.Format("User id = {0} is not logged in or is no manager", managerId));
if (String.IsNullOrEmpty(firstName))
throw new ArgumentNullException("firstName");
if (String.IsNullOrEmpty(lastName))
throw new ArgumentNullException("lastName");
if (String.IsNullOrEmpty(login))
throw new ArgumentNullException("login");
if (String.IsNullOrEmpty(password))
throw new ArgumentNullException("password");
UserContextEntity newWaiterContextEntity = null;
using (var db = new DataAccessProvider())
{
var waiterContextToAdd = new UserContextEntity() { FirstName = firstName, LastName = lastName, Login = login, Role = UserRole.Waiter};
var usersSameLogin = db.Users.Where(u => u.Role == UserRole.Waiter && u.Login.Equals(login));
if (usersSameLogin != null && usersSameLogin.Any())
{
foreach (UserContextEntity userContextEntity in usersSameLogin)
if (userContextEntity.Equals(waiterContextToAdd))
{
if (userContextEntity.IsDeleted)
userContextEntity.IsDeleted = false;
newWaiterContextEntity = userContextEntity;
break;
}
//istnieją kelnerzy o tym samym loginie, ale nie są tacy sami jak ten co chcemy dodać.
if(newWaiterContextEntity == null)
throw new ArgumentException(String.Format("login = {0} already exists in database!", login));
}
if(newWaiterContextEntity == null)
newWaiterContextEntity = db.Users.Add(waiterContextToAdd);
db.SaveChanges();
PasswordEntity newWaiterPassword = db.Passwords.FirstOrDefault(p => p.UserId == newWaiterContextEntity.Id);
if (newWaiterPassword == null)
{
newWaiterPassword = new PasswordEntity()
{
UserId = newWaiterContextEntity.Id,
Hash = HashClass.CreateSecondHash(password)
};
db.Passwords.Add(newWaiterPassword);
db.SaveChanges();
}
else
{
newWaiterPassword.Hash = HashClass.CreateSecondHash(password);
db.Entry(newWaiterPassword).State = EntityState.Detached;
db.Passwords.Attach(newWaiterPassword);
db.Entry(newWaiterPassword).State = EntityState.Modified;
db.SaveChanges();
}
}
return new UserContext(newWaiterContextEntity);
}
