//Update BookTransaction (async)
        public async Task <BookTransactionDTO> UpdateBookTransactionAsync(BookTransactionDTO modelDTO)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.Create())
                {
                    BookTransactionModel model = _Mapper_ToModel.Map <BookTransactionDTO, BookTransactionModel>(modelDTO);

                    bool result = unitOfWork.BookTransactionRepository.Update(model);

                    BookTransactionDTO modelRTN = null;
                    if (result)
                    {
                        await unitOfWork.SaveChangesAsync();

                        modelRTN = _Mapper_ToDTO.Map <BookTransactionModel, BookTransactionDTO>(model);
                    }

                    return(modelRTN);
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
        //Add BookTransaction (async)
        public async Task <int> AddBookTransactionAsync(BookTransactionDTO modelDTO)
        {
            try
            {
                using (var unitOfWork = unitOfWorkFactory.Create())
                {
                    //BookModel tempBook = unitOfWork.BookRepository.GetSingleOrDefaultBook(x => x.BookId == modelDTO.BookId);

                    //modelDTO.BookId = tempBook.BookId;

                    //StudentModel tempStudent = unitOfWork.StudentRepository.GetSingleOrDefaultStudent(x => x.StudentId == modelDTO.StudentId);

                    //modelDTO.StudentId = tempStudent.StudentId;

                    BookTransactionModel model = _Mapper_ToModel.Map <BookTransactionDTO, BookTransactionModel>(modelDTO);

                    unitOfWork.BookTransactionRepository.Add(model);
                    //unitOfWork.Repository.Add<BookTransactionModel>(model);
                    await unitOfWork.SaveChangesAsync();

                    return(model.BookTransactionId);
                }
            }
            catch (Exception ex)
            {
                LogException(ex);
                throw ex;
            }
        }
        public async Task <IHttpActionResult> GetBookTransaction(int id)
        {
            BookTransactionDTO dto = await BookTransactionService.SearchSingleBookTransactionByIdAsync(id);

            if (dto != null)
            {
                return(Ok(dto));
            }
            else
            {
                return(NotFound());
            }
        }
        public async Task <IHttpActionResult> UpdateBookTransaction([FromBody] BookTransactionDTO BookTransactionModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var updatedBookTransaction = await BookTransactionService.UpdateBookTransactionAsync(BookTransactionModel);

            if (updatedBookTransaction != null)
            {
                return(Ok(updatedBookTransaction));
            }
            else
            {
                return(NotFound());
            }
        }
        public async Task <IHttpActionResult> AddBookTransaction([FromBody] BookTransactionDTO BookTransactionModel)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var newBookTransactionId = await BookTransactionService.AddBookTransactionAsync(BookTransactionModel);

            if (newBookTransactionId != 0)
            {
                return(Ok(newBookTransactionId));
            }
            else
            {
                return(NotFound());
            }
        }