public async Task AddAsync(BookIssue entity)
{
var spParameters = new SqlParameter[3];
spParameters[0] = new SqlParameter()
{
ParameterName = "ReturnDate", Value = entity.ReturnDate
};
spParameters[1] = new SqlParameter()
{
ParameterName = "IssueDate", Value = entity.IssueDate
};
spParameters[2] = new SqlParameter()
{
ParameterName = "BookIssueId", Value = entity.BookIssueId
};
await DbContextManager.StoreProc <StoreProcResult>("[dbo].spReturnBook ", spParameters);
try
{
await DbContextManager.CommitAsync();
}
catch (Exception e)
{
DbContextManager.RollbackTransaction();
}
}
public ActionResult DeleteConfirmed(int id)
{
BookIssue bookIssue = db.BookIssues.Find(id);
db.BookIssues.Remove(bookIssue);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "BookIssueID,BookCode,DateIssued,DateReturn,DateReturned,BookIssuedStatus,FineRange,CreatedBy,CreatedOn,LastModifiedBy,LastModifiedOn")] BookIssue bookIssue)
{
if (ModelState.IsValid)
{
db.Entry(bookIssue).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(bookIssue));
}
public string Save(BookIssue bookIssue)
{
string message = "";
//to check if the book status is free before issuing
var book = _bookRepository.GetBook(bookIssue.BookId);
if (book != null)
{
if (book.Status == "FREE" || book.Status == null)
{
//to check if the student already has issued 4 books
List <BookIssue> booksIssuedByTheStudent = _bookIssueRepository.GetBookIssueListByStudent(bookIssue.StudentId);
if (booksIssuedByTheStudent.Count > 4)
{
message = "Student Already Issued 4 Books";
}
else
{
//to check if student already has issued 2 books in current date
List <BookIssue> booksIssuedByTheStudentInCurrentDate = _bookIssueRepository.GetBookIssueListByStudent(bookIssue.IssueDate);
if (booksIssuedByTheStudent.Count >= 2)
{
message = "Student Already Issued 2 Books Today";
}
else
{
int rowAffected = _bookIssueRepository.Insert(bookIssue);
if (rowAffected > 0)
{
//updating book status
book.Status = "ISSUED";
_bookRepository.Update(book);
message = "Issued Successfully";
}
else
{
message = "Issuing Failed";
}
}
}
}
else
{
message = "Book is already issued";
}
}
else
{
message = "No Book with this id";
}
return(message);
}
public async Task <ActionResult> Edit([Bind(Include = "ID,StudentId,AccessionNo,IssueDate,DueDate,Status")] BookIssue bookIssue)
{
if (ModelState.IsValid)
{
Db.Entry(bookIssue).State = EntityState.Modified;
await Db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(bookIssue));
}
public void CreateBookIssue(BookIssue bookIssue)
{
var issueBook = _libraryContext.Add(bookIssue);
bookIssue.Id = issueBook.Entity.BookId;
bookIssue.Barcode = issueBook.Entity.Barcode;
bookIssue.StudentId = issueBook.Entity.StudentId;
bookIssue.BookIssueDate = issueBook.Entity.BookIssueDate;
bookIssue.Book.CopyCount = issueBook.Entity.Book.CopyCount;
Save();
}
public async Task <ActionResult> Create([Bind(Include = "ID,StudentId,AccessionNo,IssueDate,DueDate,Status")] BookIssue bookIssue)
{
if (ModelState.IsValid)
{
Db.BookIssues.Add(bookIssue);
await Db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(bookIssue));
}
public void changeIssueStatus(int bookIssueId, int status, string user)
{
BookIssue issue = this._bookIssueRepository.Table.FirstOrDefault(w => w.Id == bookIssueId);
if (issue != null)
{
issue.Status = status;
issue.UpdatedBy = user;
issue.UpdatedOn = DateTime.Now;
this._bookIssueRepository.Update(issue);
}
}
public ActionResult Edit([Bind(Include = "BookIssueId,MemberId,BookId,DateOfIssue,Status")] BookIssue bookIssue)
{
if (ModelState.IsValid)
{
db.Entry(bookIssue).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.BookId = new SelectList(db.Books, "BookId", "BookName", bookIssue.BookId);
ViewBag.MemberId = new SelectList(db.Members, "MemberId", "MemberName", bookIssue.MemberId);
return(View(bookIssue));
}
public double CheckFine(BookReturn bookReturn, BookIssue bookIssue, Student student)
{
var returnBook = _reportRepository.ReturnBook(bookReturn);
var timeSpan = bookIssue.BookIssueDate - returnBook.BookReturingDate;
var fine = student.FineAmount;
if (timeSpan.Days > 7)
{
fine *= 10;
}
return(fine);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
LibraryBusinessLogic libraryBL = new LibraryBusinessLogic();
if (resultDataGridView.SelectedRows.Count > 0)
{
int studentNumber;
if (!int.TryParse(studentNumberTextBox.Text, out studentNumber))
{
throw new Exception("Student Number should be numeric only");
}
if (libraryBL.ValidateID(studentNumber))
{
foreach (DataGridViewRow row in resultDataGridView.SelectedRows)
{
BookIssue bookIssue = new BookIssue();
bookIssue.Book_Number = int.Parse(row.Cells[0].Value.ToString());
bookIssue.Student_Number = studentNumber;
MessageBox.Show(row.Cells[0].Value.ToString());
bookIssue.Issued_Date = issueDateTimePicker.Value;
bookIssue.Return_Date = returnDateTimePicker.Value;
int quantity = int.Parse(row.Cells[4].Value.ToString());
//MessageBox.Show("Hello");
if (quantity > 0)
{
if (libraryBL.NewBookIssue(bookIssue))
{
MessageBox.Show("Book Issued");
searchTextBox.Clear();
studentNumberTextBox.Clear();
}
}
else
{
throw new Exception("Cannot issue book because it is not available right now ");
}
}
}
else
{
throw new Exception("Invalid Student Number");
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
// GET: BookIssues/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BookIssue bookIssue = await Db.BookIssues.FindAsync(id);
if (bookIssue == null)
{
return(HttpNotFound());
}
return(View(bookIssue));
}
public void AddBookIssue(string IssueDate, int MemberId, int BookId)
{
var db = new LibraryEntities();
BookIssue book = new BookIssue();
book.IssueDate = IssueDate;
book.MemberId = MemberId;
book.BookId = BookId;
db.BookIssues.Add(book);
db.SaveChanges();
db.Dispose();
}
// GET: BookIssue/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BookIssue bookIssue = db.BookIssues.Find(id);
if (bookIssue == null)
{
return(HttpNotFound());
}
return(View(bookIssue));
}
public bool IssueBookToMember(BookIssue bookIssue)
{
bool isIssued;
try
{
_bookIssueRepository.InsertBookIssue(bookIssue);
isIssued = true;
}
catch (Exception)
{
isIssued = false;
}
return(isIssued);
}
// GET: BookIssue/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BookIssue bookIssue = db.BookIssues.Find(id);
if (bookIssue == null)
{
return(HttpNotFound());
}
ViewBag.BookId = new SelectList(db.Books, "BookId", "BookName", bookIssue.BookId);
ViewBag.MemberId = new SelectList(db.Members, "MemberId", "MemberName", bookIssue.MemberId);
return(View(bookIssue));
}
public ActionResult IssueBook([FromBody] BookIssue bookIssue)
{
try
{
var isBookIssued = _managementService.IssueBookToMember(bookIssue);
var book = _managementService.GetBook(bookIssue.BookId);
if (book.CopyCount > 0)
{
_managementService.DecreaseBookCopy(book);
}
if (isBookIssued)
{
return(Ok("Book Issued Succesfully"));
}
return(NotFound("Oops"));
}
catch (Exception)
{
return(BadRequest());
}
}
private void btngive_Click(object sender, EventArgs e)
{
BookIssue issue = new BookIssue();
Books newstock = new Books();
int bookid = Convert.ToInt32(databook.SelectedRows[0].Cells[0].Value);
int stdid = Convert.ToInt32(datastudent.SelectedRows[0].Cells[0].Value);
issue.BookID = bookid;
issue.StudentID = stdid;
issue.IssueDate = DateTime.Today;
service.BookIssueService.insert(issue);
int id = Convert.ToInt32(databook.SelectedRows[0].Cells[0].Value);
newstock = db.Books.Find(id);
newstock.BookName = databook.SelectedRows[0].Cells[1].Value.ToString();
newstock.Author = databook.SelectedRows[0].Cells[2].Value.ToString();
newstock.GenresID = Convert.ToInt32(databook.SelectedRows[0].Cells[3].Value);
newstock.Available = false;
db.SaveChanges();
MessageBox.Show("Book Issue is Recorded");
datastudent.DataSource = service.StudentService.GetAll();
databook.DataSource = service.BooksService.GetByCondition(x => x.Available == true);
}
public IEnumerable <BookIssue> GetIssueBook(BookIssue bookIssue)
{
yield return(_bookIssueRepository.CreateBookIssue(bookIssue));
}
public int Insert(BookIssue bookIssue)
{
//insert
_dbContext.BookIssues.Add(bookIssue);
return(_dbContext.SaveChanges());
}
public Task <object> GetBy(BookIssue parameters)
{
throw new NotImplementedException();
}
public int InsertBookIssue(BookIssue bIssue)
{
this._bookIssueRepository.Insert(bIssue);
return(bIssue.Id);
}
public bool NewBookIssue(BookIssue book)
{
LibraryDataAccessLogic libraryDA = new LibraryDataAccessLogic();
return(libraryDA.NewBookIssue(book));
}
public Task DeleteAsync(BookIssue parameters)
{
throw new NotImplementedException();
}
public async Task UpdateAsync(BookIssue entity)
{
await Uow.RegisterDirtyAsync(entity);
await Uow.CommitAsync();
}
public HashSet <string> UpdateValidation(BookIssue entity)
{
return(ValidationMessages);
}
public void InsertBookIssue(BookIssue bookIssue)
{
_context.BookIssues.Add(bookIssue);
_context.SaveChanges();
}
BookIssue IBookIssueRepository.CreateBookIssue(BookIssue bookIssue)
{
throw new NotImplementedException();
}
public HashSet <string> DeleteValidation(BookIssue parameters)
{
return(ValidationMessages);
}
public void InsertBookIssue(BookIssue bookIssue)
{
_context.BookIssues.Add(bookIssue);
Save();
}
