private void populateLists() {
IProxyGenerator gen1 = new CSharpGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen1.GetName(), gen1));
IProxyGenerator gen2 = new JavaScriptGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen2.GetName(), gen2));
IProxyGenerator gen3 = new JavaScriptDojoAMDGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen3.GetName(), gen3));
IProxyGenerator gen4 = new JavaGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen4.GetName(), gen4));
IProxyGenerator gen5 = new ObjectiveCGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen5.GetName(), gen5));
IProxyGenerator gen6 = new FlexGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen6.GetName(), gen6));
IProxyGenerator gen7 = new AngularGenerator();
cmbGenerator.Items.Add(new GeneratorItem(gen7.GetName(), gen7));
cmbTypeMap.Items.Add(new TypeMapItem("No Type Map", null));
ResourceManager resMan = new ResourceManager();
foreach (TypeMap tm in resMan.GetTypeMaps())
{
TypeMapItem item = new TypeMapItem(tm.Name, tm);
cmbTypeMap.Items.Add(item);
}
cmbTypeMap.Items.Add(new TypeMapItem("Custom", null));
}
public void WriteList(IEnumerable<ParserRuleContext> expressionContexts, CSharpGenerator generator)
{
var firstParam = true;
foreach(var argument in expressionContexts)
{
if(firstParam)
firstParam = false;
else
Write(", ");
argument.Accept(generator);
}
}
public List <MetadataType> GetMetadataTypesForOperation(IRequest httpReq, Operation op)
{
var typeMetadata = HostContext.TryResolve <INativeTypesMetadata>();
var typesConfig = HostContext.AppHost.GetTypesConfigForMetadata(httpReq);
var metadataTypes = typeMetadata != null
? typeMetadata.GetMetadataTypes(httpReq, typesConfig)
: new MetadataTypesGenerator(this, typesConfig)
.GetMetadataTypes(httpReq);
var types = new List <MetadataType>();
var reqType = FindMetadataType(metadataTypes, op.RequestType);
if (reqType != null)
{
types.Add(reqType);
AddReferencedTypes(reqType, metadataTypes, types);
}
var resType = FindMetadataType(metadataTypes, op.ResponseType);
if (resType != null)
{
types.Add(resType);
AddReferencedTypes(resType, metadataTypes, types);
}
var generator = new CSharpGenerator(typesConfig);
types.Each(x =>
{
x.DisplayType = x.DisplayType ?? generator.Type(x.Name, x.GenericArgs);
x.Properties.Each(p =>
p.DisplayType = p.DisplayType ?? generator.Type(p.Type, p.GenericArgs));
});
return(types);
}
public bool GenerateClassLibrarys(out List <string> errors, string outFileName)
{
errors = new List <string>();
outFileName = Path.Combine(System.IO.Path.GetDirectoryName(outFileName), Path.GetFileNameWithoutExtension(outFileName));
string error;
string curSchema;
Task <JsonSchema4> schema;
curSchema = ParseSchemas(out error);
if (!string.IsNullOrEmpty(error))
{
errors.Add(error);
return(false);
}
try
{
schema = FromJsonAsync(curSchema);
schema.Result.Title = "Models";
generator = new CSharpGenerator(schema.Result, csgs, resolver);
generator.GenerateTypes(schema.Result, "");
string file = generator.GenerateFile();
if (outputAs == eOutputType.Library)
{
return(CompileCSharpCode(file, outFileName + ".dll", out errors));
}
try
{
File.WriteAllText(outFileName + ".cs", file);
}
catch (Exception ex)
{
errors.Add(ex.Message);
return(false);
}
}
catch (Exception ex)
{
errors.Add(ex.Message);
return(false);
}
return(true);
}
public async Task When_integer_property_has_minimum_and_maximum_with_exclusive_true_then_range_attribute_is_rendered_in_Swagger_mode()
{
//// Arrange
const string json = @"{
'type': 'object',
'required': [ 'value' ],
'properties': {
'value': {
'$ref': '#/definitions/int100000000'
}
},
'definitions': {
'int100000000': {
'type': 'integer',
'minimum': -100000000,
'exclusiveMinimum': true,
'maximum': 100000000,
'exclusiveMaximum': true,
}
}
}";
var schema = await JsonSchema.FromJsonAsync(json);
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.Swagger2
});
var code = generator.GenerateFile("Message");
//// Assert
Assert.Null(schema.Properties["value"].Minimum);
Assert.Equal(-100000000m, schema.Properties["value"].ActualSchema.Minimum);
Assert.Equal(100000000m, schema.Properties["value"].ActualSchema.Maximum);
Assert.True(schema.Properties["value"].ActualSchema.IsExclusiveMaximum);
Assert.True(schema.Properties["value"].ActualSchema.IsExclusiveMinimum);
// expect the integer to be converted to an int64
Assert.Contains("[System.ComponentModel.DataAnnotations.Range(-99999999, 99999999)]\n" +
" public int Value { get; set; }\n", code);
}
public async Task When_array_property_is_not_nullable_then_it_does_not_have_a_setter()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <MyRequiredTest>();
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
GenerateImmutableArrayProperties = true,
GenerateImmutableDictionaryProperties = true,
GenerateDefaultValues = false
});
//// Act
var code = generator.GenerateFile();
//// Assert
Assert.Contains("public System.Collections.ObjectModel.ObservableCollection<string> Collection { get; } = new System.Collections.ObjectModel.ObservableCollection<string>();", code);
Assert.Contains("public System.Collections.Generic.Dictionary<string, object> Dictionary { get; } = new System.Collections.Generic.Dictionary<string, object>();", code);
}
public void When_object_has_generic_name_then_it_is_transformed()
{
//// Arrange
var schema = new JsonSchema4();
schema.Type = JsonObjectType.Object;
schema.Properties["foo"] = new JsonProperty
{
Type = JsonObjectType.Number
};
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings {
ClassStyle = CSharpClassStyle.Poco
});
var code = generator.GenerateFile("Foo[Bar[Inner]]");
//// Assert
Assert.Contains("public partial class FooOfBarOfInner", code);
}
/// <summary>
/// Extracts Layout from InfoPath views, and writes the result to disk
/// </summary>
public async Task Generate()
{
var jsons = await GetJsonSchema();
foreach (var json in jsons)
{
var documentPathSplit = json.DocumentPath.Split('/');
var filename = documentPathSplit[documentPathSplit.Length - 1].Split('.').First();
// var folder = documentPathSplit[documentPathSplit.Length - 2];
var path = Path.Join("Models", "Altinn3", filename);
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var generator = new CSharpGenerator(null, GetSettings(filename));
var file = generator.GenerateFile(json, "test");
await File.WriteAllTextAsync(Path.Join(path, $"{filename}.cs"), file, System.Text.Encoding.UTF8);
}
}
private async Task <string> GenerateCSharpFileAsync(ConnectedServiceHandlerContext context, Instance instance)
{
var serviceFolder = instance.Name;
string jsonPath = instance.JSONPath;
var rootFolder = context.HandlerHelper.GetServiceArtifactsRootFolder();
var folderPath = context.ProjectHierarchy.GetProject().GetServiceFolderPath(rootFolder);
var text = File.ReadAllText(jsonPath);
var schema = NJsonSchema.JsonSchema.FromSampleJson(text);
var generator = new CSharpGenerator(schema);
var result = await System.Threading.Tasks.Task.FromResult(generator.GenerateFile());
var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(jsonPath);
var fileName = $"{fileNameWithoutExtension}.cs";
var generatedFullPath = Path.Combine(folderPath, fileName);
await context.HandlerHelper.AddFileAsync(generatedFullPath, fileName);
return(generatedFullPath);
}
public async Task When_class_with_discriminator_has_base_class_then_csharp_is_generated_correctly()
{
//// Arrange
var schema = JsonSchema.FromType <ExceptionContainer>();
var data = schema.ToJson();
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings {
ClassStyle = CSharpClassStyle.Poco
});
//// Act
var code = generator.GenerateFile();
//// Assert
Assert.Contains("Foobar.", data);
Assert.Contains("Foobar.", code);
Assert.Contains("class ExceptionBase : Exception", code);
Assert.Contains("class MyException : ExceptionBase", code);
}
public void When_name_contains_dash_then_it_is_converted_to_upper_case()
{
//// Arrange
var schema = new JsonSchema4();
schema.TypeNameRaw = "MyClass";
schema.Properties["foo-bar"] = new JsonProperty
{
Type = JsonObjectType.String
};
var generator = new CSharpGenerator(schema);
// Act
var output = generator.GenerateFile();
// Assert
Assert.IsTrue(output.Contains(@"[JsonProperty(""foo-bar"", "));
Assert.IsTrue(output.Contains(@"public string FooBar"));
}
public async Task When_type_is_array_and_items_and_item_is_not_defined_then_any_array_is_generated()
{
//// Arrange
var json = @"{
'properties': {
'emptySchema': { 'type': 'array' }
}
}";
var schema = await JsonSchema4.FromJsonAsync(json);
//// Act
var settings = new CSharpGeneratorSettings {
ClassStyle = CSharpClassStyle.Poco, Namespace = "ns",
};
var generator = new CSharpGenerator(schema, settings);
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("public System.Collections.ObjectModel.ObservableCollection<object> EmptySchema { get; set; } = ", output);
}
public async Task When_generating_from_json_schema_property_is_optional_and_GenerateNullableOptionalProperties_is_not_set_then_CSharp_property()
{
//// Arrange
// CSharpGenerator `new object()` adds = new object() initializer to property only if it's explicitly marked
// as having `type: object` in json schema
var schemaJson = @"
{
""type"": ""object"",
""required"": [
""property2""
],
""properties"": {
""Property"": {
""x-nullable"": true,
""type"": ""object""
},
""property2"": {
""type"": ""object""
}
}
}
";
var schema = await JsonSchema.FromJsonAsync(schemaJson);
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.OpenApi3,
GenerateNullableReferenceTypes = false
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("public object Property { get; set; }", code);
Assert.Contains("public object Property2 { get; set; } = new object();", code);
}
//This tests asserts that we can generate snippets from json objects with nested objects inside them.
public void RecursivelyGeneratesNestedPasswordProfileObjectFromJson()
{
//Arrange
LanguageExpressions expressions = new CSharpExpressions();
//json string with nested object properties
const string userJsonObject = "{\r\n \"accountEnabled\": true,\r\n " +
"\"displayName\": \"displayName-value\",\r\n " +
"\"mailNickname\": \"mailNickname-value\",\r\n " +
"\"userPrincipalName\": \"[email protected]\",\r\n " +
" \"passwordProfile\" : {\r\n \"forceChangePasswordNextSignIn\": true,\r\n \"password\": \"password-value\"\r\n }\r\n}";//nested passwordProfile Object
var requestPayload = new HttpRequestMessage(HttpMethod.Post, "https://graph.microsoft.com/v1.0/users")
{
Content = new StringContent(userJsonObject)
};
var snippetModel = new SnippetModel(requestPayload, ServiceRootUrl, _edmModel);
//Act by generating the code snippet
var result = CSharpGenerator.GenerateCodeSnippet(snippetModel, expressions);
//Assert code snippet string matches expectation
const string expectedSnippet = "var user = new User\r\n" +
"{\r\n" +
"\tAccountEnabled = true,\r\n" +
"\tDisplayName = \"displayName-value\",\r\n" +
"\tMailNickname = \"mailNickname-value\",\r\n" +
"\tUserPrincipalName = \"[email protected]\",\r\n" +
"\tPasswordProfile = new PasswordProfile\r\n" + //object with nested properties
"\t{\r\n" +
"\t\tForceChangePasswordNextSignIn = true,\r\n" + //nested object property
"\t\tPassword = \"password-value\"\r\n" + //nested object property
"\t}\r\n" +
"};\r\n\r\n" +
"await graphClient.Users\n" +
"\t.Request()\n" +
"\t.AddAsync(user);";
//Assert the snippet generated is as expected
Assert.Equal(AuthProviderPrefix + expectedSnippet, result);
}
public async Task When_property_is_required_then_required_attribute_is_rendered()
{
//// Arrange
var schema = JsonSchema.FromType <ClassWithRequiredObject>();
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.JsonSchema
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("[System.ComponentModel.DataAnnotations.Required]\n" +
" public string Property { get; set; }\n", code);
Assert.Contains("[System.ComponentModel.DataAnnotations.Required(AllowEmptyStrings = true)]\n" +
" public string Property2 { get; set; }\n", code);
}
public async Task When_property_has_not_supported_characters_then_they_are_removed()
{
//// Arrange
var schemaJson =
@"{
""type"": ""object"",
""properties"": {
""@odata.context"": { ""type"": ""string"" }
}
}";
var schema = await JsonSchema4.FromJsonAsync(schemaJson);
var settings = new CSharpGeneratorSettings();
var generator = new CSharpGenerator(schema, settings);
//// Act
var output = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("public string OdataContext", output);
}
public async Task When_record_no_setter_in_class_and_constructor_provided()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <Address>();
var data = schema.ToJson();
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Record
});
//// Act
var output = generator.GenerateFile("Address");
//// Assert
Assert.Contains(@"public string Street { get; }", output);
Assert.DoesNotContain(@"public string Street { get; set; }", output);
Assert.Contains("public Address(string street, string city)", output);
Assert.Contains("public Address(string street, string city)", output);
}
public async Task When_empty_class_inherits_from_dictionary_then_allOf_inheritance_still_works()
{
//// Arrange
var schema = await JsonSchema4.FromTypeAsync <MyContainer>();
var data = schema.ToJson();
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings());
//// Act
var code = generator.GenerateFile();
//// Assert
var dschema = schema.Definitions["EmptyClassInheritingDictionary"];
Assert.Equal(0, dschema.AllOf.Count);
Assert.True(dschema.IsDictionary);
Assert.Contains("public EmptyClassInheritingDictionary CustomDictionary", code);
Assert.Contains("public partial class EmptyClassInheritingDictionary : System.Collections.Generic.Dictionary<string, object>", code);
}
public void When_property_has_boolean_default_it_is_reflected_in_the_poco()
{
var data = @"{'properties': {
'boolWithDefault': {
'type': 'boolean',
'default': false
}
}}";
var schema = JsonSchema4.FromJson(data);
var settings = new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
Namespace = "ns",
GenerateDefaultValues = true
};
var gen = new CSharpGenerator(schema, settings);
var output = gen.GenerateFile();
Assert.IsTrue(output.Contains("public bool BoolWithDefault { get; set; } = false;"));
}
public void When_property_is_not_required_then_required_attribute_is_not_rendered_in_Swagger_mode()
{
//// Arrange
var schema = JsonSchema4.FromType <ClassWithoutRequiredObject>(new JsonSchemaGeneratorSettings
{
NullHandling = NullHandling.Swagger
});
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
NullHandling = NullHandling.Swagger
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsFalse(code.Contains("[Required]"));
Assert.IsTrue(code.Contains("public string Property { get; set; }"));
}
public void When_type_is_array_and_items_and_item_is_not_defined_then_any_array_is_generated()
{
//// Arrange
var json = @"{
'properties': {
'emptySchema': { 'type': 'array' }
}
}";
var schema = JsonSchema4.FromJson(json);
//// Act
var settings = new CSharpGeneratorSettings()
{
ClassStyle = CSharpClassStyle.Poco, Namespace = "ns",
};
var generator = new CSharpGenerator(schema, settings);
var output = generator.GenerateFile();
//// Assert
Assert.IsTrue(output.Contains("public ObservableCollection<object> EmptySchema { get; set; }"));
}
protected override bool Generate(JsonSchemaItem item, JsonSchemaItemMetadata metadata)
{
try
{
var outputFilePath = item.GetOutputFilePath(TargetLanguage);
var schema = JsonSchema4.FromFileAsync(item.SchemaFile).Result;
var settings = new CSharpGeneratorSettings
{
Namespace = metadata.Namespace,
};
var code = new CSharpGenerator(schema, settings).GenerateFile();
File.WriteAllText(outputFilePath, code);
return(true);
}
catch (Exception ex)
{
Logger.LogError(ex, item.SchemaFile);
return(false);
}
}
//This tests asserts that we can properly generate snippets for odata actions with parameters
public void GeneratesSnippetsForOdataActionsWithParameters()
{
//Arrange
LanguageExpressions expressions = new CSharpExpressions();
var requestPayload = new HttpRequestMessage(HttpMethod.Get,
"https://graph.microsoft.com/v1.0/me/drive/items/{id}/workbook/worksheets/{id|name}/range(address='A1:B2')");
var snippetModel = new SnippetModel(requestPayload, ServiceRootUrl, _edmModel);
//Act by generating the code snippet
var result = CSharpGenerator.GenerateCodeSnippet(snippetModel, expressions);
//Assert code snippet string matches expectation
const string expectedSnippet = "var workbookRange = await graphClient.Me.Drive.Items[\"{id}\"].Workbook.Worksheets[\"{id|name}\"]\n" +
"\t.Range(\"A1:B2\")\n" + //parameter has double quotes
"\t.Request()\n" +
"\t.GetAsync();";
//Assert the snippet generated is as expected
Assert.Equal(AuthProviderPrefix + expectedSnippet, result);
}
public async Task When_property_is_not_required_then_required_attribute_is_not_rendered_in_Swagger_mode()
{
//// Arrange
var schema = JsonSchema.FromType <ClassWithoutRequiredObject>(new JsonSchemaGeneratorSettings
{
SchemaType = SchemaType.Swagger2
});
var schemaData = schema.ToJson();
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.Swagger2
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.DoesNotContain("[Required]", code);
Assert.Contains("public object Property { get; set; }", code);
}
public void TestGenerateOutputOnEmptySpec()
{
// arrange
var spec =
new Spec
{
Targets = new Dictionary <string, TargetInfo>
{
{ Constants.CSharpTarget, new TargetInfo {
Path = "some_path", Namespace = "Blogged"
} }
}
};
var generator = new CSharpGenerator();
// act
var outputs = generator.GenerateOutputs(spec);
// assert
Assert.Equal(0, outputs.Count());
}
public void When_SourceTypeHasDifferentNamespace_Should_NotAddToUsings()
{
// Arrange
var source = GetSourceText(new SourceGeneratorOptions(SourceClassNamespace: "Bazaar"));
const string expectedResult = @"
// <auto-generated />
using MapTo;
using System;
namespace Test
{
";
// Act
var(compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source);
// Assert
diagnostics.ShouldBeSuccessful();
compilation.SyntaxTrees.Last().ToString().ShouldStartWith(expectedResult.Trim());
}
public void When_dictionary_property_is_required_or_not_then_the_code_has_correct_initializer()
{
//// Arrange
var schema = new JsonSchema4
{
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.Object,
AdditionalPropertiesSchema = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = true
} },
{ "B", new JsonProperty
{
Type = JsonObjectType.Object,
AdditionalPropertiesSchema = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = false
} },
}
};
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
NullHandling = NullHandling.Swagger
});
var code = generator.GenerateFile();
//// Assert
Assert.IsTrue(code.Contains("public Dictionary<string, string> A { get; set; } = new Dictionary<string, string>();"));
Assert.IsFalse(code.Contains("public Dictionary<string, string> B { get; set; } = new Dictionary<string, string>();"));
}
public void When_array_property_is_required_or_not_then_the_code_has_correct_initializer()
{
//// Arrange
var schema = new JsonSchema4
{
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.Array,
Item = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = true
} },
{ "B", new JsonProperty
{
Type = JsonObjectType.Array,
Item = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = false
} },
}
};
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.Swagger2
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.IsTrue(code.Contains("public System.Collections.ObjectModel.ObservableCollection<string> A { get; set; } = new System.Collections.ObjectModel.ObservableCollection<string>();"));
Assert.IsFalse(code.Contains("public System.Collections.ObjectModel.ObservableCollection<string> B { get; set; } = new System.Collections.ObjectModel.ObservableCollection<string>();"));
}
public void When_dictionary_property_is_required_or_not_then_the_code_has_correct_initializer()
{
//// Arrange
var schema = new JsonSchema4
{
Properties =
{
{ "A", new JsonProperty
{
Type = JsonObjectType.Object,
AdditionalPropertiesSchema = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = true
} },
{ "B", new JsonProperty
{
Type = JsonObjectType.Object,
AdditionalPropertiesSchema = new JsonSchema4
{
Type = JsonObjectType.String
},
IsRequired = false
} },
}
};
//// Act
var generator = new CSharpGenerator(schema, new CSharpGeneratorSettings
{
ClassStyle = CSharpClassStyle.Poco,
SchemaType = SchemaType.Swagger2
});
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("public System.Collections.Generic.Dictionary<string, string> A { get; set; } = new System.Collections.Generic.Dictionary<string, string>();", code);
Assert.DoesNotContain("public System.Collections.Generic.Dictionary<string, string> B { get; set; } = new System.Collections.Generic.Dictionary<string, string>();", code);
}
public void When_MapPropertyFound_Should_UseItToMapToSourceProperty()
{
// Arrange
var source = GetSourceText(new SourceGeneratorOptions(
true,
PropertyBuilder: builder =>
{
builder
.WriteLine("[MapProperty(SourcePropertyName = nameof(Baz.Prop3))]")
.WriteLine("public int Prop4 { get; set; }");
},
SourcePropertyBuilder: builder => builder.WriteLine("public int Prop4 { get; set; }")));
var expectedResult = @"
partial class Foo
{
public Foo(Test.Models.Baz baz)
: this(new MappingContext(), baz) { }
private protected Foo(MappingContext context, Test.Models.Baz baz)
{
if (context == null) throw new ArgumentNullException(nameof(context));
if (baz == null) throw new ArgumentNullException(nameof(baz));
context.Register(baz, this);
Prop1 = baz.Prop1;
Prop2 = baz.Prop2;
Prop3 = baz.Prop3;
Prop4 = baz.Prop3;
}
".Trim();
// Act
var(compilation, diagnostics) = CSharpGenerator.GetOutputCompilation(source, analyzerConfigOptions: DefaultAnalyzerOptions);
// Assert
diagnostics.ShouldBeSuccessful();
compilation.SyntaxTrees.Last().ShouldContainPartialSource(expectedResult);
}
public async Task When_enum_has_no_names_and_string_value_starts_with_number_then_underline_is_generated()
{
//// Arrange
var schemaData = @"{
""type"": ""object"",
""properties"": {
""Bar"": {
""oneOf"": [
{
""$ref"": ""#/definitions/StringEnum""
}
]
}
},
""definitions"": {
""StringEnum"": {
""type"": ""string"",
""enum"": [
""0562"",
""\""0532\"""",
""a\\b\\c""
],
""description"": """"
}
}
}";
var schema = await JsonSchema.FromJsonAsync(schemaData);
//// Act
var generator = new CSharpGenerator(schema);
var code = generator.GenerateFile("MyClass");
//// Assert
Assert.Contains("[System.Runtime.Serialization.EnumMember(Value = @\"0562\")]", code);
Assert.Contains("_0562 = 0,", code);
Assert.Contains("[System.Runtime.Serialization.EnumMember(Value = @\"\"\"0532\"\"\")]", code);
Assert.Contains("_0532 = 1,", code);
Assert.Contains("[System.Runtime.Serialization.EnumMember(Value = @\"a\\b\\c\")]", code);
Assert.Contains("A_b_c = 2,", code);
}
public void Can_write_ValidateRequestAttribute()
{
var nativeTypes = appHost.AssertPlugin <NativeTypesFeature>();
var gen = nativeTypes.DefaultGenerator;
var attr = new ValidateRequestAttribute("HasRole('Accounts')")
{
ErrorCode = "ExCode",
Message = "'Id' Is Required",
};
var metaAttr = gen.ToAttribute(attr);
string argValue(string name) => metaAttr.Args.First(x => x.Name == name).Value;
Assert.That(metaAttr.Name, Is.EqualTo("ValidateRequest"));
Assert.That(metaAttr.Args.Count, Is.EqualTo(3));
Assert.That(argValue(nameof(ValidateRequestAttribute.Validator)), Is.EqualTo("HasRole('Accounts')"));
Assert.That(argValue(nameof(ValidateRequestAttribute.ErrorCode)), Is.EqualTo("ExCode"));
Assert.That(argValue(nameof(ValidateRequestAttribute.Message)), Is.EqualTo("'Id' Is Required"));
var csharp = new CSharpGenerator(new MetadataTypesConfig {
DefaultNamespaces = new List <string> {
"ServiceStack"
}
});
var src = csharp.GetCode(new MetadataTypes {
Types = new List <MetadataType> {
new MetadataType {
Name = "TheType",
Attributes = new List <MetadataAttribute> {
metaAttr,
}
}
}
}, new BasicRequest(), appHost.TryResolve <INativeTypesMetadata>());
src.Print();
Assert.That(src, Does.Contain(
"[ValidateRequest(\"HasRole('Accounts')\", ErrorCode=\"ExCode\", Message=\"'Id' Is Required\")]"));
}
private void processClientCode(NameValueCollection queryString, HttpContext context)
{
IProxyGenerator generator = null;
ResourceManager resMan = new ResourceManager();
string platform = queryString["platform"];
if (string.IsNullOrEmpty(platform))
{
context.Response.ContentType = "text/plain";
context.Response.Write("No Platform is Specified");
return;
}
platform = platform.ToLower();
if (platform == "csharp")
{
TypeMap tm = resMan.GetTypeMap("dotnet-csharp.typemap");
generator = new CSharpGenerator(tm);
}
else if (platform == "java")
{
TypeMap tm = resMan.GetTypeMap("dotnet-java.typemap");
generator = new JavaGenerator(tm);
}
else if (platform == "js-angularjs")
{
generator = new AngularGenerator();
}
else if (platform == "js-dojo")
{
generator = new JavaScriptGenerator();
}
else if (platform == "js-dojo-amd")
{
generator = new JavaScriptDojoAMDGenerator();
}
else if (platform == "flex")
{
generator = new FlexGenerator();
}
else if (platform == "objc")
{
TypeMap tm = resMan.GetTypeMap("dotnet-objc.typemap");
generator = new ObjectiveCGenerator(tm);
}
if (generator == null)
{
context.Response.ContentType = "text/plain";
context.Response.Write("Unknown Platform");
return;
}
string format = queryString["format"];
format = format == null ? "zip" : format.ToLower();
Service svc = createService();
IDictionary<string, string> files = generator.Generate(svc);
if (format == "zip")
{
byte[] buffer = ZipExporter.Export(files);
MemoryStream ms = new MemoryStream(buffer);
//context.Response.ContentType = "application/zip";
context.Response.ContentType = "application/octet-stream";
string fileName = string.Format("{0}_{1}.zip", svc.Name, platform);
context.Response.AddHeader("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
ms.CopyTo(context.Response.OutputStream);
context.Response.OutputStream.Close();
}
else if (format == "json")
{
string s = JsonConvert.SerializeObject(files);
context.Response.ContentType = "text/json";
context.Response.Write(s);
}
else if (format == "xml")
{
}
}
private static MainFunctions Compile(string codePath, TextWriter output)
{
var stream = new AntlrFileStream(codePath);
var lexer = new AdamantLexer(stream);
var tokens = new CommonTokenStream(lexer);
var parser = new AdamantParser(tokens) { BuildParseTree = true };
var tree = parser.compilationUnit();
var syntaxCheck = new SyntaxCheckVisitor();
tree.Accept(syntaxCheck);
//var buildAst = new BuildAstVisitor();
//var ast = (Assemblage)tree.Accept(buildAst);
//var borrowChecker = new BorrowChecker();
//borrowChecker.Check(ast);
var cSharpGenerator = new CSharpGenerator(output);
return tree.Accept(cSharpGenerator);
}
private void CodeForm_Load(object sender, EventArgs e)
{
// Restore position from registry.
RegistryKey twbstStudioRegKey = Registry.CurrentUser.OpenSubKey("Software\\Codecentrix\\OpenTwebst\\Studio");
// If Twebst Studio registry key does not exist then create it.
if (twbstStudioRegKey == null)
{
twbstStudioRegKey = Registry.CurrentUser.CreateSubKey("Software\\Codecentrix\\OpenTwebst\\Studio");
}
if (twbstStudioRegKey != null)
{
int top = (int)twbstStudioRegKey.GetValue("codex", -1);
int left = (int)twbstStudioRegKey.GetValue("codey", -1);
int height = (int)twbstStudioRegKey.GetValue("codeh", -1);
int width = (int)twbstStudioRegKey.GetValue("codew", -1);
if ((top != -1) && (left != -1) && (height != -1) && (width != -1) &&
IsValidFormPosAndSize(top, left, height, width))
{
this.Top = top;
this.Left = left;
this.Height = height;
this.Width = width;
}
else
{
this.GoDefaultPosAndSize();
}
twbstStudioRegKey.Close();
}
else
{
this.GoDefaultPosAndSize();
}
// Create target language objects.
BaseLanguageGenerator vbsLang = new VbsGenerator();
BaseLanguageGenerator jsLang = new JsGenerator();
BaseLanguageGenerator pythonLang = new PyGenerator();
BaseLanguageGenerator watirEnv = new WatirGenerator();
BaseLanguageGenerator csLang = new CSharpGenerator();
BaseLanguageGenerator vbNetLang = new VbNetGenerator();
BaseLanguageGenerator vbaLang = new VbaGenerator();
// Populate language combo-box.
this.codeToolStripLanguageCombo.Items.Add(vbsLang);
this.codeToolStripLanguageCombo.Items.Add(jsLang);
this.codeToolStripLanguageCombo.Items.Add(vbaLang);
this.codeToolStripLanguageCombo.Items.Add(csLang);
this.codeToolStripLanguageCombo.Items.Add(vbNetLang);
this.codeToolStripLanguageCombo.Items.Add(pythonLang);
this.codeToolStripLanguageCombo.Items.Add(watirEnv);
// Initialize code generator.
this.codeGen = new CodeGenerator(vbsLang);
this.codeGen.NewStatement += OnNewStatement;
this.codeGen.CodeChanged += OnLanguageChanged;
// Select a language in the combo-box.
int defaultLanguage = GetRecorderSavedLanguage();
if ((defaultLanguage < 0) || (defaultLanguage >= this.codeToolStripLanguageCombo.Items.Count))
{
defaultLanguage = 0;
}
this.codeToolStripLanguageCombo.SelectedIndex = defaultLanguage;
this.codeToolStrip.ClickThrough = true;
this.toolStripStatusProductLabel.Text = CoreWrapper.Instance.productName + " " + CoreWrapper.Instance.productVersion;
}
