public async Task <ActionResult> UpdateUserSetting(UserSettingModel setting) { CheckPermissions(); await _settingsService.UpdateUserSetting(setting); return(Json("OK")); }
public static UserSettingModel ToModel(this UserSettingPoco poco) { var model = new UserSettingModel(); model.UserId = poco.UserId; model.CaloriesDayLimit = poco.CaloriesDayLimit; return model; }
public async Task UpdateUserSetting(UserSettingModel settingModel) { var setting = await _userSettingsRepository.GetSettingValue(settingModel.Id, settingModel.UserId); setting.Value = setting.Value; await _userSettingsRepository.SaveChangesAsync(); }
public UserSettingModel GetUserSetting(int systemUserId) { var systemUser = _systemUserRepository.GetFirstOrDefault(predicate: a => a.SystemUserId == systemUserId, include: a => a.Include(b => b.Business).ThenInclude(b => b.BusinessToBusiness)); var universitySetting = _eduUniversityRepository.GetFirstOrDefault(predicate: a => a.BusinessId == (systemUser.Business.UniversityId ?? systemUser.BusinessId)); if (universitySetting == null) { throw new ApplicationException("University ID is invalid."); } var model = new UserSettingModel { IsMentorAllowedToSearchMentee = universitySetting.IsMentorAllowedToSearchMentee, MaxMenteeRequestedSent = universitySetting.MaxMenteeRequest, MaxNumberMenteeForMentor = universitySetting.MaxNumberMenteeForMentor, MaxNumberMentorForMentee = universitySetting.MaxNumberMentorForMentee, MenteeAlias = universitySetting.MenteeAlias, MentorAlias = universitySetting.MentorAlias, ProgramName = universitySetting.ProgramName, UniverisityNameAlias = universitySetting.UniversityNameAlias, }; var count = _connectionService.GetCounts(systemUserId); model.ConnectedCount = count.Connected; model.RequestedSentCount = count.Pending; return(model); }
public UserSettingModel GetUserAccountSetting(int userId) { UserSettingModel userSettingModel = new UserSettingModel(); UserSetting userSetting = accountRepository.SingleOrDefault(x => x.UserId == userId); AutoMapper.Mapper.Map(userSetting, userSettingModel); return(userSettingModel); }
public static void CopyToBllUser(this UserSettingModel settingModel, BllUser bllUser) { bllUser.Name = settingModel.Name; bllUser.LastName = settingModel.LastName; bllUser.FatherName = settingModel.FatherName; bllUser.Profession = settingModel.Profession; bllUser.ExtraInfo = settingModel.ExtraInfo; bllUser.Avatar = settingModel.Avatar.ToBllImage(); }
public async Task UserSetting_Test() { // Arrange // Login as testuser1 _jwtToken = await Login("testuser1"); UserSettingModel setting = new UserSettingModel { UserSettingId = 4, UserId = "testuser1", SettingKey = "test key3", SettingValue = "test value3", }; // This setting is invalid, since UserId in the UserSettingModel is marked as Required, but it is not provided in the object UserSettingModel invalidSetting = new UserSettingModel { UserSettingId = 5, SettingKey = "test key3", SettingValue = "test value3", }; // Add HttpResponseMessage response = await Invoke_UserSetting_Api(HttpMethod.Post, "v1/usersettings", setting); response.EnsureSuccessStatusCode(); // Add invalid setting would cause BadRequest response response = await Invoke_UserSetting_Api(HttpMethod.Post, "v1/usersettings", invalidSetting); Assert.Equal(StatusCodes.Status400BadRequest, (int)response.StatusCode); // Get All response = await Invoke_UserSetting_Api(HttpMethod.Get, "v1/usersettings"); response.EnsureSuccessStatusCode(); // Get One response = await Invoke_UserSetting_Api(HttpMethod.Get, "v1/usersettings/1"); response.EnsureSuccessStatusCode(); setting = JsonConvert.DeserializeObject <UserSettingModel>(await response.Content.ReadAsStringAsync()); // Update setting.SettingValue = "testvalue"; response = await Invoke_UserSetting_Api(HttpMethod.Put, "v1/usersettings", setting); response.EnsureSuccessStatusCode(); // Delete response = await Invoke_UserSetting_Api(HttpMethod.Delete, $"v1/usersettings/{setting.UserSettingId}"); response.EnsureSuccessStatusCode(); }
public ActionResult Setting(UserSettingModel newSetting) { if (ModelState.IsValid) { BllUser user = userService.GetUser(User.Identity.Name); newSetting.CopyToBllUser(user); userService.UpdateUser(user); return(RedirectToAction("UserInfo")); } return(View(newSetting)); }
public async Task <IActionResult> AddUserSetting([FromBody] UserSettingModel userSetting) { try { userSetting.UserId = HttpContext.User.Identity.Name; var setting = await _userSettingRepository.AddUserSetting(_mapper.Map <UserSetting>(userSetting)); return(Ok(_mapper.Map <UserSettingModel>(setting))); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } }
public IActionResult UpdateUserSetting([FromBody] UserSettingModel userSetting) { var setting = settings.FirstOrDefault(s => s.UserSettingId == userSetting.UserSettingId && s.UserId == HttpContext.User.Identity.Name); if (setting != null) { setting.SettingKey = userSetting.SettingKey; setting.SettingValue = userSetting.SettingValue; return(Ok(userSetting)); } else { return(StatusCode(StatusCodes.Status404NotFound, "User setting does not exist.")); } }
public IActionResult AddUserSetting([FromBody] UserSettingModel userSetting) { var setting = settings.FirstOrDefault(s => s.UserSettingId == userSetting.UserSettingId); if (setting != null) { return(StatusCode(StatusCodes.Status400BadRequest, "User setting already exists")); } else { userSetting.UserId = HttpContext.User.Identity.Name; settings.Add(userSetting); return(Ok(userSetting)); } }
public async Task UserSetting_Test() { // Arrange // Login as testuser2 _jwtToken = await Login("testuser2"); UserSettingModel setting3 = new UserSettingModel { SettingKey = "test key3", SettingValue = "test value3", UserId = "testuser2" }; setting3 = await AddUserSetting_Verify(setting3); // Login as testuser1 _jwtToken = await Login("testuser1"); UserSettingModel setting1 = new UserSettingModel { SettingKey = "test key1", SettingValue = "test value1", UserId = "testuser1" }; UserSettingModel setting2 = new UserSettingModel { SettingKey = "test key2", SettingValue = "test value2", UserId = "testuser1" }; setting1 = await AddUserSetting_Verify(setting1); setting2 = await AddUserSetting_Verify(setting2); await Get_UserSetting(2); await Get_UserSetting_Unauthorized(); await Delete_UserSetting_Successful(setting1.UserSettingId); await Delete_UserSetting_NotAuthorized(setting3.UserSettingId); await Delete_UserSetting_NotFound(10000); await Get_UserSetting_NotFound(setting1.UserSettingId); await Get_UserSetting_ByUserId_Unauthorized("testuser2"); // Login as admin _jwtToken = await Login("testadmin"); await Get_UserSetting_ByUserId_Successful("testuser2", 1); }
public async Task <IActionResult> AddUserSettingAsync([FromBody] UserSettingModel userSetting) { try { if (!ModelState.IsValid) { return(StatusCode(StatusCodes.Status400BadRequest, ModelState.ToString())); } userSetting.UserId = HttpContext.User.Identity.Name; return(Ok(await _userSettingService.AddUserSettingAsync(userSetting).ConfigureAwait(false))); } catch (Exception ex) { return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message)); } }
public ActionResult Index(UserSettingModel model) { if (ModelState.IsValid) { model.Email = model.Email.ToLower(); UserDto user = this.userService.GetUserByIdpID(((ClaimsPrincipal)this.User).IdentityProviderUserId()); if (user.Email != model.Email) { List <UserDto> users = this.userService.GetUsers(); List <UserInviteDto> userInvites = this.userService.GetUserInvites(); if (users.Count(x => x.Email == model.Email) != 0 || userInvites.Count(x => x.Email == model.Email) != 0) { model.EmailIsAlreadyUsed = true; return(View(model)); } this.userService.ChangeEmail(user.Id, model.Email); } this.userService.ChangeName(user.Id, model.FullName); this.userService.ChangeContact( user.Id, new ContactDto() { Type = global::Server.Service.Users.Contact.PrimaryNumber, Value = model.PrimaryNumber } ); if (!String.IsNullOrEmpty(model.SecondaryNumber)) { this.userService.ChangeContact( user.Id, new ContactDto() { Type = global::Server.Service.Users.Contact.SecondaryNumber, Value = model.SecondaryNumber } ); } } return(View(model)); }
public async Task UpdateUserSettingAsync(UserSettingModel setting) { var entity = await _context.UserSettings.FirstOrDefaultAsync(c => c.UserSettingId == setting.UserSettingId).ConfigureAwait(false); if (entity != null) { entity.UserId = setting.UserId; entity.SettingKey = setting.SettingKey; entity.SettingValue = setting.SettingValue; await _context.SaveChangesAsync().ConfigureAwait(false); } else { throw new ArgumentException($"Cannot find the user setting with id {setting.UserSettingId}"); } }
public IActionResult Settings(UserSetting olddata, UserSettingModel data, IFormFile files) { var user = new UserSetting() { BusinessEntityId = data.BusinessEntityId, CreateDate = data.CreateDate, FirstName = data.FirstName, LastName = data.LastName, MiddleName = data.MiddleName, ModifiedDate = System.DateTime.Now, rowguid = data.rowguid, Title = data.Title, UserSettingId = data.UserSettingId }; try { using (var memoryStream = new MemoryStream()) { //data.AvatarImage = files; data.avatarImage.CopyTo(memoryStream); user.AvatarImage = memoryStream.ToArray(); _accessor.HttpContext.Session.Set("User.Settings.AvatarImage", user.AvatarImage); } } catch { user.AvatarImage = olddata.AvatarImage; } if (!ModelState.IsValid) { return(View(data)); } _userSetting.Update(user); return(RedirectToAction("Settings")); }
// // GET: /Settings/GetUserSetting/?clid=xx&key=key1 public ActionResult GetUserSetting(UserSettingModel setting) { try { if (ModelState.IsValid) { setting.value = Kesco.ApplicationServices.Manager.GetUserSettingValue(setting.clid, setting.key); return(JsonModel(setting, JsonRequestBehavior.AllowGet)); } else { return(JsonError("Неверные данные", new { Model = setting, error_details = GetModelErrors() }, JsonRequestBehavior.AllowGet)); } } catch (Exception ex) { Kesco.Logger.WriteEx(ex); return(JsonError(ex.Message, ex.ToString(), JsonRequestBehavior.AllowGet)); } }
public ActionResult Index() { UserDto user = this.userService.GetUserByIdpID(((ClaimsPrincipal)this.User).IdentityProviderUserId()); UserSettingModel model = new UserSettingModel(); model.FullName = user.FullName; model.Email = user.Email; if (user.Contacts.Any()) { model.PrimaryNumber = user.Contacts.First().Value; } if (user.Contacts.Count == 2) { model.SecondaryNumber = user.Contacts[1].Value; } return(View(model)); }
private async Task <UserSettingModel> AddUserSetting_Verify(UserSettingModel setting) { HttpRequestMessage postRequest = new HttpRequestMessage(HttpMethod.Post, "v1/usersettings") { Content = new JsonContent(setting) }; postRequest.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _jwtToken.Token); HttpResponseMessage response = await client.SendAsync(postRequest); response.EnsureSuccessStatusCode(); var result = JsonConvert.DeserializeObject <UserSettingModel>(await response.Content.ReadAsStringAsync()); Assert.IsType <UserSettingModel>(result); Assert.Equal(result.SettingKey, setting.SettingKey); Assert.Equal(result.SettingValue, setting.SettingValue); Assert.Equal(result.UserId, setting.UserId); return(result); }
public async Task <UserSettingModel> AddUserSettingAsync(UserSettingModel userSetting) { UserSetting setting = await _context.UserSettings.FirstOrDefaultAsync(s => s.UserId == userSetting.UserId && s.SettingKey == userSetting.SettingKey).ConfigureAwait(false); if (setting == null) { setting = new UserSetting() { UserId = userSetting.UserId, SettingKey = userSetting.SettingKey, SettingValue = userSetting.SettingValue, }; await _context.UserSettings.AddAsync(setting).ConfigureAwait(false); await _context.SaveChangesAsync().ConfigureAwait(false); userSetting.UserSettingId = setting.UserSettingId; return(userSetting); } else { throw new ArgumentException("The user setting with same UserId and SettingKey already exists"); } }
public void UpdateUserAccountSetting(UserSettingModel userSettingModel) { UserSetting userSetting = new UserSetting(); userSetting = accountRepository.SingleOrDefault(x => x.UserSettingId == userSettingModel.UserSettingId); if (userSetting != null) { userSetting.UserId = userSettingModel.UserId; userSetting.IsSendNotificationsRecentActivities = userSettingModel.IsSendNotificationsRecentActivities; userSetting.UserSettingId = userSettingModel.UserSettingId; accountRepository.Update(userSetting); // AutoMapper.Mapper.Map(accountseting, accountSettingModel); } else { userSetting = new UserSetting(); userSetting.UserId = userSettingModel.UserId; userSetting.IsSendNotificationsRecentActivities = userSettingModel.IsSendNotificationsRecentActivities; accountRepository.Insert(userSetting); // AutoMapper.Mapper.Map(accountseting,accountSettingModel); } // return accountSettingModel; }
private async Task <HttpResponseMessage> Invoke_UserSetting_Api(HttpMethod httpMethod, string apiUrl, UserSettingModel setting = null) { HttpRequestMessage request = new HttpRequestMessage(httpMethod, apiUrl); if (setting != null) { request.Content = new JsonContent(setting); } request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _jwtToken.Token); return(await client.SendAsync(request).ConfigureAwait(false)); }
public SysConfigPresenter(LocationStoreUserInfoModel lsui, string execpath) { lsuiModel = lsui; executablePath = execpath; usModel = new UserSettingModel(lsuiModel).LoadUserSetting(executablePath, lsui); }
/// <summary> /// 加载用户配置 /// </summary> public void LoadUserSetting() { UsModel = usModel.LoadUserSetting(executablePath); }