private SettingsLoader()
{
string SettingsFileName = Path.Combine(
System.Environment.GetFolderPath(System.Environment.SpecialFolder.ApplicationData),
@"NKF\RIO Desktop\Settings.xml");
System.Console.WriteLine(SettingsFileName);
XmlSerializer serializer = new XmlSerializer(typeof(SettingsDto));
if (File.Exists(SettingsFileName))
{
XmlReader reader = XmlReader.Create(new StringReader(Properties.Resources.Settings));
SettingsDto = (SettingsDto)serializer.Deserialize(reader);
}
else
{
FileStream fileStream = new FileStream(SettingsFileName, FileMode.Open);
XmlReader reader = XmlReader.Create(fileStream);
SettingsDto = (SettingsDto)serializer.Deserialize(reader);
fileStream.Close();
}
CacheImportMetaData();
CacheQueryFilters();
CacheDefaults();
}
public ActionResult Settings(string angularModuleName = "app-main.settings")
{
var builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json");
Configuration = builder.Build();
var settingsDto = new SettingsDto()
{
FileServiceUrl = Configuration["FileServiceUrl"],
DataServiceUrl = Configuration["DataServiceUrl"]
};
var serializerSettings = new JsonSerializerSettings
{
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var settingsJson = JsonConvert.SerializeObject(settingsDto, Formatting.Indented, serializerSettings);
var settingsModel = new SettingsViewModel()
{
SettingsJson = settingsJson,
AngularModuleName = angularModuleName
};
Response.ContentType = "text/javascript";
return(View(settingsModel));
}
public Settings CopyFrom(SettingsDto dto)
{
this.Key = dto.Key;
this.Val = dto.Val;
BaseCopyFrom <Settings>(dto);
return(this);
}
private void button1_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(textBoxKey.Text) &&
!string.IsNullOrEmpty(textBoxValue.Text))
{
if (Id > 0)
{
var data = settingsAppService.Get(new Abp.Application.Services.Dto.EntityDto <int>
{
Id = Id
});
data.Key = textBoxKey.Text;
data.Value = textBoxValue.Text;
data.Remark = textBoxRemark.Text;
settingsAppService.Update(data);
}
else
{
var data = new SettingsDto {
Key = textBoxKey.Text,
Value = textBoxValue.Text,
Remark = textBoxRemark.Text,
};
settingsAppService.Create(data);
}
MessageBox.Show("update success");
}
}
static void Main(string[] args)
{
var set = new SettingsDto();
set.Settings = new List <ISetting>();
set.Settings.Add(new Setting <int>()
{
Name = "Setting1", Value = 100
});
set.Settings.Add(new Setting <double>()
{
Name = "Setting2", Value = Math.PI
});
set.Settings.Add(new Setting <DateTime>()
{
Name = "Setting3", Value = DateTime.Now
});
set.Settings.Add(new Setting <int>()
{
Name = "Setting4", Value = 200
});
foreach (var setting in set.Settings.OfType <Setting <int> >())
{
Console.WriteLine("{0}={1}", setting.Name, setting.Value);
}
// Setting1=100
// Setting4=200
}
public State SetSettings(string userId, SettingsDto settings)
{
var state = GetState(userId);
// set categories
foreach (var categorySetting in settings.Categories)
{
var category = state.User.Categories.SingleOrDefault(c => c.Id == categorySetting.Id);
if (category == null)
{
continue;
}
category.Enabled = categorySetting.Enabled;
}
// check if there is any category enabled
if (!state.User.Categories.Any(c => c.Enabled))
{
state.User.Categories[0].Enabled = true; // enable first
}
// clear cache
state.CachedResult = null;
// save state and user data
_dbService.UpdateAsync(state.User);
SaveState(state);
return(state);
}
public IHttpActionResult ModifySettings([FromBody] SettingsDto settings)
{
if (settings == null || !ModelState.IsValid)
{
return(BadRequest(Resources.EmtyData));
}
var userClaims = HttpContext.Current.User.Identity as ClaimsIdentity
?? throw new ArgumentNullException(nameof(HttpContext.Current.User.Identity));
var idUser = Convert.ToInt64(userClaims.Claims.FirstOrDefault(x => x.Type == Resources.ClaimTypeId)?.Value);
if (idUser < 1 || !ModelState.IsValid)
{
return(BadRequest(Resources.IncorrectData));
}
try
{
settings.AccountId = idUser;
var user = _userService.ModifySettings(settings);
return(Ok(user));
}
catch (ArgumentException ex)
{
return(BadRequest(ex.Message));
}
catch (NotFoundUserException ex)
{
return(BadRequest(ex.Message));
}
catch (AddAccountException ex)
{
return(BadRequest(ex.Message));
}
}
public async Task CreateServerSummaryAsync(SettingsDto settingsDto)
{
var summary = _mapper.Map <Summary>(settingsDto);
summary.CreateDateTime = DateTimeOffset.Now;
CheckEmptyField(summary);
_context.Summaries.Add(summary);
try
{
await _context.SaveChangesAsync();
await _sysSqlLogManager.InsertLog(summary, LogActionEnum.Create);
}
catch (DbUpdateException)
{
if (SummaryExists(summary.SvcNo))
{
return;
}
else
{
throw;
}
}
}
public SettingsWindow(List <ITracker> trackers, SettingsDto dto, string version)
{
InitializeComponent();
_trackers = trackers;
TbVersion.Text = "Version: " + version;
SetDefaultValues(dto);
}
public async Task EditServerSummaryAsync(int serverId, SettingsDto settingsDto)
{
var summary = _mapper.Map <Summary>(settingsDto);
summary.LastMDateTime = DateTimeOffset.Now;
CheckEmptyField(summary);
_context.Entry(summary).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
await _sysSqlLogManager.InsertLog(summary, LogActionEnum.Edit);
}
catch (DbUpdateConcurrencyException)
{
if (!SummaryExists(serverId))
{
return;
}
else
{
throw;
}
}
}
/// <summary>
/// Loads the context.
/// </summary>
private void LoadContext()
{
SettingsDto settings = null;
if (!this.IsPostBack && (!this.Request.QueryString.ToString().Contains("Callback=yes"))) // load fresh on initial load
{
settings = LoadFresh();
}
else // load from session
{
settings = (SettingsDto)Session[_SettingsDtoEditSessionKey];
if (settings == null)
{
settings = LoadFresh();
}
}
// Put a dictionary key that can be used by other tabs
IDictionary dic = new ListDictionary();
dic.Add(_SettingsDtoString, settings);
// Call tabs load context
ViewControl.LoadContext(dic);
}
public SettingsDto CopyTo(SettingsDto dto)
{
dto.Key = this.Key;
dto.Val = this.Val;
BaseCopyTo <SettingsDto>(dto);
return(dto);
}
public SettingsDto GetSettings()
{
if (_settingsDto == null)
{
_settingsDto = ReadSettings();
}
return(_settingsDto);
}
public override global::System.Data.DataSet Clone()
{
SettingsDto cln = ((SettingsDto)(base.Clone()));
cln.InitVars();
cln.SchemaSerializationMode = this.SchemaSerializationMode;
return(cln);
}
private void SettingsListener_Received(object sender, SettingsDto e)
{
foreach (var pathWatcher in _pathWatchers)
{
pathWatcher.WaitInterval = e.Timeout;
pathWatcher.BarcodeManager.EndOfDocument = e.EndOfDocument;
}
}
public SettingsDto Persist(SettingsDto settingsDto)
{
List <Settings> settings = new List <Settings>();
List <SettingValueDto> settingValueDtos = settingsDto.GetAllSettingValues();
settingValueDtos.ForEach(x => settings.Add(_dtoToEntityConverter.Convert(_connection, x)));
settings.ForEach(x => _genericRepository.Persist <Settings>(x));
return(settingsDto);
}
public async Task <Result> CreateSettingsForUser(string access_token, SettingsDto settings)
{
(var userId, var result) = await _token_validator.ValidateAsync(_client, access_token);
try
{
if (result.Succeeded)
{
if (settings.Device == null)
{
settings.Device = "undefined";
}
//var unixtime = (uint)(DateTime.UtcNow - DateTime.UnixEpoch).TotalSeconds;
//if (Math.Abs(unixtime - settings.SyncTime) > 100)
// settings.SyncTime = unixtime;
var userSettings = await _store.SettingsStore.FindByUserId(userId);
settings.GibbonAccountId = userId;
if (userSettings == null)
{
var settingsModel = settings.ToModel();
await _store.SettingsStore.CreateAsync(settingsModel);
}
else
{
userSettings.GroupName = settings.GroupName;
userSettings.GroupLink = settings.GroupLink;
userSettings.AccentColor = settings.AccentColor;
userSettings.CustomAccentColor = settings.CustomAccentColor;
userSettings.BackDrop = settings.BackDrop;
userSettings.ThemeState = settings.ThemeState;
userSettings.LastSyncUnixTime = settings.SyncTime;
userSettings.Device = settings.Device;
await _store.UpdateAsync(userSettings);
}
await _store.SaveChangesAsync();
}
return(result);
}
catch (SqlException)
{
var error = new Error(ErrorCodes.DataBaseError);
return(Result.Failed(error));
}
catch (ArgumentException)
{
var error = new Error(ErrorCodes.InvalidParam);
return(Result.Failed(error));
}
catch
{
var error = new Error(ErrorCodes.UndefinedError);
return(Result.Failed(error));
}
}
public void TestSaveSettings_NoException()
{
var settings = new SettingsDto();
var expectedFilename = Path.Combine(Directory.GetCurrentDirectory(), "Settings.json");
Service.SaveSettings(settings);
Assert.IsTrue(File.Exists(expectedFilename));
}
internal static Setting FromDto(SettingsDto dto)
{
return(new Setting
{
Name = dto.Name,
Scope = dto.Scope.ToString(),
Value = dto.Value
});
}
public void Settings_CRUD()
{
var proxy = new ProxyService <SystemService>(new SystemService(new ServiceContext()));
//arrange
var dto = testUtil.SettingsDto();
//Create
var rpInsert = proxy.RunAsync(x => x.InsertSettings(dto));
rpInsert.Wait();
Assert.True(rpInsert.Result.Data > 0);
//Read
long identity = rpInsert.Result.Data;
var rpGet = proxy.RunAsync(x => x.GetSettings(identity));
rpGet.Wait();
Assert.True(rpInsert.Result.Data == rpGet.Result.Data.Id);
//Update
var tmpDto = rpGet.Result.Data;
tmpDto.Key = "Name updated!";
var rpUpdate = proxy.RunAsync(x => x.UpdateSettings(tmpDto));
rpUpdate.Wait();
var rpUpdateGet = proxy.RunAsync(x => x.GetSettings(identity));
rpUpdateGet.Wait();
Assert.Equal(rpUpdateGet.Result.Data.Key, tmpDto.Key);
//Delete
var rpDelete = proxy.RunAsync(x => x.DeleteSettings(identity));
rpDelete.Wait();
var rpDeleteGet = proxy.RunAsync(x => x.GetSettings(identity));
rpDeleteGet.Wait();
Assert.True(rpDeleteGet.Result.Data == null);
//List
var queryDto = new SettingsDto {
};
var pagingDto = new PagingDto {
pageSize = 3, pageNumber = 1
};
var rpList = proxy.RunAsync(x => x.ListSettings(queryDto, pagingDto));//List
rpList.Wait();
Assert.True(rpList?.Result.Data != null && rpList.Result.Data.Any());
//assert
//cleaup
var rpHardDelete = proxy.RunAsync(x => x.DeleteHardSettings(identity));
}
public ActionResult SaveSettings(SettingsDto settings)
{
var action = new SaveSettingsAction <ActionResult>(ServiceRegistry)
{
OnFailure = (model) => View("Index", model),
OnSuccess = () => RedirectToAction("Index")
};
return(action.Invoke(settings));
}
public SettingsWindow(List <ITracker> trackers, SettingsDto dto, string version)
{
InitializeComponent();
_trackers = trackers;
TbVersion.Text = "Version: " + version;
SetDefaultValues(dto);
// show/hide FlowLight tab depending on availability
FlowLightSettingsTab.Visibility = (dto.FlowLightAvailable.HasValue && dto.FlowLightAvailable.Value) ? Visibility.Visible : Visibility.Collapsed;
}
public SettingsDto Read(Guid id)
{
SettingsDto settingsDto = new SettingsDto();
List <SettingValueDto> settingValueDtos = new List <SettingValueDto>();
List <Settings> settings = _genericRepository.FindAll <Settings>();
settings.ForEach(x => settingValueDtos.Add(_entityToDtoConverter.Convert(_connection, x)));
settingsDto.SettAllSetingValues(settingValueDtos);
return(settingsDto);
}
public async Task <IActionResult> DemoLogin()
{
TimeSpan demoTokenLifeSpan = TimeSpan.Parse(_appSettings["DemoTokenLifeTime"]);
int demoUserCount = await _authRepo.CountDemoUsers();
demoUserCount++;
var newUser = new User()
{
UserName = $"demo{demoUserCount}",
DisplayName = "Demo Benutzer",
Email = "*****@*****.**",
AccountExpireDate = DateTime.Now.Add(demoTokenLifeSpan)
};
IdentityResult creationResult = await _userManager.CreateAsync(newUser, "P@ssw0rd");
if (!creationResult.Succeeded)
{
BadRequest(creationResult.Errors);
}
IdentityResult addRoleResult = await _userManager.AddToRolesAsync(newUser, new[] { RoleNames.Member, RoleNames.Demo });
if (!addRoleResult.Succeeded)
{
return(BadRequest(addRoleResult.Errors));
}
newUser = await _authRepo.CreateDemoData(newUser);
if (newUser == null)
{
throw new Exception("Error creating environment/demo data");
}
Permission defaultPermissions = await _authRepo.GetDefaultPermissions(newUser.Id);
_permissionsCache.AddEntriesForUser(newUser.Id, await _authRepo.GetAllUserPermissions(newUser.Id));
SettingsDto userSettings = await GetUserSettings(newUser.Id, new List <CameraDto>());
var mappedUser = _mapper.Map <UserForTokenDto>(newUser);
var permissionsToken = BuildPermissionToken(defaultPermissions, demoTokenLifeSpan);
return(Ok(new
{
identityToken = await CreateIdentityToken(newUser, demoTokenLifeSpan),
permissionsToken,
refreshToken = "",
mappedUser,
settings = userSettings
}));
}
public async Task <ServiceResponse <IEnumerable <SettingsDto> > > ListSettings([FromBody] IDictionary <string, object> data)
{
if (data == null)
{
throw new System.ArgumentNullException(nameof(data));
}
SettingsDto searchDto = JsonConvert.DeserializeObject <SettingsDto>(data["searchDto"].ToString());
PagingDto pagingDto = JsonConvert.DeserializeObject <PagingDto>(data["pagingDto"].ToString());
return(await Sm.SystemService.RunAsync(x => x.ListSettings(searchDto, pagingDto)));
}
public Task Settings()
{
return(HandleRequest <SettingsRequest, State>(r =>
{
var data = new SettingsDto
{
Categories = r.Categories.Select(c => new CategorySetting(c.Id, c.Enabled)).ToArray()
};
return _geoService.SetSettings(r.UserId, data);
}));
}
private void FitbitRevoke_Click(object sender, RoutedEventArgs e)
{
FitbitRevoke.IsEnabled = false;
// FitbitConnector.RevokeAccessToken(SecretStorage.GetAccessToken());
UpdatedSettingsDto = new SettingsDto();
UpdatedSettingsDto.FitbitTokenRevoked = true;
DialogResult = true;
this.Close();
}
/// <summary>
/// Saves the settings.
/// </summary>
/// <param name="dto">The dto.</param>
public static void SaveSettings(SettingsDto dto)
{
if (dto == null)
{
throw new ArgumentNullException("dto", String.Format("SettingsDto can not be null"));
}
CommonSettingsAdmin admin = new CommonSettingsAdmin(dto);
admin.Save();
}
public async Task <IActionResult> DemoLogin()
{
var tokenLifeTimeSeconds = Convert.ToInt32(_appSettings["TokenLifeTime"]);
int demoUserCount = await _authRepo.CountDemoUsers();
demoUserCount++;
var newUser = new User()
{
UserName = $"demo{demoUserCount}",
DisplayName = "Demo Benutzer",
Email = "*****@*****.**",
AccountExpireDate = DateTime.Now.AddSeconds(tokenLifeTimeSeconds)
};
IdentityResult creationResult = await _userManager.CreateAsync(newUser, "P@ssw0rd");
if (!creationResult.Succeeded)
{
BadRequest(creationResult.Errors);
}
IdentityResult addRoleResult = await _userManager.AddToRolesAsync(newUser, new[] { RoleNames.Member, RoleNames.Demo });
if (!addRoleResult.Succeeded)
{
return(BadRequest(addRoleResult.Errors));
}
newUser = await _authRepo.CreateDemoData(newUser);
if (newUser == null)
{
throw new Exception("Error creating environment/demo data");
}
List <Claim> identityClaims = await BuildIdentityClaims(newUser);
Permission defaultPermissions = await _authRepo.GetDefaultPermissions(newUser.Id);
List <Claim> permissionClaims = BuildPermissionClaims(defaultPermissions);
SettingsDto settings = await GetSettings(newUser.Id, new List <CameraDto>());
_permissionsCache.AddEntriesForUser(newUser.Id, await _authRepo.GetAllUserPermissions(newUser.Id));
var mappedUser = _mapper.Map <UserForTokenDto>(newUser);
return(Ok(new
{
identityToken = JwtHelper.CreateToken(identityClaims.ToArray(), _tokenSecretKey, DateTime.Now.AddSeconds(tokenLifeTimeSeconds)),
permissionsToken = JwtHelper.CreateToken(permissionClaims.ToArray(), _tokenSecretKey, DateTime.Now.AddSeconds(tokenLifeTimeSeconds)),
mappedUser,
settings
}));
}
public async Task <ResponseMeta <SettingsDto> > GetSettings()
{
using (var context = await _contextFactory)
{
var list = context.Settings.ToList();
var settings = new SettingsDto();
settings.CourseImageUrl = list.FirstOrDefault(s => s.Key == "CourseImageUrl")?.Value;
return(ResponseMeta <SettingsDto> .CreateSuccess(settings));
}
}
