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