public static void Main(string[] args)
{
try
{
var parsed = Args.Parse <JsonTransformArguments>(args);
//Console.WriteLine("You entered string '{0}' and int '{1}'", parsed.StringArg, parsed.IntArg);
var logger = new ConsoleJsonTransformationLogger();
var transform = new JsonTransformation(parsed.TransformFile, logger);
if (File.Exists(parsed.DestinationFile))
{
File.Delete(parsed.DestinationFile);
}
//File.Copy(parsed.SourceFile, parsed.DestinationFile);
var result = transform.Apply(parsed.SourceFile);
using (var destFile = File.OpenWrite(parsed.DestinationFile))
result.CopyTo(destFile);
Console.WriteLine($"Transform completed successfully into {parsed.DestinationFile}");
}
catch (ArgException ex)
{
Console.WriteLine(ex.Message);
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate <JsonTransformArguments>());
}
}
public void DoTransform(string sourceFile, string transformFile, string outputFile)
{
_jsonTransformationLogger.LogMessage("Attempting to perform transform.");
_jsonTransformationLogger.LogMessage($"Transforming source file: {sourceFile} using file {transformFile}");
var absoluteSourcePath = Path.GetFullPath(sourceFile);
JsonTransformation transformation = CreateJsonTransformation(transformFile);
// apply transform
using (Stream outputStream = transformation.Apply(absoluteSourcePath))
{
using (StreamReader streamReader = new StreamReader(outputStream))
{
string finalText = streamReader.ReadToEnd();
if (string.IsNullOrWhiteSpace(outputFile))
{
outputFile = defaultOutputFilename;
_jsonTransformationLogger.LogWarning($"No output filename was given. Using default filename of \"{defaultOutputFilename}\"");
}
_jsonTransformationLogger.LogMessage($"Writing transformed file to {outputFile}");
File.WriteAllText($"{outputFile}", finalText);
}
}
_jsonTransformationLogger.LogMessage("Done and done.");
}
protected internal override void TransformInternal(string destination, string source, string transformation)
{
using (var stream = new JsonTransformation(transformation).Apply(source))
{
this.SaveToFile(destination, stream);
}
}
public static string ApplyTransform(this string source, string transform)
{
using (var transformStream = transform.AsStream())
using (var sourceStream = source.AsStream())
{
JsonTransformation transformation = new JsonTransformation(transformStream, null);
var result = transformation.Apply(sourceStream);
return(result.ReadAsString());
}
}
private void TryTransformTest(string sourceString, string transformString, bool shouldTransformSucceed)
{
using (var transformStream = this.GetStreamFromString(transformString))
using (var sourceStream = this.GetStreamFromString(sourceString))
{
JsonTransformation transform = new JsonTransformation(transformStream, this.logger);
this.AssertTransformSucceeds(() => transform.Apply(sourceStream), shouldTransformSucceed);
}
}
public void RemovePropertyTest()
{
const string original = "{\"x\":\"originalValue\"}";
const string column = "json";
const string code = "((JObject)json).Remove(\"x\");";
var jsonScript = new JsonTransformation(column, code, format: false);
var result = jsonScript.Apply(original, null);
Assert.AreEqual("{}", result);
}
public void ApplyTest()
{
const string original = "{\"x\":\"originalValue\"}";
const string column = "json";
const string code = "json.x = \"modifiedValue\";";
var jsonScript = new JsonTransformation(column, code, format: false);
var result = jsonScript.Apply(original, null);
Assert.AreEqual("{\"x\":\"modifiedValue\"}", result);
}
internal static MemoryStream ApplyJsonTransformations(Stream configInputStream, Stream transformInputStream)
{
transformInputStream = EnvironmentHelper.ExpandEnvironmentVariablesInConfig(transformInputStream);
JsonTransformation jsonTransformation = new JsonTransformation(transformInputStream);
using (Stream configResultStream = jsonTransformation.Apply(configInputStream))
{
MemoryStream configOutputStream = new MemoryStream();
configResultStream.CopyTo(configOutputStream);
configOutputStream.Seek(0, SeekOrigin.Begin);
return(configOutputStream);
}
}
public void ReadOnly()
{
const string TransformSourceString = @"{
'@jdt.rename' : {
'A' : 'Astar'
}
}";
// create temporary files to use for the source and transform
using (ReadOnlyTempFile tempSourceFilePath = new ReadOnlyTempFile(SimpleSourceString))
using (ReadOnlyTempFile tempTransformFilePath = new ReadOnlyTempFile(TransformSourceString))
{
// apply transform
JsonTransformation transformation = new JsonTransformation(tempTransformFilePath.FilePath, this.logger);
this.AssertTransformSucceeds(() => transformation.Apply(tempSourceFilePath.FilePath), true);
}
}
private static void BaseTransformTest(string inputsDirectory, string testName)
{
// Removes the test name to find the source file
string sourceName = Path.GetFileNameWithoutExtension(testName);
var transformation = new JsonTransformation(inputsDirectory + testName + ".Transform.json");
// Read the resulting stream into a JObject to compare
using (Stream result = transformation.Apply(inputsDirectory + sourceName + ".Source.json"))
using (StreamReader streamReader = new StreamReader(result))
using (JsonTextReader jsonReader = new JsonTextReader(streamReader))
{
var expected = JObject.Parse(File.ReadAllText(inputsDirectory + testName + ".Expected.json"));
var transformed = JObject.Load(jsonReader);
Assert.True(JObject.DeepEquals(expected, transformed));
}
}
public void ThrowAndLogException()
{
string transformString = @"{
'@jdt.invalid': false
}";
using (var transformStream = this.GetStreamFromString(transformString))
using (var sourceStream = this.GetStreamFromString(SimpleSourceString))
{
JsonTransformation transform = new JsonTransformation(transformStream, this.logger);
var exception = Record.Exception(() => transform.Apply(sourceStream));
Assert.NotNull(exception);
Assert.IsType<JdtException>(exception);
var jdtException = exception as JdtException;
Assert.Contains("invalid", jdtException.Message);
Assert.Equal(ErrorLocation.Transform, jdtException.Location);
Assert.Equal(2, jdtException.LineNumber);
Assert.Equal(56, jdtException.LinePosition);
}
}
/// <inheritdoc/>
public bool Transform(string sourcePath, string transformPath, string destinationPath)
{
if (string.IsNullOrWhiteSpace(sourcePath))
{
throw new ArgumentException($"{nameof(sourcePath)} cannot be null or whitespace");
}
if (string.IsNullOrWhiteSpace(transformPath))
{
throw new ArgumentException($"{nameof(transformPath)} cannot be null or whitespace");
}
if (string.IsNullOrWhiteSpace(destinationPath))
{
throw new ArgumentException($"{nameof(destinationPath)} cannot be null or whitespace");
}
if (!File.Exists(sourcePath))
{
throw new FileNotFoundException(Resources.Resources.ErrorMessage_SourceFileNotFound, sourcePath);
}
if (!File.Exists(transformPath))
{
throw new FileNotFoundException(Resources.Resources.ErrorMessage_TransformFileNotFound, transformPath);
}
var transformation = new JsonTransformation(transformPath, this.logger);
try
{
using (Stream result = transformation.Apply(sourcePath))
{
return(this.TrySaveToFile(result, sourcePath, destinationPath));
}
}
catch
{
// JDT exceptions are handled by it's own logger
return(false);
}
}
private void TryTransformTest(string sourceString, string transformString, bool shouldTransformSucceed)
{
using (var transformStream = this.GetStreamFromString(transformString))
using (var sourceStream = this.GetStreamFromString(sourceString))
{
JsonTransformation transform = new JsonTransformation(transformStream, this.logger);
Stream result = null;
var exception = Record.Exception(() => result = transform.Apply(sourceStream));
if (shouldTransformSucceed)
{
Assert.NotNull(result);
Assert.Null(exception);
}
else
{
Assert.Null(result);
Assert.NotNull(exception);
Assert.IsType<JdtException>(exception);
}
}
}
public Stream Transform(Stream input, Stream transform)
{
var jdt = new JsonTransformation(transform, _logger);
return(jdt.Apply(input));
}
public AutoMapper(JObject mapping)
{
_mappingFile = mapping.ToObject <JsonMapping>();
transform = new JsonTransformation(_mappingFile);
}
public AutoMapper(string mapping)
{
_mappingFile = JsonConvert.DeserializeObject <JsonMapping>(mapping);
transform = new JsonTransformation(_mappingFile);
}
