public void TestJsonToJsonSchema()
{
string json = JsonWriter.GetWriter().Write(new MyUserModel.UserContact()
{
phoneNumbers = new int[1] {
123
},
user = new MyUserModel()
{
name = "Tom",
age = 99,
phoneNumber = 12345
}
});
Log.d("json=" + json);
var schemaGenerator = new ModelToJsonSchema();
var schema = schemaGenerator.ToJsonSchema("MyUserModel", json);
Log.d(JsonWriter.AsPrettyString(schema));
Assert.Equal("Age", schema.properties["user"].properties["age"].title);
Assert.Equal("integer", schema.properties["phoneNumbers"].items.First().type);
}
private static async Task LoadJsonModelIntoGeneratedJsonSchemaView(
ViewStack viewStack, ModelToJsonSchema schemaGenerator, JsonSchema schema, string jsonModel)
{
JObject model = JsonReader.GetReader().Read <JObject>(jsonModel);
JsonSchemaToView viewGenerator = new JsonSchemaToView(schemaGenerator);
GameObject generatedView = await viewGenerator.ToView(schema);
viewStack.ShowView(generatedView);
var presenter = new JsonSchemaPresenter(viewGenerator);
presenter.targetView = generatedView;
Log.d("Model BEFORE changes: " + model.ToPrettyString());
var changedModel = await presenter.LoadModelIntoView(model.DeepClone() as JObject);
await JsonSchemaPresenter.ChangesSavedViaConfirmButton(generatedView);
Log.d("Model AFTER changes: " + changedModel.ToPrettyString());
viewStack.SwitchBackToLastView(generatedView);
var changedFields = MergeJson.GetDiff(model, changedModel);
Log.d("Fields changed: " + changedFields?.ToPrettyString());
}
private static async Task GenerateAndShowViewFor(ViewStack viewStack)
{
{
await Dialog.ShowInfoDialog("Generating UIs from C# classes", "The next examples will show generating" +
" views from normal C# classes. In this example MyUserModel is passed to the generator", "Show example");
var schemaGenerator = new ModelToJsonSchema();
var userModelType = typeof(MyUserModel);
JsonSchema schema = schemaGenerator.ToJsonSchema("" + userModelType, userModelType);
Log.d(JsonWriter.AsPrettyString(schema));
await LoadModelIntoGeneratedView(viewStack, schemaGenerator, schema);
}
{
await Dialog.ShowInfoDialog("Generating UIs from JSON schemas",
"This time the json schema is loaded from an JSON schema string", "Show example");
var schemaGenerator = new ModelToJsonSchema();
JsonSchema schema = JsonReader.GetReader().Read <JsonSchema>(SomeJsonSchemaExamples.jsonSchema1);
await LoadJsonModelIntoGeneratedJsonSchemaView(viewStack, schemaGenerator, schema, SomeJsonSchemaExamples.json1);
}
{
await Dialog.ShowInfoDialog("Editing arrays & lists:",
"Both primitave lists but also List<MyClass1> can be shown and edited", "Show list example");
var schemaGenerator = new ModelToJsonSchema();
JsonSchema schema = JsonReader.GetReader().Read <JsonSchema>(SomeJsonSchemaExamples.jsonSchema2);
await LoadJsonModelIntoGeneratedJsonSchemaView(viewStack, schemaGenerator, schema, SomeJsonSchemaExamples.json2);
}
}
public void TestRecursiveModel()
{
var exampleUserContact1 = new MyUserModel.UserContact()
{
user = new MyUserModel()
{
bestFriend = new MyUserModel.UserContact()
}
};
var schemaGenerator = new ModelToJsonSchema();
JsonSchema schema = schemaGenerator.ToJsonSchema("UserContact", exampleUserContact1);
var bestFriendSchema = schema.properties["user"].properties["bestFriend"];
Assert.Equal("" + typeof(MyUserModel.UserContact), bestFriendSchema.modelType);
}
public void TestNullObjectResolved()
{
{
var user = new MyUserModel.UserContact();
var schemaGenerator = new ModelToJsonSchema();
JsonSchema schema = schemaGenerator.ToJsonSchema("UserContact", user);
Assert.Null(user.user); // The model field is null
Assert.NotEmpty(schema.properties["user"].properties); // The schema info is still defined
}
{
var schemaGenerator = new ModelToJsonSchema();
var schema = schemaGenerator.ToJsonSchema("UserContact", typeof(MyUserModel.UserContact));
Assert.NotEmpty(schema.properties["user"].properties); // The schema info is still defined
}
}
public void TestEnum()
{
var schema = new ModelToJsonSchema().ToJsonSchema("FromClassType", typeof(UserStats));
var e1 = schema.properties["experience1"];
var e2 = schema.properties["experience2"];
var e3 = schema.properties["experience3"];
var e4 = schema.properties["experience4"];
var e5 = schema.properties["experience5"];
Log.d(JsonWriter.AsPrettyString(schema));
Assert.Equal(Enum.GetNames(typeof(UserStats.Experience)), e1.contentEnum);
Assert.Equal(e1.contentEnum, e2.contentEnum);
Assert.Equal(e2.contentEnum, e3.contentEnum);
Assert.Equal(e3.contentEnum, e4.contentEnum);
Assert.Equal(e4.contentEnum, e5.contentEnum);
}
private static async Task LoadModelIntoGeneratedView(ViewStack viewStack, ModelToJsonSchema schemaGenerator, JsonSchema schema)
{
MyUserModel model = NewExampleUserInstance();
{
await Dialog.ShowInfoDialog("Manually connecting the model instance to the view", "First an example to connect the " +
"model to a generated view via a manual presenter 'MyManualPresenter1'", "Show manual presenter example");
var viewGenerator = new JsonSchemaToView(schemaGenerator);
GameObject generatedView = await viewGenerator.ToView(schema);
viewStack.ShowView(generatedView);
var presenter = new MyManualPresenter1();
presenter.targetView = generatedView;
Log.d("Model BEFORE changes: " + JsonWriter.AsPrettyString(model));
await presenter.LoadModelIntoView(model);
viewStack.SwitchBackToLastView(generatedView);
Log.d("Model AFTER changes: " + JsonWriter.AsPrettyString(model));
}
{
await Dialog.ShowInfoDialog("Using JsonSchemaPresenter to autmatically connect the model instance and view",
"The second option is to use a generic JObjectPresenter to connect the model to the generated view",
"Show JsonSchemaPresenter example");
var viewGenerator = new JsonSchemaToView(schemaGenerator);
GameObject generatedView = await viewGenerator.ToView(schema);
viewStack.ShowView(generatedView);
var presenter = new JsonSchemaPresenter(viewGenerator);
presenter.targetView = generatedView;
Log.d("Model BEFORE changes: " + JsonWriter.AsPrettyString(model));
MyUserModel changedModel = await presenter.LoadViaJsonIntoView(model);
viewStack.SwitchBackToLastView(generatedView);
Log.d("Model AFTER changes: " + JsonWriter.AsPrettyString(changedModel));
var changedFields = MergeJson.GetDiff(model, changedModel);
Log.d("Fields changed: " + changedFields?.ToPrettyString());
}
}
public void TestNullable()
{
var user = new MyUserModel()
{
phoneNumber = 12345
};
string json = JsonWriter.GetWriter().Write(user);
JsonSchema schema1 = new ModelToJsonSchema().ToJsonSchema("FromClassInstance", user);
JsonSchema schema2 = new ModelToJsonSchema().ToJsonSchema("FromJson", json);
JsonSchema schema3 = new ModelToJsonSchema().ToJsonSchema("FromClassType", typeof(MyUserModel));
var phoneNumber1 = schema1.properties["phoneNumber"];
var phoneNumber2 = schema2.properties["phoneNumber"];
var phoneNumber3 = schema3.properties["phoneNumber"];
Assert.Equal(phoneNumber1.type, phoneNumber2.type);
Assert.Equal(phoneNumber2.type, phoneNumber3.type);
Assert.Equal(phoneNumber1.title, phoneNumber2.title);
Assert.Equal(phoneNumber2.title, phoneNumber3.title);
}
public void ExampleUsage1()
{
// A normal user model with a few example fields that users typically have:
var user1 = new MyUserModel("" + GuidV2.NewGuid())
{
name = "Tom",
password = "******",
age = 50,
profilePic = new FileRef()
{
url = "https://picsum.photos/128/128"
},
tags = new List <string>()
{
"tag1"
}
};
var schemaGenerator = new ModelToJsonSchema();
JsonSchema schema = schemaGenerator.ToJsonSchema("MyUserModel", user1);
Log.d("schema: " + JsonWriter.AsPrettyString(schema));
var profilePicVm = schema.properties["profilePic"];
Assert.Equal("string", profilePicVm.properties["dir"].type);
Assert.Equal("string", profilePicVm.properties["url"].type);
Assert.Contains("id", schema.required);
Assert.Contains("name", schema.required);
Assert.Equal(2, schema.required.Count);
Assert.Equal("array", schema.properties["tags"].type);
Assert.Equal("string", schema.properties["tags"].items.First().type);
Assert.Null(schema.properties["tags"].items.First().properties);
Assert.Equal("array", schema.properties["contacts"].type);
Assert.True(schema.properties["id"].readOnly.Value); // id has private setter
Assert.True(schema.properties["contacts"].readOnly.Value); // contacts has only a getter
Assert.Equal(2, schema.properties["name"].minLength);
Assert.Equal(30, schema.properties["name"].maxLength);
Assert.Equal("object", schema.properties["contacts"].items.First().type);
// Contacts schema already resolve as part of the bestFried field, so here no properties are included:
Assert.Null(schema.properties["contacts"].items.First().properties);
var entrySchema = schema.properties["contacts"].items.First();
Assert.Equal("" + typeof(MyUserModel.UserContact), entrySchema.modelType);
Assert.Null(entrySchema.properties);
Assert.Equal("" + typeof(MyUserModel.UserContact), schema.properties["bestFriend"].modelType);
Assert.Equal("" + ContentFormat.password, schema.properties["password"].format);
var userSchemaInUserContactClass = schema.properties["bestFriend"].properties["user"];
Assert.Equal("" + typeof(MyUserModel), userSchemaInUserContactClass.modelType);
// The other fields of this json schema are null since it was already defined:
Assert.Null(userSchemaInUserContactClass.properties);
Assert.Equal(0, schema.properties["age"].minimum);
Assert.Equal(130, schema.properties["age"].maximum);
}
/// <summary> Creates a generator instance that can generate views from view models vie JsonSchemaToView.ToView(..) </summary>
public JsonSchemaToView(ModelToJsonSchema schemaGenerator) : base(schemaGenerator)
{
}
