private string GetTargetFileFullPath(RulesDto rulesDto, GeneralOptionsDto generalOptionsDto) { var actualProjectPath = GetProjectPath(rulesDto.ProjectName); if (!string.IsNullOrEmpty(actualProjectPath)) { var actualFilePath = GetFilePathWithinProjectDirectory(rulesDto.FileName, actualProjectPath); if (!string.IsNullOrEmpty(actualFilePath)) { var targetFileIsUnderSourceControl = dte.SourceControl.IsItemUnderSCC(actualFilePath); if (FileIsEligibleToBeChanged(rulesDto, generalOptionsDto, actualFilePath, targetFileIsUnderSourceControl)) { if (File.Exists(actualFilePath)) { return(actualFilePath); } else { failureMessages.Add("File " + actualFilePath + " does not exist"); return(string.Empty); } } } } return(string.Empty); }
public async Task <IActionResult> GetRules(string app) { var rules = await appProvider.GetRulesAsync(AppId); var response = RulesDto.FromRules(rules, this, app); Response.Headers[HeaderNames.ETag] = response.GenerateEtag(); return(Ok(response)); }
public async Task <IActionResult> GetRules(string app) { var rules = await ruleQuery.QueryAsync(Context); var response = Deferred.AsyncResponse(() => { return(RulesDto.FromRulesAsync(rules, ruleRunnerService, Resources)); }); return(Ok(response)); }
public async Task <IActionResult> GetRules(string app) { var rules = await ruleQuery.QueryAsync(Context); var response = Deferred.Response(() => { return(RulesDto.FromRules(rules, this, app)); }); return(Ok(response)); }
private void CanLoadAccessLevelFromPath(string rulesPath, string sessionMapPath) { var fileLoader = new FileLoader(); var settings = new SettingsStub() .WithRulesPath(Path.Combine(Directory.GetCurrentDirectory(), rulesPath)) .WithSessionMapPath(Path.Combine(Directory.GetCurrentDirectory(), sessionMapPath)); var repos = new SecurityRepository(fileLoader, settings); RulesDto level = repos.LoadAccessLevel().Result; Assert.IsNotNull(level); level.AssertNoPropertiesAreNull(new [] { "Identifier" }); }
public async Task<IActionResult> GetRules(string app) { var rules = await ruleQuery.QueryAsync(Context); var response = Deferred.Response(() => { return RulesDto.FromRules(rules, this, app); }); Response.Headers[HeaderNames.ETag] = rules.ToEtag(); return Ok(response); }
public async Task <IActionResult> GetRules(string app) { var rules = await appProvider.GetRulesAsync(AppId); var response = Deferred.Response(() => { return(RulesDto.FromRules(rules, this, app)); }); Response.Headers[HeaderNames.ETag] = rules.ToEtag(); return(Ok(response)); }
public async Task <IActionResult> GetRules(string app) { var rules = await ruleQuery.QueryAsync(Context); var runningRuleId = await ruleRunnerService.GetRunningRuleIdAsync(Context.App.Id); var response = Deferred.Response(() => { return(RulesDto.FromRules(rules, runningRuleId, this, app)); }); return(Ok(response)); }
public void CanLoadAccessLevel() { // var webLoader = new WebLoader(); // var settings = new SettingsStub(); // var repos = new SecurityRepository(webLoader, settings); var fileLoader = new FileLoader(); var settings = new SettingsStub() .WithRulesPath(Path.Combine(Directory.GetCurrentDirectory(), @"../../../../../resource/test/ignite_rules.json")) .WithSessionMapPath(Path.Combine(Directory.GetCurrentDirectory(), @"../../../../../resource/test/ignite_session_map.json")); var repos = new SecurityRepository(fileLoader, settings); RulesDto level = repos.LoadAccessLevel().Result; Assert.IsNotNull(level); level.AssertNoPropertiesAreNull(new [] { "Identifier" }); }
private IEnumerable <string> PerformFindReplace(RulesDto rulesDto, GeneralOptionsDto generalOptionsDto, string targetFileFullPath) { var findReplaceMessages = new List <string>(); dte.ItemOperations.OpenFile(targetFileFullPath); var textDocument = dte.ActiveDocument.Object("TextDocument") as TextDocument; if (textDocument == null) { failureMessages.Add("File " + rulesDto.FileName + " is not an editable text file"); } else { var find = textDocument.DTE.Find; vsFindOptions vsFindOptions; if (rulesDto.CaseSensitive) { vsFindOptions = vsFindOptions.vsFindOptionsMatchCase; } else { vsFindOptions = vsFindOptions.vsFindOptionsFromStart; } var result = find.FindReplace(vsFindAction.vsFindActionReplaceAll, rulesDto.FindWhat, (int)vsFindOptions, rulesDto.ReplaceWith, vsFindTarget.vsFindTargetCurrentDocument); if (result == vsFindResult.vsFindResultReplaced) { changesCount++; findReplaceMessages.Add(rulesDto.FileName.ToLower() + " in " + rulesDto.ProjectName.ToLower()); dte.ActiveDocument.Save(); } } if (!generalOptionsDto.KeepFileOpenAfterSave) { dte.ActiveDocument.Close(); } return(findReplaceMessages); }
public PermissionManager(RulesDto rules) { rules.UserAccess = new List <ProfileDto>( rules .UserAccess .Where(access => access.Identifiers != null && access.Identifiers.Length > 0) .SelectMany(access => access.Identifiers.Select(identifier => new ProfileDto { Identifier = identifier, Identifiers = access.Identifiers ?? new string[] {}, Access = access.Access, EvalAccess = access.EvalAccess, Reporting = access.Reporting, SessionSetAccess = access.SessionSetAccess, VisibleAttendeeTypes = access.VisibleAttendeeTypes })) .Union(rules.UserAccess.Where(access => !string.IsNullOrEmpty(access.Identifier)))); _permission = new Lazy <Dictionary <string, ProfileDto> >(() => rules.UserAccess.ToDictionary(rule => rule.Identifier.ToLowerInvariant())); }
private bool FileIsEligibleToBeChanged(RulesDto rulesDto, GeneralOptionsDto generalOptionsDto, string actualFilePath, bool targetFileIsUnderSourceControl) { bool fileIsEligibleToBeChanged; if (!string.IsNullOrEmpty(actualFilePath)) { if (generalOptionsDto.UnderSourceControlOnly && !targetFileIsUnderSourceControl) { failureMessages.Add("File " + rulesDto.FileName + " is not under source-control"); fileIsEligibleToBeChanged = false; } else { fileIsEligibleToBeChanged = true; } } else { fileIsEligibleToBeChanged = false; } return(fileIsEligibleToBeChanged); }
public PermissionManager(RulesDto rules) { _permission = new Lazy <Dictionary <string, ProfileDto> >(() => rules.UserAccess.ToDictionary(rule => rule.Identifier.ToLowerInvariant())); }
public override void SaveSettingsToStorage() { base.SaveSettingsToStorage(); var shellSettingsManager = new ShellSettingsManager(ServiceProvider.GlobalProvider); var writableSettingsStore = shellSettingsManager.GetWritableSettingsStore(SettingsScope.UserSettings); if (writableSettingsStore.CollectionExists(Constants.CollectionPath)) { writableSettingsStore.DeleteCollection(Constants.CollectionPath); } if (!writableSettingsStore.CollectionExists(Constants.CollectionPath)) { writableSettingsStore.CreateCollection(Constants.CollectionPath); } var userControlWindow = (RulesUserControl)Window; var dgv = userControlWindow.Controls.Find(Constants.DataGridViewName, false).First() as DataGridView; var rulesDtos = new List <RulesDto>(); var rows = dgv.Rows.Cast <DataGridViewRow>(); for (int i = 0; i < rows.Count(); i++) { var rulesDto = new RulesDto(); var dgvRow = dgv.Rows[i]; foreach (DataGridViewCell cell in dgvRow.Cells) { var owner = cell.OwningColumn; switch (owner.DataPropertyName) { case "FindWhat": rulesDto.FindWhat = (string)cell.EditedFormattedValue; break; case "ReplaceWith": rulesDto.ReplaceWith = (string)cell.EditedFormattedValue; break; case "FileName": rulesDto.FileName = (string)cell.EditedFormattedValue; break; case "SolutionName": rulesDto.SolutionName = (string)cell.EditedFormattedValue; break; case "Comments": rulesDto.Comments = (string)cell.EditedFormattedValue; break; case "ProjectName": rulesDto.ProjectName = (string)cell.EditedFormattedValue; break; case "Enabled": rulesDto.Enabled = (bool)cell.EditedFormattedValue; break; case "CaseSensitive": rulesDto.CaseSensitive = (bool)cell.EditedFormattedValue; break; default: break; } } rulesDtos.Add(rulesDto); } var settingsStoreValue = JsonConvert.SerializeObject(rulesDtos); writableSettingsStore.SetString(Constants.CollectionPath, Constants.PropertyName, settingsStoreValue); }