public async Task <IActionResult> Edit(int id, [Bind("ProjectUserID,Name,HoursPerWeek,RatePerHour,CreatedBy,CreatedAt,UpdatedBy,UpdatedAt")] UserDM userDM)
{
if (id != userDM.UserID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
userDM.UpdatedAt = DateTime.UtcNow;
userDM.UpdatedBy = userId;
await _userService.Update(userDM);
}
catch (DbUpdateConcurrencyException)
{
if (!_userService.IsUserExist(userDM.UserID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(userDM));
}
public void CanGetAllReviewsForAUser()
{
try
{
string userFirstName = "Dale";
string userLastName = "Cooper";
UserDM testUserDM = GetUser(userFirstName, userLastName);
if (testUserDM == null)
{
Assert.Fail("Could not get Test User needed for this test...");
}
IUserReviewsDataAdapter userReviewsDataAdapter = new UserReviewsDataAdapter();
IList <UserReviewDM> results = userReviewsDataAdapter.GetUserReviewsForUser(testUserDM);
Assert.IsTrue(results != null);
Assert.IsTrue(results.Count > 0);
}
catch (Exception e)
{
Assert.Fail(e.Message);
}
}
public int Save(UserVM vmEntity)
{
var file = vmEntity.ProfileImage;
//byte[] imageByte = null;
//BinaryReader reader = new BinaryReader(file.InputStream);
//imageByte = reader.ReadBytes(file.ContentLength);
string filename = string.Empty;
if (file != null && file.ContentLength > 0)
{
filename = Path.GetFileName(file.FileName);
string imgpath = Path.Combine(System.Web.Hosting.HostingEnvironment.MapPath("/UserProfiles/"), filename);
file.SaveAs(imgpath);
}
UserDM dmEntity = new UserDM();
dmEntity.PositionId = vmEntity.PositionId;
dmEntity.Profile = filename;
dmEntity.Name = vmEntity.Name;
dmEntity.Password = vmEntity.Password;
dmEntity.UserBio = vmEntity.UserBio;
dmEntity.FullAddress = vmEntity.FullAddress;
dmEntity.PhoneNo = vmEntity.PhoneNo;
dmEntity.Email = vmEntity.Email;
dmEntity.CreatedUserId = vmEntity.CreatedUserId;
dmEntity.UpdatedUserId = vmEntity.UpdatedUserId;
dmEntity.Photoshop = vmEntity.Photoshop;
dmEntity.Photography = vmEntity.Photography;
dmEntity.Illustrator = vmEntity.Illustrator;
dmEntity.Media = vmEntity.Media;
dmEntity.PremierePro = vmEntity.PremierePro;
dmEntity.Lightroom = vmEntity.Lightroom;
dmEntity.Burmese = vmEntity.Burmese;
dmEntity.English = vmEntity.English;
dmEntity.Chinese = vmEntity.Chinese;
dmEntity.PackageTitle = vmEntity.PackageTitle;
dmEntity.AboutPackage = vmEntity.AboutPackage;
dmEntity.PackagePrice = vmEntity.PackagePrice;
long time = DateTime.Now.Ticks;
dmEntity.Version = time;
dmEntity.CreatedDate = time;
dmEntity.UpdatedDate = time;
int result = 0; //to know success
using (PHOTOLIODBContext context = new PHOTOLIODBContext())
{
context.UserDMs.Add(dmEntity);
result = context.SaveChanges();
}
return(result);
}
public UserDM LoginControl(string Username, string Password)
{
UserDM udt = new UserDM();
DBUtilities utility = new DBUtilities();
utility.cn.Open();
utility.cmd.CommandText = "sp_Login";
utility.cmd.Parameters.Add("Username", Username);
utility.cmd.Parameters.Add("Password", Password);
SqlDataReader dr = utility.cmd.ExecuteReader();
while (dr.Read())
{
if (dr["Username"].ToString().Trim() == Username && dr["Password"].ToString().Trim() == Password)
{
udt.Username = dr["Username"].ToString().Trim();
udt.Password = dr["Password"].ToString().Trim();
}
}
dr.Close();
utility.endC();
return(udt);
}
public async Task <ActionResult> ShowUser()
{
string id = User.Identity.GetUserId();
var user = await _accountService.GetUserAsync(id);
UserDM userProfile = _identityMapperDM.ToUserDM.Map <User, UserDM>(user);
return(View("ShowUser", userProfile));
}
public async Task Delete(UserDM entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
_context.EmployeeUsers.Remove(entity);
await _context.SaveChangesAsync();
}
/// <summary>
/// Converts a UserSM to a UserDM
/// </summary>
/// <param name="human">UserSM human</param>
/// <returns>UserDM</returns>
private UserDM Map(UserSM human) //Converts for use in the Data Layer
{
UserDM hm = new UserDM();
hm.UserName = human.UserName;
hm.Password = human.Password.CurrentPassword;
hm.SecLev = human.SecLev;
hm.UserId = human.UserId.ToString();
return(hm);
}
public IHttpActionResult Login([FromBody] UserDM user)
{
var foundUser = RC.UserManager.Pull(u => u.Name == user.Name);
if (foundUser != null)
{
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, foundUser.Password == user.Password));
}
return(ResponseUtils.CreateResponse(HttpStatusCode.OK, false));
}
public async Task <IActionResult> Create([Bind("Id,FirstName,LastName,MiddleName")] UserDM user)
{
if (ModelState.IsValid)
{
await _userService.AddAsync(user);
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public ActionResult UserInfo(string name = "")
{
if (name == "")
{
name = User.Identity.Name;
}
UserDM user = _mappers.ToUserDM.Map <UserDTO, UserDM>(_service.GetUserByName(name));
return(View(user));
}
/// <summary>
/// Converts UserDM to UserSM for use on the Logic Layer
/// </summary>
/// <param name="human">UserDM human</param>
/// <returns>UserSM</returns>
private UserSM Map(UserDM human) // Converts for user in the Logic/Presentation Layer
{
UserSM hm = new UserSM();
hm.UserName = human.UserName;
hm.Password.CurrentPassword = human.Password;
hm.SecLev = human.SecLev;
hm.UserId = Convert.ToInt32(human.UserId);
return(hm);
}
public UserDM Map(User user)
{
UserDM person = new UserDM();
person.Id = user.Id;
person.Username = user.Username;
person.Password = user.Password;
person.Role = user.Role;
return(person);
}
public async Task <UserDM> Update(UserDM entity)
{
if (entity == null)
{
throw new ArgumentNullException();
}
_context.EmployeeUsers.Update(entity);
await _context.SaveChangesAsync();
return(entity);
}
public void AddUser(UserDM userDM)
{
UOW.Users.Create(new User
{
FirstName = userDM.FirstName,
LastName = userDM.LastName,
Quantity = 0
});
UOW.Save();
}
public async Task <UserDM> GetByIdAsync(long id)
{
var result = await _userRepository.GetById(id);
var userDM = new UserDM();
userDM.Id = result.Id;
userDM.FirstName = result.FirstName;
userDM.MiddleName = result.MiddleName;
userDM.LastName = result.LastName;
return(userDM);
}
IList <UserReviewDM> IUserReviewsDataAdapter.GetUserReviewsForUser(UserDM userDm)
{
ISelectUserReviewsOperation selectUserReviewsOperation = new SelectUserReviewsOperation();
IList <UserReview> operationResults = selectUserReviewsOperation.SelectByUser(
new User()
{
Id = userDm.Id
});
return(BuildUserReviewDomainModelList(operationResults));
}
/// <summary>
/// Execute a project.
/// </summary>
/// <param name="uid">Id for project.</param>
/// <param name="owner">Owner of a project.</param>
/// <param name="project">Project domain model.</param>
public static void Execute(Guid uid, UserDM owner, PythonProjectDM project)
{
//PyProject p = projects[uid];
//if (p != null)
//{
// dynamic r = p.Execute(code);
// if (r != null)
// {
// p.notify(Convert.ToString(r));
// }
//}
}
public async Task ExecuteAsync(string email)
{
if (await _userExists.QueryAsync(email))
{
return;
}
var user = new UserDM
{
Email = email
};
await _users.InsertOneAsync(user);
}
public async Task <IActionResult> Create([Bind("ProjectUserID,Name,HoursPerWeek,RatePerHour,CreatedBy,CreatedAt,UpdatedBy,UpdatedAt")] UserDM userDM)
{
if (ModelState.IsValid)
{
var userId = User.FindFirst(ClaimTypes.NameIdentifier).Value;
userDM.CreatedAt = DateTime.UtcNow;
userDM.CreatedBy = userId;
await _userService.Create(userDM);
return(RedirectToAction(nameof(Index)));
}
return(View(userDM));
}
UserDM IUsersDataAdapter.GetUserById(int userId)
{
UserDM results = null;
var filteredResults = ((IUsersDataAdapter)this).GetAllUsers().Where(x => x.Id == userId).ToList <UserDM>();
if (filteredResults != null && filteredResults.Count > 0)
{
results = filteredResults.SingleOrDefault <UserDM>();
}
return(results);
}
public async Task UserServiceAdd_TestAsync()
{
var user = new UserDM
{
FirstName = "Mohammed",
MiddleName = "Tanbir",
LastName = "Hossain"
};
var actualResult = await _userService.AddAsync(user);
var expectedResult = true;
Assert.AreEqual(expectedResult, actualResult);
}
UserDM IUsersDataAdapter.GetUserByName(string firstName, string lastName)
{
UserDM results = null;
var filteredResults = ((IUsersDataAdapter)this).GetAllUsers().Where(x => x.FirstName == firstName &&
x.LastName == lastName).ToList <UserDM>();
if (filteredResults != null && filteredResults.Count > 0)
{
results = filteredResults.SingleOrDefault <UserDM>();
}
return(results);
}
public void Map_UserToUserDM_Test()
{
//Arrange
User user = MockUsers1[0];
UserDM user2 = new UserDM();
UserLogic target = new UserLogic(userData, hashData, logData);
//Act
user2 = target.Map(user);
//Assert
Assert.IsNotNull(user2);
Assert.AreEqual(user.Username, user2.Username);
Assert.AreEqual(user.Password, user2.Password);
Assert.AreEqual(user.Id, user2.Id);
}
public async Task Return_user()
{
// Arrange
const string email = "*****@*****.**";
UserDM user = new UserDM {
Email = email
};
Db.Users.InsertOne(user);
// Act
var result = await new UserQuery(Db).QueryAsync(email);
// Assert
Assert.Equal(user.Email, result.Email);
}
public async Task <IActionResult> Edit(long id, [Bind("Id,FirstName,LastName,MiddleName")] UserDM user)
{
if (id != user.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _userService.UpdateAsync(user);
return(RedirectToAction(nameof(Index)));
}
return(View(user));
}
public void CreateUserTest()
{
//Arrange
User user = MockUsers1[0];
UserDM user2 = MockUsers2[0];
userData.Expect(mock => mock.AddUser(Arg <UserDM> .Is.Anything));
logData.Expect(mock => mock.LogError("Event", "The user was able to create an user", "Class: UserLogic & Method Name: CreateUser"));
UserLogic target = new UserLogic(userData, hashData, logData);
//Act
target.CreateUser(user);
//Assert
userData.VerifyAllExpectations();
logData.VerifyAllExpectations();
}
public async Task <bool> SaveUser(UserDM model)
{
bool result = false;
//var user = new User()
//{
// FirstName = model.FirstName,
// LastName = model.LastName,
// Email = model.Email,
// UserName = model.UserName
//};
//IdentityResult result = await userManager.CreateAsync(user, model.Password);
return(result);
}
public async Task Return_true_if_user_exists()
{
// Arrange
const string email = "*****@*****.**";
UserDM user = new UserDM {
Email = email
};
Db.Users.InsertOne(user);
// Act
var result = await new UserExistsQuery(Db).QueryAsync(email);
// Assert
Assert.True(result);
}
public async Task <bool> AddAsync(UserDM userDM)
{
try
{
var obj = new TblUser();
obj.FirstName = userDM.FirstName;
obj.MiddleName = userDM.MiddleName;
obj.LastName = userDM.LastName;
var result = await _userRepository.Add(obj);
return(result);
}
catch (Exception ex)
{
return(false);
}
}
public UserView(UserDM user)
{
UserID = user.UserID;
FirstName = user.FirstName;
LastName = user.LastName;
Quantity = user.Quantity;
List <BookView> MyBooks = new List <BookView>();
if (user.Books != null)
{
foreach (var b in user.Books)
{
MyBooks.Add(new BookView(b));
}
}
Books = MyBooks;
}
