Inheritance: BaseObject
 public User Update(User user)
 {
     using (var svc = new ServiceProxyHelper<IUsersService>("UsersService"))
     {
         return svc.Proxy.Update(user);
     }
 }
 public Media AddAsContent(User user, string albumName, string filename, string path, string contentType)
 {
     using (var svc = new ServiceProxyHelper<IMediaService>("MediaService"))
     {
         return svc.Proxy.AddAsContent(user, albumName, filename, path, contentType);
     }
 }
 public User Update(User user, string authenticationToken)
 {
     using (var svc = new HttpClientHelper())
     {
         var result = JsonHelper.DeserializeJson<User>(
             svc.Put(Constants.BlogRestUrl, "users", user, authenticationToken));
         return result;
     }
 }
 public Media AddAsContent(User user, string albumName, string filename, string path, string contentType)
 {
     throw new System.NotImplementedException();
 }
 public Media AddAsContent(User user, string albumName, string filename, string path, string contentType)
 {
     return _mediaLogic.Add(user, albumName, filename, path, contentType);
 }
 public User Update(User user)
 {
     return _usersLogic.Update(user);
 }
 public User Add(User user)
 {
     return _usersLogic.Add(user);
 }
        public async Task<ActionResult> Edit(UserViewModel model)
        {
            try
            {
                if (!ModelState.IsValid)
                {
                    ViewBag.ErrorMessage = "Something went wrong. Please try again.";
                    return View(model);
                }

                var user = await UserManager.FindByNameAsync(model.UserName);
                if (user == null)
                {
                    ViewBag.IdentityMissing = true;
                    throw new Exception(string.Format("User {0} has no identity.", model.UserName));
                }

                user.Email = model.EmailAddress;

                var result = await UserManager.UpdateAsync(user);

                if (result.Succeeded)
                {
                    var roles = await UserManager.GetRolesAsync(user.Id);
                    if (roles.Count > 0)
                    {
                        var roleRemoveResult = await UserManager.RemoveFromRolesAsync(user.Id, roles.ToArray());
                        if (!roleRemoveResult.Succeeded) throw new Exception("Failed to update this user's role.");
                    }

                    var addToRoleResult = await UserManager.AddToRoleAsync(user.Id, model.SelectedRole);
                    if (!addToRoleResult.Succeeded)
                    {
                        AddErrors(addToRoleResult);
                        return View(model);
                    }

                    var userProfile = new User
                                      {
                                          Id = model.Id,
                                          UserName = model.UserName,
                                          FirstName = model.FirstName,
                                          LastName = model.LastName,
                                          BirthDate = model.BirthDate,
                                          IdentityId = user.Id,
                                          EmailAddress = model.EmailAddress,
                                          Picture = model.Picture,
                                          Background = model.Background
                                      };

                    var blogUser = _usersResource.Update(userProfile);
                    if (blogUser.Error == null) return RedirectToAction("Index", "Users");

                    ViewBag.UserCreationError = blogUser.Error.Message;
                    return View(model);
                }

                AddErrors(result);
                return View(model);
            }
            catch (Exception ex)
            {
                _errorSignaler.SignalFromCurrentContext(ex);
                ViewBag.ErrorMessage = ex.Message;
                return View(model);
            }
        }