public ActionResult AddExistingFoodItem(int foodItemId, int eventId, int personId)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the food item id
                var foodItem = _foodRepository.GetAll().FirstOrDefault(x => x.FoodItemId == foodItemId);

                //Add the pending food item to session
                SessionUtility.Events.AddFoodItem(foodItem.FoodItemId, eventId);
                SessionUtility.Person.AddFoodItem(foodItem.FoodItemId, personId);

                //Get list of pending food ids for this event from session
                var pendingEventFoodItemIds = SessionUtility.Events.GetPendingFoodItems(eventId);
                var pendingPersonFoodItemIds = SessionUtility.Person.GetPendingFoodItems(personId);

                //Populate the food items already ing brought
                var foodList = GetSelectedFoodItems(pendingEventFoodItemIds, pendingPersonFoodItemIds, eventId);
                response.Data = RenderRazorViewToString("_FoodItemListTemplate", foodList);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult RemoveGame(int eventId, int gameId)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the person id
                var personId = _userService.GetCurrentUserId(User.Identity.Name);

                //Remove from the event
                SessionUtility.Events.RemoveGame(gameId, eventId);

                //Get list of pending game ids for this event from session
                var pendingEventGameIds = SessionUtility.Events.GetPendingGames(eventId);
                var pendingPersonGameIds = SessionUtility.Person.GetPendingGames(personId);

                var gameList = GetSelectedGames(pendingEventGameIds, pendingPersonGameIds, eventId);
                response.Data = RenderRazorViewToString("_GameListTemplate", gameList);

                //Save to the database last
                if (eventId != 0)
                    _eventRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_REMOVE_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult RemoveGuest(int eventId, int guestId)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the event host
                var theHost = GetCurrentUser();

                //Get the event
                var theEvent = GetEventById(eventId);

                //Remove from the list
                SessionUtility.Events.RemoveGuest(guestId, eventId);

                //Get list of pending invitation ids
                var pendingEventInvitations = SessionUtility.Events.GetGuestList(eventId);
                var personFriendsList = GetPersonFriendList(theHost);

                //Populate the guset list
                var viewModel = GetEventViewModel(theEvent);
                viewModel.PeopleInvited = GetSelectedGuests(pendingEventInvitations, personFriendsList, eventId);

                response.Data = RenderRazorViewToString("_InvitedPeopleTemplate", viewModel);

                //Save to the database last and only if the event exists in the database
                if (eventId != 0)
                    _eventRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_REMOVE_GUEST_FAIL;
            }

            return Json(response);
        }
        public ActionResult GetTimeList()
        {
            var response = new Response { Error = false, Message = ""};

            try
            {
               response.Data = JsonConvert.SerializeObject(_eventService.GetTimeList());
            }
            catch (Exception)
            {
                //TODO: log to database
                response.Error = true;
                response.Message = "An error occured while trying to get the event times list";
            }

            return Json(response);
        }
        public ActionResult RemoveFoodItem(int eventId, int foodItemId)
        {
            var response = new Response { Error = false };

            try
            {
                var personId = _userService.GetCurrentUserId(User.Identity.Name);
                var thePerson = _personRepository.GetAll().FirstOrDefault(x => x.PersonId == personId);

                //Remove from the list
                SessionUtility.Events.RemoveFoodItem(foodItemId, eventId);

                //Get list of pending food ids for this event from session
                var pendingEventFoodItemIds = SessionUtility.Events.GetPendingFoodItems(eventId);
                var pendingPersonFoodItemIds = SessionUtility.Person.GetPendingFoodItems(personId);

                var foodList = GetSelectedFoodItems(pendingEventFoodItemIds, pendingPersonFoodItemIds, eventId);
                response.Data = RenderRazorViewToString("_FoodItemListTemplate", foodList);

                //Save to the database last and only if the event exists in the database
                if(eventId != 0)
                    _eventRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_REMOVE_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult AddExistingGame(int gameId, int eventId, int personId)
        {
            var response = new Response { Error = false };

            try
            {
                //Add the pending game to session
                SessionUtility.Events.AddGame(gameId, eventId);
                SessionUtility.Person.AddGame(gameId, personId);

                //Get list of pending game ids for this event from session
                var pendingEventGameIds = SessionUtility.Events.GetPendingGames(eventId);
                var pendingPersonGameIds = SessionUtility.Person.GetPendingGames(personId);

                //Populate the games already ing brought
                var gameList = GetSelectedGames(pendingEventGameIds, pendingPersonGameIds, eventId);
                response.Data = RenderRazorViewToString("_GameListTemplate", gameList);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult GetSingleGame(int gameId)
        {
            var response = new Response { Error = false };

            try
            {
                var game = _gameRepository.GetAll().FirstOrDefault(x => x.GameId == gameId);
                response.Data = new GameViewModel(game);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_GET_GAME_FAIL;
            }

            return Json(response);
        }
        public ActionResult GetGuestList(int eventId, string contains)
        {
            var response = new Response { Error = false };

            try
            {
                //Get list of pending guest ids for this event from session
                var pendingGuestListIds = SessionUtility.Events.GetGuestList(eventId);
                var personFriendIds = new List<int>();
                var thePerson = GetCurrentUser();

                thePerson.MyRegisteredFriends.ForEach(x => personFriendIds.Add(x.PersonId));

                //Make the unregistered ids negative to avoid conflicts with registered friend ids... see comments at top of class
                thePerson.MyUnRegisteredFriends.ForEach(x => personFriendIds.Add(-x.PendingInvitationId));

                var guestList = GetNonSelectedGuests(pendingGuestListIds, personFriendIds, eventId)
                    .Where(x =>
                        x.FirstName.ToLower().Contains(contains.ToLower()) ||
                        x.LastName.ToLower().Contains(contains.ToLower()));

                response.Data = guestList;
            }
            catch (Exception)
            {
                //TODO: log to database
                response.Error = true;
                response.Message = "An error occurred. Unable to retrieve your list of food items.";
            }

            return Json(response);
        }
        public ActionResult GetPersonGameList(int eventId, int personId, string contains)
        {
            var response = new Response { Error = false };

            try
            {
                //Get list of pending game ids for this event from session
                var pendingEventGameIds = SessionUtility.Events.GetPendingGames(eventId);
                var pendingPersonGameIds = SessionUtility.Person.GetPendingGames(personId);

                response.Data = GetNonSelectedGames(pendingEventGameIds, pendingPersonGameIds, eventId)
                    .Where(x => x.Title.ToLower().Contains(contains.ToLower()));
            }
            catch (Exception)
            {
                //TODO: log to database
                response.Error = true;
                response.Message = "An error occurred. Unable to retrieve your list of games.";
            }

            return Json(response);
        }
        public ActionResult AddPreviousGuest(int guestId, int eventId, int personId)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the event
                var theEvent = GetEventById(eventId);

                //Get the event host
                var theHost = GetPersonById(personId);

                //Add the pending guest id to session
                SessionUtility.Events.AddGuest(guestId, eventId);

                //Get list of pending invitation ids
                var pendingEventInvitations = SessionUtility.Events.GetGuestList(eventId);
                var hostFriendList = GetPersonFriendList(theHost);

                //Populate the guset list
                var viewModel = GetEventViewModel(theEvent);
                viewModel.PeopleInvited = GetSelectedGuests(pendingEventInvitations, hostFriendList, eventId);

                response.Data = RenderRazorViewToString("_InvitedPeopleTemplate", viewModel);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_GUEST_FAIL;
            }

            return Json(response);
        }
        public ActionResult GetEventGuest(int guestId)
        {
            var response = new Response { Error = false };

            try
            {
                var registeredGuest = _personRepository.GetAll().FirstOrDefault(x => x.PersonId == guestId);

                //Change the guestId to a posative value... see comments at top of class
                guestId = Math.Abs(guestId);
                var unRegisteredGuest = _inviteRepository.GetAll().FirstOrDefault(x => x.PendingInvitationId == guestId);

                var guest = (registeredGuest != null) ? new PersonViewModel(registeredGuest) : new PersonViewModel
                    {
                        PersonId = unRegisteredGuest.PendingInvitationId,
                        FirstName = unRegisteredGuest.FirstName,
                        LastName = unRegisteredGuest.LastName,
                        Email = unRegisteredGuest.Email,
                        IsRegistered = false
                    };

                response.Data = guest;
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_GET_GUEST_FAIL;
            }

            return Json(response);
        }
        public ActionResult AddNewGuest(EditEventViewModel model)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the event
                var theEvent = GetEventById(model.EventId);

                //Get the host
                var theHost = GetPersonById(model.PersonId);

                //Find out the if the user being added already has an email as a registered user... see comments at top of class
                var exists = _personRepository.GetAll().FirstOrDefault(x => x.Email == model.EmailInvite.Email);

                if (exists == null)
                {
                    var userName = model.EmailInvite.FirstName + " " + model.EmailInvite.LastName;
                    response.Data = new { PersonId = 0, model.EmailInvite.Email, UserName = userName, model.EmailInvite.FirstName, model.EmailInvite.LastName, model.EmailInvite.InviteControlId };

                    //Add the unregistered guest to the database
                    var newGuest = new PendingInvitation
                    {
                        FirstName = model.EmailInvite.FirstName,
                        LastName = model.EmailInvite.LastName,
                        Email = model.EmailInvite.Email
                    };

                    _inviteRepository.Insert(newGuest);
                    _inviteRepository.SubmitChanges();

                    //Add the new guest to the host's list of unregistered friends
                    theHost.MyUnRegisteredFriends.Add(newGuest);

                    //Add a negative value to the list.
                    var tempId = -newGuest.PendingInvitationId;

                    //Add the unregistered user to session
                    SessionUtility.Events.AddGuest(tempId, model.EventId);
                }
                else
                {
                    //Add the registered user to the session
                    SessionUtility.Events.AddGuest(exists.PersonId, model.EventId);
                }

                //Get list of pending invitation ids
                var pendingEventInvitations = SessionUtility.Events.GetGuestList(model.EventId);
                var personFriendsList = GetPersonFriendList(theHost);

                //Populate the guest list
                var viewModel = GetEventViewModel(theEvent);
                viewModel.PeopleInvited = GetSelectedGuests(pendingEventInvitations, personFriendsList, model.EventId);

                response.Data = RenderRazorViewToString("_InvitedPeopleTemplate", viewModel);

                //Save to the database if no errors have occurred
                _personRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_GUEST_FAIL;
            }

            return Json(response);
        }
        public ActionResult AddGame(EventBaseViewModel model)
        {
            var response = new Response { Error = false };

            try
            {
                //Add to the games table if it doesn't exist
                var newGame = new Game { Title = model.AddGameItem.Title, Description = model.AddGameItem.Description};
                _gameRepository.Insert(newGame);
                _gameRepository.SubmitChanges();

                //Add to the user's personal list of food items
                var thePerson = _personRepository.GetAll().FirstOrDefault(x => x.PersonId == model.PersonId);
                thePerson.MyGames.Add(newGame);

                //Add the pending game to session
                SessionUtility.Events.AddGame(newGame.GameId, model.EventId);
                SessionUtility.Person.AddGame(newGame.GameId, model.PersonId);

                //Get list of pending game ids for this event from session
                var pendingEventGameIds = SessionUtility.Events.GetPendingGames(model.EventId);
                var pendingPersonGameIds = SessionUtility.Person.GetPendingGames(model.PersonId);

                //Populate the games already ing brought
                var gameList = GetSelectedGames(pendingEventGameIds, pendingPersonGameIds, model.EventId);
                response.Data = RenderRazorViewToString("_GameListTemplate", gameList);

                //Save to the database last
                _personRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult AddFoodItem(EventBaseViewModel model)
        {
            var response = new Response { Error = false };

            try
            {
                //Add to the food items table if it doesn't exist
                var newFoodItem = new FoodItem { Title = model.AddFoodItem.Title, Description = model.AddFoodItem.Description };
                _foodRepository.Insert(newFoodItem);
                _foodRepository.SubmitChanges();

                //Add to the user's personal list of food items
                var thePerson = _personRepository.GetAll().FirstOrDefault(x => x.PersonId == model.PersonId);
                thePerson.MyFoodItems.Add(newFoodItem);

                //Add the person's pending food item to session
                SessionUtility.Events.AddFoodItem(newFoodItem.FoodItemId, model.EventId);
                SessionUtility.Person.AddFoodItem(newFoodItem.FoodItemId, model.PersonId);

                //Get list of all pending food ids for this event from session
                var pendingEventFoodItemIds = SessionUtility.Events.GetPendingFoodItems(model.EventId);
                var pendingPersonFoodItemIds = SessionUtility.Person.GetPendingFoodItems(model.PersonId);

                //Populate the food items already being brought
                var foodList = GetSelectedFoodItems(pendingEventFoodItemIds, pendingPersonFoodItemIds, model.EventId);
                response.Data = RenderRazorViewToString("_FoodItemListTemplate", foodList);

                //Save to the database if no errors have occurred
                _personRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_ADD_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult UpdateGame(EventBaseViewModel model)
        {
            var response = new Response { Error = false };

            try
            {
                var personId = _userService.GetCurrentUserId(User.Identity.Name);

                //Update the food item
                var updateMe = _gameRepository.GetAll().FirstOrDefault(x => x.GameId == model.UpdateGameItem.GameId);
                updateMe.Title = model.UpdateGameItem.Title;
                updateMe.Description = model.UpdateGameItem.Description;

                //Save to the database last
                _gameRepository.SubmitChanges();

                //Get list of pending food ids for this event from session
                var pendingEventFoodItemIds = SessionUtility.Events.GetPendingGames(model.EventId);
                var pendingPersonFoodItemIds = SessionUtility.Person.GetPendingGames(personId);

                var selectedGames = GetSelectedGames(pendingEventFoodItemIds, pendingPersonFoodItemIds, model.EventId);
                response.Data = RenderRazorViewToString("_GameListTemplate", selectedGames);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_UPDATE_GAME_FAIL;
            }

            return Json(response);
        }
        public ActionResult GetSingleFoodItem(int foodItemId)
        {
            var response = new Response { Error = false };

            try
            {
                var foodItem = _foodRepository.GetAll().FirstOrDefault(x => x.FoodItemId == foodItemId);
                response.Data = new FoodItemViewModel(foodItem);
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_GET_FOOD_ITEM_FAIL;
            }

            return Json(response);
        }
        public ActionResult UpdateGuestInfo(EditEventViewModel model)
        {
            var response = new Response { Error = false };

            try
            {
                //Get the person
                var thePerson = GetCurrentUser();

                //Get the event
                var theEvent = GetEventById(model.EventId);

                //Update the guest info
                int guestId = Math.Abs(model.UpdateGuest.PersonId); //Make the guest id posative before we hit the database
                var updateMe = _inviteRepository.GetAll().FirstOrDefault(x => x.PendingInvitationId == guestId);
                updateMe.FirstName = model.UpdateGuest.FirstName;
                updateMe.LastName = model.UpdateGuest.LastName;
                updateMe.Email = model.UpdateGuest.Email;

                //Get list of pending invitation ids
                var pendingEventInvitations = SessionUtility.Events.GetGuestList(model.EventId);
                var personFriendsList = GetPersonFriendList(thePerson);

                //Populate the guset list
                var viewModel = GetEventViewModel(theEvent);
                viewModel.PeopleInvited = GetSelectedGuests(pendingEventInvitations, personFriendsList, model.EventId);

                response.Data = RenderRazorViewToString("_InvitedPeopleTemplate", viewModel);

                //Save to the database last
                _inviteRepository.SubmitChanges();
            }
            catch (Exception)
            {
                //TODO: log error to database
                response.Error = true;
                response.Message = Constants.SERVICE_UPDATE_GUEST_FAIL;
            }

            return Json(response);
        }
        public ActionResult Update(string json)
        {
            var blogs = JsonConvert.DeserializeObject<List<BlogViewModel>>(json);
            var response = new Response { Error = false, Message = "Save successful." };

            try
            {
                using (var context = new KnockoutBasicsContext())
                {
                    foreach (var blog in blogs)
                    {
                        //Add or update blog
                        if (blog.BlogId == 0)
                        {
                            var addMe = blog.GetDataModel();
                            context.Blogs.Add(addMe);
                        }
                        else
                        {
                            var updateBlog = context.Blogs.FirstOrDefault(x => x.BlogId == blog.BlogId);

                            if (updateBlog == null)
                            {
                                response.Error = true;
                                response.Message = string.Format("Unable to find blog id '{0}'.", blog.BlogId);
                                return Json(response);
                            }

                            updateBlog.Name = blog.Name;

                            foreach (var post in blog.Posts)
                            {
                                //Add or update post
                                if (post.PostId == 0)
                                {
                                    var addPost = post.GetDataModel();
                                    addPost.Blog = updateBlog;
                                    context.Posts.Add(addPost);
                                }
                                else
                                {
                                    var updatePost = context.Posts.FirstOrDefault(x => x.PostId == post.PostId);

                                    if (updatePost == null)
                                    {
                                        response.Error = true;
                                        response.Message = string.Format("Unable to find post id '{0}'.", post.PostId);
                                        return Json(response);
                                    }

                                    updatePost.Title = post.Title;
                                    updatePost.Content = post.Content;
                                }
                            }
                        }

                        //Remove any posts...
                        var notNewPostIds = blog.Posts.Where(x => x.PostId != 0).Select(x => x.PostId);
                        var removeThesePosts = context.Posts.Where(x => !notNewPostIds.Contains(x.PostId)
                            && x.Blog.BlogId == blog.BlogId);

                        removeThesePosts.ToList().ForEach(x => context.Posts.Remove(x));
                    }

                    //Remove any blogs...
                    var notNewBlogIds = blogs.Where(x => x.BlogId != 0).Select(x => x.BlogId);
                    var removeTheseBlogs = context.Blogs.Where(x => !notNewBlogIds.Contains(x.BlogId));

                    removeTheseBlogs.ToList().ForEach(x =>
                        {
                            //Remove all of the blog's posts first...
                            var removePostIds = x.Posts.Select(y => y.PostId).ToArray();
                            foreach (var postId in removePostIds)
                            {
                                var removeMe = context.Posts.FirstOrDefault(y => y.PostId == postId);
                                context.Posts.Remove(removeMe);
                            }

                            //Then remove the blog.
                            context.Blogs.Remove(x);
                        });

                    context.SaveChanges();

                    //Requery the database to get updates...
                    blogs = new List<BlogViewModel>();
                    var data = context.Blogs.Include("Posts").ToList();
                    data.ForEach(model => blogs.Add(new BlogViewModel(model)));
                    blogs = blogs.OrderByDescending(x => x.BlogId).ToList();

                    response.Updated = JsonConvert.SerializeObject(blogs);
                }
            }
            catch (Exception ex)
            {
                //Log an error to the database
                using (var context = new KnockoutBasicsContext())
                {
                    var error = new ErrorLog { Message = ex.Message, CallStack = ex.StackTrace };
                    context.ErrorLogs.Add(error);
                    context.SaveChanges();
                }

                response.Error = true;
                response.Message = "An error occurred on the server while trying to save.";
            }

            return Json(response);
        }