private void AddPage(object sender, RoutedEventArgs e)
{
BookPage p = new BookPage();
int idx = pageList.Children.Count;
pageList.Children.Insert(idx - 1, p);
if (idx < 10)
{
p.pageIdx.Text = string.Format("第0{0}页", idx);
}
else
{
p.pageIdx.Text = string.Format("第{0}页", idx);
}
if (pageList.Children.Count == 51)
{
newPage.IsEnabled = false;
}
JsonEditor doc = p.doc;
doc.Bold = bold;
doc.Italic = italic;
doc.Underlined = underlined;
doc.Strikethrough = strikethrough;
doc.Obfuscated = obfuscated;
doc.ColorPicker = TextColor;
doc.Window = (CmdGenerator.Parent as ContentControl).Parent as IMtbWindow;
doc.EntitySelector = ES;
doc.InitializeSettings(clearStyle, c, addSelector, addObjective, addEvent, TextColor, doc.Foreground);
doc.GotFocus += FocusedChanged;
}
static void Main(string[] args)
{
if (args.Length < 1)
{
throw new ArgumentNullException("root path is expexted");
}
var rootPath = args[0];
IDictionary <FileType, string> filesPath = new Dictionary <FileType, string>()
{
{ FileType.Config, $"{rootPath}config.json" },
{ FileType.Launch, $"{rootPath}launch.json" },
{ FileType.Task, $"{rootPath}tasks.json" }
};
JsonEditor jsonEditor = new JsonEditor(filesPath);
var config = jsonEditor.GetConfig();
var activeSolution = jsonEditor.GetActiveConfiguration();
var jsonLanuch = jsonEditor.LoadLunchJson();
var jsonTask = jsonEditor.LoadTaskJson();
jsonLanuch.SetupConfiguration(config, activeSolution);
jsonTask.SetupConfiguration(config, activeSolution);
jsonEditor.Update <JsonLaunch>(jsonLanuch);
jsonEditor.Update <JsonTask>(jsonTask);
}
public int Execute()
{
string result = JsonEditor.GetValue(Path, Key);
System.Console.Write(result);
return(0);
}
public void ShouldReturn_ActiveConfiguration()
{
var jsonEditor = new JsonEditor(filesPath);
Solution activeSolution = jsonEditor.GetActiveConfiguration();
Assert.AreEqual("serializacja", activeSolution.Key);
}
public async Task AddAndSelectRuleLevel(string bicepConfigFilePath, string ruleCode)
{
if (await SelectRuleLevelIfExists(ruleCode, bicepConfigFilePath))
{
// The rule already exists and has been shown/selected
return;
}
string json = File.ReadAllText(bicepConfigFilePath);
(int line, int column, string text)? insertion = new JsonEditor(json).InsertIfNotExist(
new string[] { "analyzers", "core", "rules", ruleCode },
new { level = "warning" });
if (insertion.HasValue)
{
var(line, column, insertText) = insertion.Value;
try
{
File.WriteAllText(bicepConfigFilePath, JsonEditor.ApplyInsertion(json, (line, column, insertText)));
}
catch (Exception ex)
{
server.Window.ShowError($"Unable to write to configuration file \"{bicepConfigFilePath}\": {ex.Message}");
}
await SelectRuleLevelIfExists(ruleCode, bicepConfigFilePath);
}
}
private void InitializeWithPopulatedJson()
{
_PathToSampleConfigFile = CreateSampleJsonConfigFile();
Console.WriteLine(_PathToSampleConfigFile);
_SystemUnderTest = new JsonEditor(_PathToSampleConfigFile);
}
public ManageController(ApplicationDbContext dbContext,
ILogger <ManageController> logger,
UserManager <User> userManager)
{
_manage = new Manage(new DbManage(dbContext, logger), new JsonEditor(logger), logger, userManager);
_jsonEditor = new JsonEditor(logger);
_logger = logger;
}
public int Execute()
{
if (!File.Exists(SourceFile))
{
File.WriteAllText(SourceFile, "{}");
}
JsonEditor.SetProperty(SourceFile, Key, Value);
return(0);
}
public ScheduleController(ApplicationDbContext dbContext, UserManager <User> userManager,
ILogger <ScheduleController> logger)
{
var dbAgenda = new DbAgenda(dbContext, logger);
var jsonEditor = new JsonEditor(logger);
_agenda = new Agenda(dbAgenda, jsonEditor, logger);
_userManager = userManager;
_logger = logger;
}
public AuthenticationController(
UserManager <User> userManager,
SignInManager <User> signInManager,
RoleManager <IdentityRole> roleManager,
ApplicationDbContext dbContext,
ILogger <AuthenticationController> logger)
{
_authentication = new Authentication(userManager, signInManager, roleManager, dbContext, logger);
_json = new JsonEditor(logger);
_logger = logger;
}
private void FromClipboardToolStripMenuItem_Click(object sender, EventArgs e)
{
if (selectedModViewer.IsVanilla)
{
return;
}
if (!Clipboard.ContainsText())
{
return;
}
JsonEditor je = new JsonEditor(Clipboard.GetText());
if (je.ShowDialog() == DialogResult.OK)
{
switch (je.ObjectType)
{
case "Aspect":
FromClipboardOnOkay(selectedModViewer.Content.Aspects, je.ObjectText);
break;
case "Element":
FromClipboardOnOkay(selectedModViewer.Content.Elements, je.ObjectText);
break;
case "Recipe":
FromClipboardOnOkay(selectedModViewer.Content.Recipes, je.ObjectText);
break;
case "Deck":
FromClipboardOnOkay(selectedModViewer.Content.Decks, je.ObjectText);
break;
case "Legacy":
FromClipboardOnOkay(selectedModViewer.Content.Legacies, je.ObjectText);
break;
case "Ending":
FromClipboardOnOkay(selectedModViewer.Content.Endings, je.ObjectText);
break;
case "Verb":
FromClipboardOnOkay(selectedModViewer.Content.Verbs, je.ObjectText);
break;
default:
MessageBox.Show("I'm not sure what you selected or how, but that was an invalid choice.", "Unknown Object Type", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
selectedModViewer.MarkDirty();
}
}
private string GetClaimValue(JsonEditor editor, string claimName)
{
var args = new SiblingValueArguments();
args.SiblingSearchKey = "typ";
args.SiblingSearchValue = claimName;
args.DesiredNodeKey = "val";
args.PathArguments = new[] { "user_claims" };
var temp = editor.GetSiblingValue(args);
return(temp);
}
private bool AddClaimIfExists(List <Claim> claims, JsonEditor editor, string claimTypeName)
{
var temp = GetClaimValue(editor, claimTypeName);
if (temp.IsNullOrWhitespace() == false)
{
AddClaim(claims, claimTypeName, temp);
return(true);
}
else
{
return(false);
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
JsonEditor = await _context.JsonEditor.FirstOrDefaultAsync(m => m.Id == id);
if (JsonEditor == null)
{
return(NotFound());
}
return(Page());
}
public bool Execute()
{
const string fullPath = "FullPath";
string src = SourceFile.GetMetadata(fullPath);
string dest = (DestinationFile?.GetMetadata(fullPath) ?? Path.Combine(Path.GetDirectoryName(BuildEngine.ProjectFileOfTaskNode), "appsettings.json"));
foreach (string path in JPath.Split(new char[] { ';', ',' }, System.StringSplitOptions.RemoveEmptyEntries))
{
JsonEditor.CopyProperty(src, dest, path);
BuildEngine.LogMessageEvent(new BuildMessageEventArgs(
$"Copied '{Path.GetFileName(src)}':'{path}' property to '{Path.GetFileName(dest)}'", null, nameof(CopyJsonProperties), MessageImportance.Normal));
}
return(true);
}
public Sign(CommandsGeneratorTemplate tmp)
{
InitializeComponent();
CmdGenerator = tmp;
line1.Bold = bold;
line1.Italic = italic;
line1.Underlined = underlined;
line1.Strikethrough = strikethrough;
line1.Obfuscated = obfuscated;
line1.ColorPicker = TextColor;
line1.Window = (tmp.Parent as ContentControl).Parent as IMtbWindow;
line1.EntitySelector = ES;
line1.InitializeSettings(clearStyle, c, null, null, null, TextColor, line1.Foreground);
line2.Bold = bold;
line2.Italic = italic;
line2.Underlined = underlined;
line2.Strikethrough = strikethrough;
line2.Obfuscated = obfuscated;
line2.ColorPicker = TextColor;
line2.Window = (tmp.Parent as ContentControl).Parent as IMtbWindow;
line2.EntitySelector = ES;
line2.InitializeSettings(clearStyle, c, null, null, null, TextColor, line2.Foreground);
line3.Bold = bold;
line3.Italic = italic;
line3.Underlined = underlined;
line3.Strikethrough = strikethrough;
line3.Obfuscated = obfuscated;
line3.ColorPicker = TextColor;
line3.Window = (tmp.Parent as ContentControl).Parent as IMtbWindow;
line3.EntitySelector = ES;
line3.InitializeSettings(clearStyle, c, null, null, null, TextColor, line3.Foreground);
line4.Bold = bold;
line4.Italic = italic;
line4.Underlined = underlined;
line4.Strikethrough = strikethrough;
line4.Obfuscated = obfuscated;
line4.ColorPicker = TextColor;
line4.Window = (tmp.Parent as ContentControl).Parent as IMtbWindow;
line4.EntitySelector = ES;
line4.InitializeSettings(clearStyle, c, null, null, null, TextColor, line4.Foreground);
EditingCommands.AlignCenter.Execute(null, line1);
EditingCommands.AlignCenter.Execute(null, line2);
EditingCommands.AlignCenter.Execute(null, line3);
EditingCommands.AlignCenter.Execute(null, line4);
editing = line1;
addSelector.Click += AddSelector_Click;
addObjective.Click += AddObjective_Click;
}
/// <summary>
/// On the "JSON" button click, this method opens a JSON editor that allows the user to modify JSON data in the action variable.
/// </summary>
private void jsonEditButton_Click(object sender, EventArgs e)
{
string json = JsonConvert.SerializeObject(action, ConfigManager.JsonSettings);
je = new JsonEditor();
je.Closing += (o, args) =>
{
action = JsonConvert.DeserializeObject(je.GetEditorText(), ConfigManager.JsonSettings);
BindActionToUi();
SetEnableModifications(true);
};
SetEnableModifications(false);
je.SetEditorText(json);
je.Show();
}
public void Can_get_json_value()
{
// Arrange
var sourceFile = TestData.GetFile("config1.json");
// Act
var result1 = JsonEditor.GetValue(sourceFile, "nugetKey");
var result2 = JsonEditor.GetValue(sourceFile, "local:datastore:auth");
var result3 = JsonEditor.GetValue(sourceFile, "local:datastore:main");
var result4 = JsonEditor.GetValue(sourceFile, "invaild");
// Assert
result1.ShouldNotBeNullOrEmpty();
result2.ShouldNotBeNullOrEmpty();
result3.ShouldNotBeNullOrEmpty();
result4.ShouldBeNullOrEmpty();
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
JsonEditor = await _context.JsonEditor.FindAsync(id);
if (JsonEditor != null)
{
_context.JsonEditor.Remove(JsonEditor);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public Book(CommandsGeneratorTemplate cmdGenerator)
{
InitializeComponent();
CmdGenerator = cmdGenerator;
JsonEditor doc = Page1.doc;
doc.Bold = bold;
doc.Italic = italic;
doc.Underlined = underlined;
doc.Strikethrough = strikethrough;
doc.Obfuscated = obfuscated;
doc.ColorPicker = TextColor;
doc.Window = (cmdGenerator.Parent as ContentControl).Parent as IMtbWindow;
doc.EntitySelector = ES;
doc.InitializeSettings(clearStyle, c, addSelector, addObjective, addEvent, TextColor, doc.Foreground);
Page1.doc.GotFocus += FocusedChanged;
editing = Page1.doc;
}
public void SetJsonValueUsingOneLevelOfElement()
{
string expectedValue = "new-value";
Args = CreateArgsArray(
CommandNameArgument,
GetArgEntry(Constants.ArgumentNameConfigFilename, _PathToSampleConfigFile),
GetArgEntry(Constants.ArgumentNameLevel1, "FirstLevel"),
GetArgEntry(Constants.ArgumentNameAttributeName, "processPath"),
GetArgEntry(Constants.ArgumentNameValue, expectedValue));
SystemUnderTest.Run();
var editor = new JsonEditor(_PathToSampleConfigFile);
var actual = editor.GetValue(
"FirstLevel");
Assert.AreEqual <string>(expectedValue, actual, "Result was wrong.");
}
public void Can_copy_json_property(string jpath)
{
// Arrange
string sourceFilePath = TestData.GetFile("config1.json");
string resultFilePath = Path.Combine(_currentWorkingDirectory, $"cecret-copy-test.{jpath}.json".Replace('*', '_'));
using var approver = ApprovalTests.Namers.ApprovalResults.ForScenario(jpath);
// Act
if (File.Exists(resultFilePath))
{
File.Delete(resultFilePath);
}
JsonEditor.CopyProperty(sourceFilePath, resultFilePath, jpath);
JsonEditor.CopyProperty(sourceFilePath, resultFilePath, jpath);
// Assert
File.Exists(resultFilePath).ShouldBeTrue();
Approvals.Verify(File.ReadAllText(resultFilePath));
}
public void SetJsonValueUsingTwoLevelsOfElement()
{
string expectedValue = "new-value";
Args = CreateArgsArray(
CommandNameArgument,
GetArgEntry(Constants.ArgumentNameConfigFilename, _PathToSampleConfigFile),
GetArgEntry(Constants.ArgumentNameLevel1, "ConnectionStrings"),
GetArgEntry(Constants.ArgumentNameLevel2, "DefaultConnectionString"),
GetArgEntry(Constants.ArgumentNameValue, expectedValue));
SystemUnderTest.Run();
var editor = new JsonEditor(_PathToSampleConfigFile);
var actual = editor.GetValue(
"ConnectionStrings", "DefaultConnectionString");
Assert.AreEqual <string>(expectedValue, actual, "Result was wrong.");
}
private void TestInsertion(string beforeText, string insertionPath, object insertionValue, string?afterText)
{
(int line, int column, string text)? insertion =
new JsonEditor(beforeText).
InsertIfNotExist(
insertionPath.Split('.').Where(p => p.Length > 0).ToArray(),
insertionValue);
if (afterText is null)
{
insertion.Should().BeNull();
}
else
{
insertion.Should().NotBeNull();
var newText = JsonEditor.ApplyInsertion(beforeText, insertion !.Value);
newText = newText.Replace("\r\n", "\n");
afterText = afterText.Replace("\r\n", "\n");
newText.Should().Be(afterText);
}
}
public void Can_set_json_property(string[] keys)
{
// Arrange
using var approver = ApprovalTests.Namers.ApprovalResults.ForScenario(string.Join("__", keys));
var line = string.Concat(Enumerable.Repeat('-', 50));
var sourceFile = Path.Combine(_currentWorkingDirectory, $"secrets-set-test({string.Join(" ", keys)}).json");
// Act
foreach (var item in keys)
{
JsonEditor.SetProperty(sourceFile, item, 123);
System.Diagnostics.Debug.WriteLine($"arg: {item}");
var result = File.ReadAllText(sourceFile);
System.Diagnostics.Debug.WriteLine(result);
System.Diagnostics.Debug.WriteLine(line);
System.Diagnostics.Debug.WriteLine(string.Empty);
System.Diagnostics.Debug.WriteLine(string.Empty);
}
// Assert
Approvals.VerifyFile(sourceFile);
}
private void AddClaimsFromAuthMeService(
HttpContext context, List <Claim> claims)
{
if (context.Request.Cookies.ContainsKey(SecurityConstants.Cookie_AppServiceAuthSession) == true)
{
var authMeJson = GetAuthMeInfo(context.Request);
var jsonArray = JArray.Parse(authMeJson);
var editor = new JsonEditor(jsonArray[0].ToString(), true);
AddClaimIfExists(claims, editor, ClaimTypes.GivenName);
AddClaimIfExists(claims, editor, ClaimTypes.Surname);
if (AddClaimIfExists(claims, editor, ClaimTypes.Email) == false)
{
var temp = editor.GetValue("user_id");
if (temp.IsNullOrWhitespace() == false)
{
claims.Add(new Claim(ClaimTypes.Email, temp));
}
}
}
}
public JsonTest()
{
_json = new JsonEditor();
}
private void FocusedChanged(object sender, RoutedEventArgs e)
{
editing.Selection.Select(editing.Document.ContentEnd, editing.Document.ContentEnd);
editing = sender as JsonEditor;
}
private void InitializeWithEmptyJson()
{
_PathToSampleConfigFile = CreateSampleJsonConfigFileEmpty();
_SystemUnderTest = new JsonEditor(_PathToSampleConfigFile);
}
// Per documentation here- https://docs.microsoft.com/en-us/azure/azure-resource-manager/bicep/parameter-files
// parameters file should be of below format:
//{
// "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#",
// "contentVersion": "1.0.0.0",
// "parameters": {
// "<first-parameter-name>": {
// "value": "<first-value>"
// },
// "<second-parameter-name>": {
// "value": "<second-value>"
// }
// }
//}
// However, azure-sdk-for-net expects parameters to be of name and value pairs:
// https://github.com/Azure/azure-sdk-for-net/blob/1e25b1bfc9b54df35d907aa7b2c10ff07082e845/sdk/resources/Azure.ResourceManager.Resources/src/Generated/Models/ArmDeploymentProperties.cs#L27
// We'll work around the above issue by first detecting the format of the file.
// If it's in the format descibed in the docs, we'll extract the parameters value and use that for actual deployment.
// If the user chose to create a new parameters file during the deployment flow, we'll follow the format
// mentioned in the docs as a best practise.
public static string GetUpdatedParametersFileContents(
string documentPath,
string parametersFileName,
string parametersFilePath,
ParametersFileUpdateOption updateOrCreateParametersFile,
IEnumerable <BicepUpdatedDeploymentParameter> updatedDeploymentParameters)
{
try
{
// Parameter file follows format mentioned here: https://docs.microsoft.com/en-us/azure/azure-resource-manager/bicep/parameter-files
var armSchemaStyleParametersFile = @"{
""$schema"": ""https://schema.management.azure.com/schemas/2019-04-01/deploymentParameters.json#"",
""contentVersion"": ""1.0.0.0"",
""parameters"": {
}
}";
// We will send across the secure param values to the azure sdk that handles deployment,
// but will avoid writing it to the parameters file for security reasons
var updatedParametersFile = !string.IsNullOrWhiteSpace(parametersFilePath) ?
File.ReadAllText(parametersFilePath) : armSchemaStyleParametersFile;
var updatedParametersFileWithoutSecureParams = updatedParametersFile;
var jObject = GetParametersObjectValue(updatedParametersFile, out bool isArmStyleTemplate);
foreach (var updatedDeploymentParameter in updatedDeploymentParameters.Reverse())
{
var name = updatedDeploymentParameter.name;
// Check to make sure parameters mentioned in parameters file are not overwritten
if (jObject.ContainsKey(name))
{
continue;
}
else
{
var jsonEditor = new JsonEditor(updatedParametersFile);
var propertyPaths = new List <string>();
if (isArmStyleTemplate)
{
propertyPaths.Add("parameters");
propertyPaths.Add(name);
}
else
{
propertyPaths.Add(name);
}
var valueObject = UpdateJObjectBasedOnParameterType(
updatedDeploymentParameter.parameterType,
updatedDeploymentParameter.value,
JObject.Parse("{}"));
(int line, int column, string text)? insertion = jsonEditor.InsertIfNotExist(propertyPaths.ToArray(), valueObject);
if (insertion.HasValue)
{
var(line, column, insertText) = insertion.Value;
updatedParametersFile = JsonEditor.ApplyInsertion(updatedParametersFile, (line, column, insertText));
if (!updatedDeploymentParameter.isSecure)
{
updatedParametersFileWithoutSecureParams = JsonEditor.ApplyInsertion(updatedParametersFileWithoutSecureParams, (line, column, insertText));
}
}
}
}
if (updatedDeploymentParameters.Any())
{
if (updateOrCreateParametersFile == ParametersFileUpdateOption.Update)
{
File.WriteAllText(parametersFilePath, updatedParametersFileWithoutSecureParams);
}
// ParametersFileCreateOrUpdate will have a value of "Overwrite" only if the parameters
// file with name <bicep_file_name>.parameters.json already exists and user chose to
// overwrite it with values from this deployment
else if (updateOrCreateParametersFile == ParametersFileUpdateOption.Create ||
updateOrCreateParametersFile == ParametersFileUpdateOption.Overwrite)
{
var directoryContainingBicepFile = Path.GetDirectoryName(documentPath);
if (directoryContainingBicepFile is not null)
{
File.WriteAllText(Path.Combine(directoryContainingBicepFile, parametersFileName), updatedParametersFileWithoutSecureParams);
}
}
}
var updatedJObject = GetParametersObjectValue(updatedParametersFile, out _);
return(updatedJObject.ToString());
}
catch (Exception e)
{
throw new Exception(string.Format(LangServerResources.InvalidParameterFileDeploymentFailedMessage, documentPath, parametersFilePath, e.Message));
}
}
