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);
}
