public ActionResult Index()
        {
            RAGContext context = new RAGContext();

            HomeIndexViewModel model = new HomeIndexViewModel();
            model.Groups = context.Groups.ToList();
            
            return View(model);
        }
        public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
        {
            var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
            if (loginInfo == null)
            {
                return RedirectToAction("Login");
            }

            // Sign in the user with this external login provider if the user already has a login
            var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
            switch (result)
            {
                case SignInStatus.Success:
                    return RedirectToLocal(returnUrl);
                case SignInStatus.Failure:
                default:
                    // If the user does not have an account, then prompt the user to create an account
                    ViewBag.LoginProvider = loginInfo.Login.LoginProvider;

                    // Get the information about the user from the external login provider
                    var identity = loginInfo.ExternalIdentity;
                    string email = loginInfo.Email;
                    string name = identity.Claims.FirstOrDefault(c => c.Type == "urn:linkedin:name").Value;
                    string accessToken = identity.Claims.FirstOrDefault(c => c.Type == "urn:linkedin:accesstoken").Value;
                    string url = identity.Claims.FirstOrDefault(c => c.Type == "urn:linkedin:url").Value;

                    // check they are authorised
                    RAGContext rag = new RAGContext();
                    var permittedUsers = rag.PermittedUsers.Where(p => p.Email == email);

                    if (permittedUsers != null && permittedUsers.Count() == 1)
                    {
                        var permitted = permittedUsers.First();

                        var user = new ApplicationUser { UserName = email, Email = email, FullName = name, LinkedInProfile = url, LinkedInToken = accessToken, PermittedUser=permitted };

                        var createResult = await UserManager.CreateAsync(user);
                        if (createResult.Succeeded)
                        {
                            // set roles                            
                            if(!string.IsNullOrEmpty(permitted.Roles))
                            {
                                string[] roles = permitted.Roles.Split(new char[] { ',' });

                                foreach (string role in roles)
                                {
                                    await this.UserManager.AddToRoleAsync(user.Id, role);
                                }
                            }

                            createResult = await UserManager.AddLoginAsync(user.Id, loginInfo.Login);
                            if (createResult.Succeeded)
                            {
                                await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
                                return RedirectToLocal(returnUrl);
                            }
                        }
                    }

                    ExternalLoginFailureViewModel model = new ExternalLoginFailureViewModel(email);
                    return View("ExternalLoginFailure", model);
            }
        }
        public ActionResult UpdateStatus(HomeIndexViewModel model)
        {
            StatusUpdateViewFailedModel failureModel = new StatusUpdateViewFailedModel();
            failureModel.Message = "Unspecified Error.";

            if (ModelState.IsValid)
            {
                RAGContext context = new RAGContext();

                // get the current user
                string currentUserId = User.Identity.GetUserId();
//                ApplicationUser currentUser = context.Users.FirstOrDefault(x => x.Id == currentUserId);
                ApplicationUser currentUser = context.Users.Where(x => x.Id == currentUserId).FirstOrDefault();

                if (currentUser != null)
                {
                    // find the criteria we are updating
                    Criteria criteria = context.Criteria.Find(model.UpdateId);

                    if (criteria != null)
                    {
                        List<StatusUpdate> updates = new List<StatusUpdate>();

                        try
                        {
                            // if we have text and a state change, save both
                            if (model.UpdateStatus != criteria.State)
                            {
                                // save the state change
                                StatusUpdate state = new StatusUpdate();
                                state.Criteria = criteria;
                                state.StateFrom = criteria.State;
                                state.StateTo = model.UpdateStatus;
                                state.UpdateType = model.UpdateType;
                                state.User = currentUser;
                                state.Stamp = DateTime.Now;
                                criteria.Updates.Add(state);

                                criteria.State = model.UpdateStatus;

                                updates.Add(state);
                            }

                            // save the update text
                            StatusUpdate update = new StatusUpdate();
                            update.Criteria = criteria;
                            update.StateFrom = model.UpdateStatus;
                            update.StateTo = model.UpdateStatus;
                            update.UpdateType = model.UpdateType;
                            update.Text = model.UpdateText;
                            update.User = currentUser;
                            update.Stamp = DateTime.Now;
                            criteria.Updates.Add(update);

                            updates.Add(update);

                            context.SaveChanges();

                            // return view
                            StatusUpdateViewModel partialModel = new StatusUpdateViewModel(updates);
                            return PartialView("_StatusUpdatePartial", partialModel);
                        }
                        catch(Exception ex)
                        {
                            failureModel.Exception = ex;
                        }
                    }
                    else
                    {
                        failureModel.Message = "Unable to find Criteria.";
                    }
                }
                else
                {
                    failureModel.Message = "Unable to find ApplicationUser.";
                }
            }

            return PartialView("_StatusUpdateFailedPartial", failureModel);
        }