public bool Add(LibraryBookBLL item, out string serverSideError)
        {
            if (item.IsValid)
            {
                using (ProtoLibEntities context = new ProtoLibEntities())
                {
                    if (DatabaseDependantValidation(item, context, out serverSideError))
                    {
                        LibraryBook newLibBook = new LibraryBook();
                        CrossLayerEntityConverter.LibraryBookBllToDal(context, item, newLibBook);
                        context.LibraryBooks.AddObject(newLibBook);

                        context.SaveChanges();

                        return true;
                    }
                }

                return false;
            }
            else
            {
                serverSideError = "The LibraryBook object is invalid";
                return false;
            }
        }
        public LibraryBookBLL GetByID(int id)
        {
            using (ProtoLibEntities context = new ProtoLibEntities())
            {
                LibraryBook libBook = (from lb in context.LibraryBooks
                                    where lb.BookID == id
                                    select lb).SingleOrDefault();

                if (libBook != null)
                {
                    LibraryBookBLL retLibBook = new LibraryBookBLL();
                    CrossLayerEntityConverter.LibraryBookDalToBll(context, retLibBook, libBook);
                    return retLibBook;
                }
            }

            return null;
        }
        private bool DatabaseDependantValidation(LibraryBookBLL bllLibBook, ProtoLibEntities context, 
            out string error,
            int idToExclude = 0)
        {
            error = null;

            return true;
        }
        public bool Update(LibraryBookBLL newItem, out string serverSideError)
        {
            if (newItem.IsValid)
            {
                using (ProtoLibEntities context = new ProtoLibEntities())
                {
                    if (DatabaseDependantValidation(newItem, context, out serverSideError, newItem.ItemID))
                    {
                        LibraryBook dalLibBook = (from lb in context.LibraryBooks
                                               where lb.BookID == newItem.ItemID
                                               select lb).Single();

                        CrossLayerEntityConverter.LibraryBookBllToDal(context, newItem, dalLibBook);
                        context.SaveChanges();

                        Debug.Assert(serverSideError == null);
                        return true;
                    }
                    else
                        return false;
                }
            }

            serverSideError = "Item is in an invalid state!";
            return false;
        }
        public List<LibraryBookBLL> GetPreviousItems(int beforeItemID, int numItems)
        {
            List<LibraryBookBLL> retList = new List<LibraryBookBLL>();

            using (ProtoLibEntities context = new ProtoLibEntities())
            {
                var dalLibBooks = (from lb in context.LibraryBooks
                                where lb.BookID < beforeItemID
                                orderby lb.BookID descending
                                select lb).Take(numItems);

                LibraryBookBLL bllLibBook = null;
                foreach (LibraryBook dalLibBook in dalLibBooks)
                {
                    bllLibBook = new LibraryBookBLL();
                    CrossLayerEntityConverter.LibraryBookDalToBll(context, bllLibBook, dalLibBook);
                    retList.Add(bllLibBook);
                }
            }

            retList.Reverse();
            return retList;
        }
        public List<LibraryBookBLL> GetFirstItems(int numItems)
        {
            List<LibraryBookBLL> retList = new List<LibraryBookBLL>();

            using (ProtoLibEntities context = new ProtoLibEntities())
            {
                var dalLibBooks = (from lb in context.LibraryBooks
                                orderby lb.BookID
                                select lb).Take(numItems);

                LibraryBookBLL bllLibBook = null;
                foreach (LibraryBook dalLibBook in dalLibBooks)
                {
                    bllLibBook = new LibraryBookBLL();
                    CrossLayerEntityConverter.LibraryBookDalToBll(context, bllLibBook, dalLibBook);
                    retList.Add(bllLibBook);
                }
            }

            return retList;
        }
        public static void LibraryBookDalToBll(ProtoLibEntities context, LibraryBookBLL bllLibBook, LibraryBook dalLibBook)
        {
            bllLibBook.ItemID = dalLibBook.BookID;

            bllLibBook.Price = dalLibBook.Price;
            bllLibBook.ObtainedFrom = dalLibBook.ObtainedFrom;
            bllLibBook.BookDetailsId = dalLibBook.BookInfoID;
            bllLibBook.Status = (BookStatusBLL)(dalLibBook.StatusID);
        }
        public static void LibraryBookBllToDal(ProtoLibEntities context, LibraryBookBLL bllLibBook, LibraryBook dalLibBook)
        {
            dalLibBook.Price = bllLibBook.Price;
            dalLibBook.ObtainedFrom = bllLibBook.ObtainedFrom;
            dalLibBook.BookDetails = (from book in context.BookDetailsSet where book.BookDetailsID == bllLibBook.BookDetailsId select book).SingleOrDefault();
            dalLibBook.BookStatus = (from st in context.BookStatus1 where st.StatusID == (int)bllLibBook.Status select st).Single();

            //TODO: Implement branch stuff
            dalLibBook.Branch = (from br in context.Branches where br.BranchID == 100 select br).First();
        }