public async Task <bool> DeleteUser(string id)
{
ClientProfile profile = Database.ClientManager.FindById(id);
if (profile != null)
{
Database.ClientManager.DeleteProfile(profile);
}
LibraryUser user = await Database.UserManager.FindByIdAsync(id);
if (user != null)
{
IdentityResult result = await Database.UserManager.DeleteAsync(user);
if (result.Succeeded)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
static void Main(string[] args)
{
Console.InputEncoding = Encoding.UTF8;
Console.OutputEncoding = Encoding.UTF8;
Human Alex = new Human("Alex", "Carnell", 03, 02, 2001);
Console.WriteLine("Клас Human\nІм`я: {0}\nПрізвіще: {1}\nДата народження: {2}\n", Alex.NameHuman, Alex.SecondNameHuman, Alex.BirthdayDateHuman);
Graduate Bill = new Graduate("Bill", "Morton", "23.03.2003", 185, 11, "school_27");
Console.WriteLine("Клас Graduate\nІм`я: {0}\nПрізвіще: {1}\nДата народження: {2}\nБал ЗНО: {3}\nБал документа: {4}\nОсвітній заклад: {5}\n", Bill.NameHuman, Bill.SecondNameHuman, Bill.BirthdayDateHuman, Bill.ZNOPointsGraduate, Bill.DocPointsGraduate, Bill.SchoolNameGraduate);
Student TomNorton = new Student("Tom", "Norton", "17.07.2002", 1, "ІПЗ-20-1", "ФІКТ", "Житомирська політехніка");
Console.WriteLine("Клас Student\nІм`я: {0}\nПрізвіще: {1}\nДата народження: {2}\nКурс: {3}\nГрупа: {4}\nФакультет: {5}\nУніверситет: {6}\n", TomNorton.NameHuman, TomNorton.SecondNameHuman, TomNorton.BirthdayDateHuman, TomNorton.CourseStudent, TomNorton.GroupStudent, TomNorton.FacultyStudent, TomNorton.UniversityStudent);
Professor ProfessorAlbert = new Professor("Albert", "Lindsay", 15, 04, 1973, "Старший викладач кафедри", "ІПЗ", "Житомирська політехніка");
Console.WriteLine("Клас Professor\nІм`я: {0}\nПрізвіще: {1}\nДата народження: {2}\nПосада: {3}\nКафедра: {4}\nОсвітній заклад: {5}\n", ProfessorAlbert.NameHuman, ProfessorAlbert.SecondNameHuman, ProfessorAlbert.BirthdayDateHuman, ProfessorAlbert.PosadaProfessor, ProfessorAlbert.CathedraProfessor, ProfessorAlbert.UniversityProfessor);
LibraryUser AgathaWade = new LibraryUser("Agatha", "Wade", "17.07.2002", 1734, "5.03.2019", 700);
Console.WriteLine("Клас LibraryUser\nІм`я: {0}\nПрізвіще: {1}\nДата народження: {2}\nНомер читацького квитка: {3}\nДата видачі: {4}\nЧитацький внесок: {5}\n", AgathaWade.NameHuman, AgathaWade.SecondNameHuman, AgathaWade.BirthdayDateHuman, AgathaWade.NumberLibraryUser, AgathaWade.DateVidachiLibraryUser, AgathaWade.VnesokLibraryUser);
Alex.NameHuman = "Alexandr";
Bill.SchoolNameGraduate = "school_5";
TomNorton.CourseStudent = 2;
ProfessorAlbert.UniversityProfessor = "Univetsity Franka";
AgathaWade.SecondNameHuman = "Askvit";
Alex.ShowInfo();
Bill.ShowInfo();
TomNorton.ShowInfo();
ProfessorAlbert.ShowInfo();
AgathaWade.ShowInfo();
}
public List <LibraryUser> GetAllLibraryUsers()
{
var libraryUsers = new List <LibraryUser>();
using (var connection = new SqlConnection(ConnectionString))
{
connection.Open();
var dataReader = new SqlCommand(GetAllLibraryUsersQuery, connection).ExecuteReader();
while (dataReader.Read())
{
var libraryUser = new LibraryUser()
{
Id = dataReader.GetInt32(0),
Firstname = dataReader.GetString(1),
Lastname = dataReader.GetString(2),
CardIdentifier = dataReader.GetString(3),
};
libraryUsers.Add(libraryUser);
}
dataReader.Close();
}
return(libraryUsers);
}
public ActionResult Return(int Book_Id)
{
int userId = (int)Session["UserId"];
BookCorrect book = new BookCorrect();
LibraryUser libraryUser = new LibraryUser();
foreach (var item in db.LibraryUser)
{
if (item.User_Id == userId)
{
libraryUser = item;
break;
}
}
foreach (var item in db.BookCorrect)
{
if (item.Book_Id == Book_Id)
{
book = item;
break;
}
}
book.User_Id = null;
book.LibraryUser = null;
libraryUser.BookCorrect.Remove(book);
db.SaveChanges();
return(RedirectToAction("Index", "BookCorrects"));
}
public void ResetPass(string id, string newPass)
{
LibraryUser user = Database.UserManager.FindById(id);
user.PasswordHash = Database.UserManager.PasswordHasher.HashPassword(newPass);
Database.SaveAsync();
}
public BorrowBookTransaction(LibraryUser libUser, BookCopy bookCopy)
: base(bookCopy)
{
_BookCopyService = new BookCopyService();
_HolidayService = new HolidayService();
_BookInfoService = new BookService();
_SectionService = new SectionService();
var bookInfo = _BookInfoService.BookInfoOf(BookCopy);
var section = _SectionService.GetBookSection(bookInfo);
if (section == null)
{
throw new InvalidOperationException("The book does not belong to a section.");
}
if (section.MaxDaysAllowedForBorrowing == 0)
{
TransactionType = "Not Allowed For Borrowing.";
}
bookTransInfo = new TransactionInfo
{
BookCopyId = BookCopy.Id,
LibraryUserId = libUser.Id,
BorrowDate = TransactionDate,
ExpectedReturnDate = _HolidayService.GetNonHolidayDateFrom(TransactionDate.AddDays(section.MaxDaysAllowedForBorrowing))
};
}
public ActionResult Register(RegistrationViewModel model)
{
LibraryUser user = new LibraryUser {
Username = model.Username, Admin = false, Password = model.Password, BookCorrect = null
};
foreach (LibraryUser u in db.LibraryUser.ToList())
{
if (u.Username.Equals(model.Username))
{
ModelState.AddModelError("", "User with that username already exists.");
return(View(model));
}
}
if (ModelState.IsValid)
{
if (model.Password.Length < 6)
{
ModelState.AddModelError("", "Password must have at least 6 characters");
return(View(model));
}
if (!model.Password.Equals(model.ConfirmPassword))
{
ModelState.AddModelError("", "The password and confirmation password do not match.");
return(View(model));
}
db.LibraryUser.Add(user);
db.SaveChanges();
return(RedirectToAction("Login"));
}
return(View());
}
public static IEnumerable <LibraryUser> GetUsers()
{
var users = new List <LibraryUser>();
for (int i = 1; i < 10; i++)
{
var user = new LibraryUser()
{
FirstName = "FirstName" + i,
LastName = "LastName" + i,
PESEL = Convert.ToInt64("1000000000" + i),
Email = "user" + i + "@testmail.pl",
Street = "Teststreet" + i,
ApartmentNumber = i,
PostalCode = "00-00" + i,
City = "TestCity",
DateOfBirth = DateTime.Parse("2005/05/05"),
RegistrationDate = DateTime.Now,
};
users.Add(user);
}
return(users);
}
public async Task <IActionResult> PostUser([FromBody] RegistrationViewModel model)
{
if (ModelState.IsValid)
{
var user = new LibraryUser
{
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(await _userManager.FindByEmailAsync(user.Email), "User");
await _signInManager.SignInAsync(user, isPersistent : false);
return(await GenerateJwtToken(model.Email, user));
}
return(BadRequest(result));
}
return(BadRequest());
}
public async void Create_ReturnsUser()
{
Mock <IDbCommand> command = new Mock <IDbCommand>();
Mock <IDataParameterCollection> parameters = new Mock <IDataParameterCollection>();
Mock <IDataReader> reader = new Mock <IDataReader>();
bool called = false;
reader.Setup(r => r.Read()).Returns(() => { bool result = !called; called = true; return(result); });
reader.Setup(r => r.GetInt32(0)).Returns(1);
reader.Setup(r => r.GetString(1)).Returns("name");
reader.Setup(r => r.GetString(2)).Returns("username");
reader.Setup(r => r.GetString(3)).Returns("superadmin");
reader.Setup(r => r.IsDBNull(4)).Returns(true);
command.SetupGet(c => c.Parameters).Returns(parameters.Object);
command.Setup(c => c.ExecuteReader()).Returns(reader.Object);
_connection.Setup(c => c.CreateCommand()).Returns(command.Object);
var expected = new LibraryUser(1, "name", "username", new[] { "superadmin" }, new Book[] { });
UserRepository repository = CreateRepository();
DateTime now = DateTime.UtcNow;
LibraryUser actual = await repository.Create(
new LibraryUser(1, "user", "username", new Book[] { })
);
Assert.Equal(expected, actual);
}
private async Task <IActionResult> GenerateJwtToken(string email, LibraryUser user)
{
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
};
var userRoles = await _userManager.GetRolesAsync(user);
foreach (var userRole in userRoles)
{
claims.Add(new Claim(ClaimTypes.Role, userRole));
}
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["JwtKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var expires = DateTime.Now.AddDays(Convert.ToDouble(_configuration["JwtExpireDays"]));
var token = new JwtSecurityToken(
_configuration["JwtIssuer"],
_configuration["JwtIssuer"],
claims,
expires: expires,
signingCredentials: creds
);
return(Ok(new { token = new JwtSecurityTokenHandler().WriteToken(token) }));
}
static void Main(string[] args)
{
// 8) declare 2 objects. Use default and paremeter constructors
LibraryUser user1 = new LibraryUser(), user2 = new LibraryUser("Maria", "Ivanenko", "+380447777777", 2);
Console.WriteLine("User1 " + user1.FirstName + " " + user1.LastName);
Console.WriteLine("User2 " + user2.FirstName + " " + user2.LastName);
// 9) do operations with books for all users: run all methods for both objects
Console.WriteLine("User 1: add Harry Potter");
user1.AddBook("Harry Potter");
Console.WriteLine("User 2: add Sherlock Holmes");
user2.AddBook("Sherlock Holmes");
Console.WriteLine("user1.BooksCount = " + user1.BooksCount() + "; user2.BooksCount " + user2.BooksCount());
Console.WriteLine("user2 :");
Console.WriteLine("Add Kobzar");
user2.AddBook("Kobzar");
Console.WriteLine("user2.BooksCount " + user2.BooksCount());
Console.WriteLine("Add Dorian Gray");
user2.AddBook("Dorian Gray");
Console.WriteLine("user2.BooksCount " + user2.BooksCount());
Console.WriteLine("user2 books " + user2[0] + "\n" + user2[1]);
Console.WriteLine("Remove Sherlock Holmes");
user2.RemoveBook("Sherlock Holmes");
Console.WriteLine("user2.BooksCount " + user2.BooksCount());
}
public async void GetWithUsername_ThrowsException_Logged()
{
Mock <IDbCommand> command = new Mock <IDbCommand>();
Mock <IDataParameterCollection> parameters = new Mock <IDataParameterCollection>();
command.SetupGet(c => c.Parameters).Returns(parameters.Object);
command.Setup(c => c.ExecuteReader()).Throws(new Exception("Bang!"));
_connection.Setup(c => c.CreateCommand()).Returns(command.Object);
var expected = new LibraryUser(1, "name", "username", new[] { "superadmin" }, new Book[] { });
UserRepository repository = CreateRepository();
await repository.Get("username");
_logger.Verify(l =>
l.Log(
LogLevel.Error,
It.IsAny <EventId>(),
It.IsAny <FormattedLogValues>(),
It.Is <Exception>(e => e.Message.Contains("Bang!")),
It.IsAny <Func <object, Exception, string> >()
),
Times.Once
);
}
public async static void CreateDefaultUser()
{
LibraryContext context = new LibraryContext();
var userManager = new LibraryUserManager(new UserStore <LibraryUser>(context));
var user = new LibraryUser();
user.UserName = "******";
Task <IdentityResult> result = null;
try
{
result = userManager.CreateAsync(user, "admin123");
}
finally
{
}
IdentityResult res = await result;
if (!res.Succeeded)
{
Debug.WriteLine("NOT SUCCEEDED");
foreach (var error in res.Errors)
{
Debug.WriteLine(error.ToString());
}
}
}
public async Task <IActionResult> PutLibraryUser(int id, LibraryUser libraryUser)
{
if (id != libraryUser.UserId)
{
return(BadRequest());
}
_context.Entry(libraryUser).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LibraryUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <OperationDetails> Create(UserDTO userDto)
{
LibraryUser user = await Database.UserManager.FindByEmailAsync(userDto.Email);
if (user == null)
{
user = new LibraryUser {
Email = userDto.Email, UserName = userDto.Email
};
var result = Database.UserManager.Create(user, userDto.Password);
if (result.Errors.Count() > 0)
{
return(new OperationDetails(false, result.Errors.FirstOrDefault(), ""));
}
await Database.UserManager.AddToRoleAsync(user.Id, userDto.Role);
ClientProfile clientProfile = new ClientProfile {
Id = user.Id, Adress = userDto.Address, Name = userDto.Name
};
Database.ClientManager.Create(clientProfile);
await Database.SaveAsync();
return(new OperationDetails(true, "Регистрация успешно пройдена", ""));
}
else
{
return(new OperationDetails(false, "Пользователь с таким логином уже существует", "Email"));
}
}
public ActionResult Login(LibraryUser model)
{
if (ModelState.IsValid)
{
var details = (from userlist in db.LibraryUser
where userlist.Username == model.Username && userlist.Password == model.Password
select new
{
userlist.User_Id,
userlist.Username,
userlist.Admin,
userlist.BookCorrect
}).ToList();
if (details.FirstOrDefault() != null)
{
Session["UserId"] = details.FirstOrDefault().User_Id;
Session["Username"] = details.FirstOrDefault().Username;
if (details.FirstOrDefault().Admin)
{
Session["Admin"] = "1";
return(RedirectToAction("Index", "LibraryUsers"));
}
else
{
Session["Admin"] = "2";
return(RedirectToAction("Details", "LibraryUsers", new { @id = details.FirstOrDefault().User_Id }));
}
}
}
return(View(model));
}
public List <LibraryUser> GetAllLibraryUsers()
{
var libraryUsers = new List <LibraryUser>();
using (var connection = new SqlConnection("Data Source=DESKTOP-GI8MCVU\\SQLSERVEREXPRESS;Initial Catalog=LibraryMVC;Integrated Security=True"))
{
connection.Open();
var dataReader = new SqlCommand(GetAllLibraryUsersQuery, connection).ExecuteReader();
while (dataReader.Read())
{
var libraryUser = new LibraryUser()
{
Id = dataReader.GetInt32(0),
Firstname = dataReader.GetString(1),
Lastname = dataReader.GetString(2),
CardIdentifier = dataReader.GetString(3),
};
libraryUsers.Add(libraryUser);
}
dataReader.Close();
}
return(libraryUsers);
}
public TransactionsViewModel(LibraryUser libUser)
{
_LibraryUser = libUser;
TransactionsView = CollectionViewSource
.GetDefaultView(new ObservableCollection <TransactionDTO>(TranService.GetTransactionDTO(libUser.Id)));
TransactionsView.SortDescriptions.Add(new SortDescription("TransactionInfo.BorrowDate", ListSortDirection.Descending));
}
public int DeleteLibraryUser(int _LibraryUserID)
{
LibraryUser LibraryUserDelete = context
.LibraryUsers.SingleOrDefault(x => x.LibraryUserID == _LibraryUserID);
context.LibraryUsers.Remove(LibraryUserDelete);
return(context.SaveChanges());
}
public void DeleteUser(LibraryUser currentUser)
{
using (var uow = new library.model.Repositories.LibUnitOfWork())
{
uow.LibraryUserRepository.Remove(currentUser);
uow.SaveChanges();
}
}
public void AddLibraryUser(LibraryUser user)
{
using (var uow = new LibUnitOfWork())
{
uow.LibraryUserRepository.Add(user);
uow.SaveChanges();
}
}
public async Task <UserDTO> FindByEmail(string email)
{
LibraryUser user = await Database.UserManager.FindByEmailAsync(email);
Mapper.Initialize(cfg => cfg.CreateMap <LibraryUser, UserDTO>());
UserDTO UserDto = Mapper.Map <LibraryUser, UserDTO>(user);
return(UserDto);
}
public LibraryTransactionsAggregate(LibraryUser user) : this()
{
_LibraryUser = user;
if (_LibraryUser.LibraryUserType == LibraryUser.UserType.Instructor)
{
CompletePayment();
}
}
public HttpResponseMessage UpdateMemberShipType([FromBody] LibraryUser _LibraryUser)
{
LibraryUserRepository LibraryUsers = new LibraryUserRepository();
LibraryUsers.UpdateLibraryUser(_LibraryUser);
HttpResponseMessage ms = Request.CreateResponse(HttpStatusCode.OK);
ms.Headers.Location = new Uri(Request.RequestUri + "/" + (_LibraryUser.LibraryUserID).ToString());
return(ms);
}
public ActionResult Edit(LibraryUser user)
{
if (ModelState.IsValid)
{
uow.LibraryUserRepository.Update(user);
uow.Save();
return(RedirectToAction("Details", new { id = user.UserId }));
}
return(View(user));
}
public async Task <ClaimsIdentity> Authenticate(UserDTO userDto)
{
ClaimsIdentity claim = null;
LibraryUser user = await Database.UserManager.FindAsync(userDto.Email, userDto.Password);
if (user != null)
{
claim = await Database.UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
}
return(claim);
}
internal LibraryUser AddLibraryUser(Library library, User user)
{
var libraryUser = new LibraryUser
{
Library = library,
User = user,
};
_dbContext.LibraryUsers.Add(libraryUser);
return(libraryUser);
}
public ActionResult Create([Bind(Include = "User_Id,Username,Password,Admin")] LibraryUser libraryUser)
{
if (ModelState.IsValid)
{
db.LibraryUser.Add(libraryUser);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(libraryUser));
}
public int UpdateLibraryUser(LibraryUser _LibraryUser)
{
LibraryUser LibraryUserToUpdate = context.LibraryUsers.SingleOrDefault(x => x.LibraryUserID == _LibraryUser.LibraryUserID);
LibraryUserToUpdate.Name = _LibraryUser.Name;
LibraryUserToUpdate.PhoneNumber = _LibraryUser.PhoneNumber;
LibraryUserToUpdate.ReferencedID = _LibraryUser.ReferencedID;
LibraryUserToUpdate.Address = _LibraryUser.Address;
LibraryUserToUpdate.EmailID = _LibraryUser.EmailID;
return(context.SaveChanges());
}
