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