public ActionResult BookView()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user = userInfo;
            //get role
            var roles = UserManager.GetRoles(userInfo.Id);

            foreach (var role in roles)
            {
                if (role == "Admin")
                {
                    model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                }
                else if (role == "Manager")
                {
                    model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                }
                else
                {
                    model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                }
            }

            return(View("Book/Index", model));
        }
        public ActionResult CreateBookSuccessView()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user = userInfo;
            model.msg  = "Book was created.";
            //model.actionBtn = "View Cart";
            //get role
            var roles = UserManager.GetRoles(userInfo.Id);

            foreach (var role in roles)
            {
                if (role == "Admin")
                {
                    model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                }
                else if (role == "Manager")
                {
                    model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                }
                else
                {
                    model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                }
            }
            return(View("Cart/AddedToCartMsg", model));
        }
        public ActionResult CreateBook()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user = userInfo;
            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                StringContent queryString = new StringContent("");
                var           getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Book/GetAllGenres/", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;

                    model.genres = JsonConvert.DeserializeObject <List <GenreModel> >(response);

                    //return View("Book/SearchOverview", model);
                    return(View("Book/Create", model));
                }
            }

            return(View("Book/SearchOverview", model));
        }
        public ActionResult checkOut(string cartId)
        {
            if (!ModelState.IsValid)
            {
                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }

            //call api
            using (HttpClient httpClient = new HttpClient())
            {
                var               currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
                UserInfoBookModel model       = new UserInfoBookModel();
                model.user = userInfo;

                var data = new Dictionary <string, string>
                {
                    { "cartid", cartId }
                };


                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);



                string dataJson    = JsonConvert.SerializeObject(cartId);
                var    queryString = new StringContent(dataJson, Encoding.UTF8, "application/json");
                var    getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Cart/Checkout", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;
                    model.msg = "You're all set! An email was sent for your record.";
                    //get role
                    var roles = UserManager.GetRoles(userInfo.Id);
                    foreach (var role in roles)
                    {
                        if (role == "Admin")
                        {
                            model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                        }
                        else if (role == "Manager")
                        {
                            model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                        }
                        else
                        {
                            model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                        }
                    }
                    return(View("Cart/AddedToCartMsg", model));
                }
            }
            //return back to book list
            return(RedirectToAction("SearchView", "Dashboard"));
        }
        public ActionResult EditBook(UserInfoBookModel model)
        {
            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                var       currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel userInfo    = accountMgr.GetUserInfo(currentUser);

                string dataJson    = JsonConvert.SerializeObject(model.book);
                var    queryString = new StringContent(dataJson, Encoding.UTF8, "application/json");
                var    getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Book/UpdateBook", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(20));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;



                    UserInfoBookModel result = new UserInfoBookModel();
                    result.user   = userInfo;
                    result.msg    = "Book updated!";
                    result.layout = "~/Views/Shared/_Layout_Admin.cshtml";

                    return(View("Cart/AddedToCartMsg", result));
                }
            }

            return(RedirectToAction("UpdateBook"));
        }
        public ActionResult SearchByGenre(Guid GenreID)
        {
            if (!ModelState.IsValid)
            {
                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }
            string genreId = GenreID.ToString();
            //api call
            var data = new Dictionary <string, string>
            {
                { "genreId", genreId }
            };


            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                var       currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel userInfo    = accountMgr.GetUserInfo(currentUser);

                var getTokenUrl = httpClient.GetAsync(String.Format("http://localhost:50799/api/Book/GetBooksByGenreID/{0}", genreId));
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;
                    var model    = new UserInfoBookModel();
                    model.book  = new BookModel();
                    model.books = JsonConvert.DeserializeObject <List <BookModel> >(response);
                    model.user  = userInfo;
                    //get role
                    var roles = UserManager.GetRoles(userInfo.Id);
                    foreach (var role in roles)
                    {
                        if (role == "Admin")
                        {
                            model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                        }
                        else if (role == "Manager")
                        {
                            model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                        }
                        else
                        {
                            model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                        }
                    }
                    return(View("Book/Search/SearchByGenre", model));
                }

                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }
        }
        public ActionResult UpdateGenre()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user = userInfo;
            return(View("Genre/Update", model));
        }
        public ActionResult SuccessAccountCreation()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user   = userInfo;
            model.msg    = "Account created!";
            model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
            return(View("Cart/AddedToCartMsg", model));
        }
        public ActionResult UserView()
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user    = userInfo;
            model.layout  = "~/Views/Shared/_Layout_Admin.cshtml";
            model.newUser = new UserModel();
            return(View("User/Index", model));
        }
        public ActionResult UpdateBookById(Guid bookId)
        {
            //api call
            var data = new Dictionary <string, string>
            {
                { "bookId", bookId.ToString() }
            };

            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                var       currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel userInfo    = accountMgr.GetUserInfo(currentUser);

                var getTokenUrl = httpClient.GetAsync(String.Format("http://localhost:50799/api/Book/GetBookByBookID/{0}", bookId.ToString()));
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;

                    var model = new UserInfoBookModel();
                    model.user = userInfo;
                    model.book = JsonConvert.DeserializeObject <BookModel>(response);
                    //get list of genre
                    StringContent queryString   = new StringContent("");
                    var           getListGenres = httpClient.PostAsync("http://localhost:50799/api/Book/GetAllGenres", queryString);
                    var           responseGenre = getListGenres.Result.Content.ReadAsStringAsync().Result;

                    var listOfGenre = JsonConvert.DeserializeObject <List <GenreModel> >(responseGenre);
                    model.genres = listOfGenre;
                    foreach (var genre in listOfGenre)
                    {
                        if (model.book.GenreID == genre.GenreID)
                        {
                            model.genre = genre;
                            break;
                        }
                    }


                    return(View("Book/BookProfile", model));
                }
            }

            //return back to book list
            return(RedirectToAction("UpdateBook", "Dashboard"));
        }
        public ActionResult AddToWaitList(string bookId)
        {
            var               currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
            UserInfoBookModel model       = new UserInfoBookModel();

            model.user = userInfo;

            var data = new Dictionary <string, string>
            {
                { "bookId", bookId },
                { "userId", userInfo.Id }
            };

            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                string dataJson    = JsonConvert.SerializeObject(data);
                var    queryString = new StringContent(dataJson, Encoding.UTF8, "application/json");
                var    getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Book/AddBookToWaitlist", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    model.msg = "Book was added to the waitlist. You will receive an email once it's available.";
                    //get role
                    var roles = UserManager.GetRoles(userInfo.Id);
                    foreach (var role in roles)
                    {
                        if (role == "Admin")
                        {
                            model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                        }
                        else if (role == "Manager")
                        {
                            model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                        }
                        else
                        {
                            model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                        }
                    }
                    return(View("Cart/AddedToCartMsg", model));
                }
            }
            return(View());
        }
        public ActionResult GetAllBook()
        {
            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                var       currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel userInfo    = accountMgr.GetUserInfo(currentUser);
                var       model       = new UserInfoBookModel();
                //get role
                var roles = UserManager.GetRoles(userInfo.Id);
                foreach (var role in roles)
                {
                    if (role == "Admin")
                    {
                        model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                    }
                    else if (role == "Manager")
                    {
                        model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                    }
                    else
                    {
                        model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                    }
                }

                StringContent queryString = new StringContent("");
                var           getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Book/GetAllBooks", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;

                    model.book  = new BookModel();
                    model.books = JsonConvert.DeserializeObject <List <BookModel> >(response);
                    model.user  = userInfo;


                    return(View("Book/Search/GetAllBook", model));
                }

                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }
        }
        public ActionResult Index()
        {
            var result = new UserInfoBookModel();

            try
            {
                //check if authenticated
                if (!User.Identity.IsAuthenticated)
                {
                    return(RedirectToAction("SignIp", "Home"));
                }
                //get user role
                var               currentUser = UserManager.FindByEmail(User.Identity.Name);
                var               roles       = UserManager.GetRoles(currentUser.Id);
                UserModel         userInfo    = accountMgr.GetUserInfo(currentUser);
                UserInfoBookModel model       = new UserInfoBookModel();
                model.book    = new BookModel();
                model.books   = new List <BookModel>();
                model.cart    = new CartModel();
                model.genres  = new List <GenreModel>();
                model.user    = accountMgr.GetUserInfo(currentUser);
                model.newUser = new UserModel();
                //redirect to dashboard
                foreach (var role in roles)
                {
                    if (role == "Admin")
                    {
                        return(View("Admin", model));
                    }
                    else if (role == "Manager")
                    {
                        return(View("Manager", model));
                    }
                    else
                    {
                        return(View(model));
                    }
                }
            }
            catch
            {
                return(RedirectToAction("Index", "Home"));
            }

            return(View(result));
        }
        public async Task <ActionResult> CreateManager(UserInfoBookModel model)
        {
            //create ASP.NET USER
            var user = new ApplicationUser()
            {
                UserName = model.newUser.Email,
                Email    = model.newUser.Email,
                //Password = model.Password,
                UserRoles = "Manager"
            };

            var result = await UserManager.CreateAsync(user, model.newUser.Password);

            if (!result.Succeeded)
            {
                ModelState.AddModelError("Error", "Account could not be created. Please try again");
                return(View());
            }

            var userInfo = await UserManager.FindByEmailAsync(model.newUser.Email);

            var addRole = await UserManager.AddToRoleAsync(userInfo.Id, user.UserRoles);

            if (!addRole.Succeeded)
            {
                ModelState.AddModelError("Error", "Account could not be created. Please try again");
                return(View());
            }
            //Save to UserAccount Table
            model.newUser.Id = userInfo.Id;
            var acc = accountMgr.SaveAccount(model.newUser);

            if (!acc)
            {
                return(RedirectToAction("FailedAccountCreation"));
            }

            return(RedirectToAction("SuccessAccountCreation"));
        }
        public ActionResult AddToCart(string bookToCart)
        {
            if (!ModelState.IsValid)
            {
                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }
            //get usesrinfo
            //check if cart exist -> GetCart API
            //return CartModel with book in the cart
            //if 200 -> addBookToCart API(cart Id)
            //if 200 null -> createCart with CartXBookModel
            var       currentUser = UserManager.FindByEmail(User.Identity.Name);
            UserModel userInfo    = accountMgr.GetUserInfo(currentUser);

            //setup my cart
            var body = new CartModel();

            body.BookList = new List <CartXBookModel>();
            body.BookList.Add(new CartXBookModel()
            {
                BookID   = Guid.Parse(bookToCart),
                Quantity = 1
            });
            body.UserID = Guid.Parse(userInfo.Id);


            var hasCart = getCartByUserId(userInfo.Id);

            if (hasCart.CartID != Guid.Empty)
            {
                //add the book to the existing cart
                //call addBookToCart API here
                //return success view
                //or home
                body.CartID = hasCart.CartID;
                if (!addBookToCart(body))
                {
                    //return back to book list
                    return(RedirectToAction("SearchView", "Dashboard"));
                }

                return(RedirectToAction("AddToCartSuccessView"));
            }

            //create new cart
            //add book to the cart while creating cart
            //return success view
            //or home

            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);


                body.UserID = Guid.Parse(userInfo.Id);
                string dataJson    = JsonConvert.SerializeObject(body);
                var    queryString = new StringContent(dataJson, Encoding.UTF8, "application/json");
                var    getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Cart/CreateCart", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(10));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;
                    var model    = new UserInfoBookModel();
                    model.book  = new BookModel();
                    model.books = JsonConvert.DeserializeObject <List <BookModel> >(response);
                    model.user  = userInfo;

                    return(RedirectToAction("AddToCartSuccessView"));
                }

                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }
        }
        public ActionResult CartView()
        {
            //get the cart if existant
            using (HttpClient httpClient = new HttpClient())
            {
                var cookie   = HttpContext.Request.Cookies.Get("AuthenticationToken");
                var token    = cookie.Value.Split(':');
                var newToken = "Bearer" + token[1];
                httpClient.DefaultRequestHeaders.Add("Authorization", newToken);

                var       currentUser = UserManager.FindByEmail(User.Identity.Name);
                UserModel userInfo    = accountMgr.GetUserInfo(currentUser);

                string dataJson    = JsonConvert.SerializeObject(userInfo.Id);
                var    queryString = new StringContent(dataJson, Encoding.UTF8, "application/json");
                var    getTokenUrl = httpClient.PostAsync("http://localhost:50799/api/Cart/GetCartByUserId", queryString);
                getTokenUrl.Wait(TimeSpan.FromSeconds(20));
                if (getTokenUrl.IsCompleted)
                {
                    var response = getTokenUrl.Result.Content.ReadAsStringAsync().Result;
                    //
                    var model = new UserInfoBookModel();
                    //get role
                    var roles = UserManager.GetRoles(userInfo.Id);
                    foreach (var role in roles)
                    {
                        if (role == "Admin")
                        {
                            model.layout = "~/Views/Shared/_Layout_Admin.cshtml";
                        }
                        else if (role == "Manager")
                        {
                            model.layout = "~/Views/Shared/_Layout_Manager.cshtml";
                        }
                        else
                        {
                            model.layout = "~/Views/Shared/_Layout_Customer.cshtml";
                        }
                    }


                    //if null means no cart
                    //show cart is empty
                    if (response == "null")
                    {
                        model.book      = new BookModel();
                        model.books     = new List <BookModel>();
                        model.user      = userInfo;
                        model.cart      = new CartModel();
                        model.countItem = 0;

                        return(View("cart/Index", model));
                    }

                    var jsonResponse = JsonConvert.DeserializeObject <CartModel>(response);

                    model.book      = new BookModel();
                    model.books     = jsonResponse.Books;
                    model.user      = userInfo;
                    model.cart      = jsonResponse;
                    model.countItem = model.books.Count();

                    return(View("Cart/Index", model));
                }

                //return back to book list
                return(RedirectToAction("SearchView", "Dashboard"));
            }


            //return View("Cart/Index", model);
        }