/// <summary>
/// Writes the messages section of a protocol definition
/// </summary>
/// <param name="writer">writer</param>
/// <param name="names">list of names written</param>
/// <param name="encspace">enclosing namespace</param>
internal void writeJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names, string encspace)
{
writer.WriteStartObject();
JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);
if (null != this.Request)
this.Request.WriteJsonFields(writer, names, null);
if (null != this.Response)
{
writer.WritePropertyName("response");
Response.WriteJson(writer, names, encspace);
}
if (null != this.Error)
{
writer.WritePropertyName("errors");
this.Error.WriteJson(writer, names, encspace);
}
if (null != Oneway)
{
writer.WritePropertyName("one-way");
writer.WriteValue(Oneway);
}
writer.WriteEndObject();
}
public virtual EnsureSchemaStatus TryEnsureSchema(Type type, bool force, out Exception ex, ILogger logger = null)
{
EnsureSchemaStatus result = EnsureSchemaStatus.Invalid;
ex = null;
try
{
string schemaName = Dao.RealConnectionName(type);
if (!SchemaNames.Contains(schemaName) || force)
{
_schemaNames.Add(schemaName);
SchemaWriter schema = ServiceProvider.Get <SchemaWriter>();
schema.WriteSchemaScript(type);
ExecuteSql(schema, ServiceProvider.Get <IParameterBuilder>());
result = EnsureSchemaStatus.Success;
}
else
{
result = EnsureSchemaStatus.AlreadyDone;
}
}
catch (Exception e)
{
ex = e;
result = EnsureSchemaStatus.Error;
logger = logger ?? Log.Default;
logger.AddEntry("Non fatal error occurred trying to write schema for type {0}: {1}", LogEventType.Warning, ex, type.Name, ex.Message);
}
return(result);
}
public static Schema Create(
DocumentNode schemaDocument,
Action <ISchemaConfiguration> configure,
bool strict,
IServiceProvider services)
{
if (schemaDocument == null)
{
throw new ArgumentNullException(nameof(schemaDocument));
}
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
if (services == null)
{
throw new ArgumentNullException(nameof(services));
}
SchemaContext context = CreateSchemaContext();
// deserialize schema objects
SchemaSyntaxVisitor visitor = new SchemaSyntaxVisitor(context.Types);
visitor.Visit(schemaDocument);
SchemaNames names = new SchemaNames(
visitor.QueryTypeName,
visitor.MutationTypeName,
visitor.SubscriptionTypeName);
return(CreateSchema(services, context, names, configure, strict));
}
/// <summary>
/// Parses the messages section of a protocol definition
/// </summary>
/// <param name="jmessage">messages JSON object</param>
/// <param name="names">list of parsed names</param>
/// <param name="encspace">enclosing namespace</param>
/// <returns></returns>
internal static Message Parse(JProperty jmessage, SchemaNames names, string encspace)
{
string name = jmessage.Name;
string doc = JsonHelper.GetOptionalString(jmessage.Value, "doc");
bool? oneway = JsonHelper.GetOptionalBoolean(jmessage.Value, "one-way");
PropertyMap props = Schema.GetProperties(jmessage.Value);
RecordSchema schema = RecordSchema.NewInstance(Schema.Type.Record, jmessage.Value as JObject, props, names, encspace);
JToken jresponse = jmessage.Value["response"];
var response = Schema.ParseJson(jresponse, names, encspace);
JToken jerrors = jmessage.Value["errors"];
UnionSchema uerrorSchema = null;
if (null != jerrors)
{
Schema errorSchema = Schema.ParseJson(jerrors, names, encspace);
if (!(errorSchema is UnionSchema))
throw new AvroException("");
uerrorSchema = errorSchema as UnionSchema;
}
return new Message(name, doc, schema, response, uerrorSchema, oneway);
}
/// <summary>
/// Generate list of named schemas from given schema
/// </summary>
/// <param name="schema">schema to process</param>
/// <returns></returns>
protected virtual SchemaNames generateNames(Schema schema)
{
var names = new SchemaNames();
addName(schema, names);
return(names);
}
/// <summary>
/// Generates code for the protocol objects
/// </summary>
protected virtual void processProtocols()
{
foreach (Protocol protocol in Protocols)
{
SchemaNames names = generateNames(protocol);
foreach (KeyValuePair <SchemaName, NamedSchema> sn in names)
{
switch (sn.Value.Tag)
{
case Schema.Type.Enumeration: processEnum(sn.Value); break;
case Schema.Type.Fixed: processFixed(sn.Value); break;
case Schema.Type.Record: processRecord(sn.Value); break;
case Schema.Type.Error: processRecord(sn.Value); break;
default:
throw new CodeGenException("Names in protocol should only be of type NamedSchema, type found " + sn.Value.Tag);
}
}
processInterface(protocol);
}
}
/// <summary>
/// Writes Protocol in JSON format
/// </summary>
/// <param name="writer">JSON writer</param>
/// <param name="names">list of named schemas already written</param>
internal void WriteJson(Newtonsoft.Json.JsonTextWriter writer, SchemaNames names)
{
writer.WriteStartObject();
JsonHelper.writeIfNotNullOrEmpty(writer, "protocol", this.Name);
JsonHelper.writeIfNotNullOrEmpty(writer, "namespace", this.Namespace);
JsonHelper.writeIfNotNullOrEmpty(writer, "doc", this.Doc);
writer.WritePropertyName("types");
writer.WriteStartArray();
foreach (Schema type in this.Types)
{
type.WriteJson(writer, names, this.Namespace);
}
writer.WriteEndArray();
writer.WritePropertyName("messages");
writer.WriteStartObject();
foreach (KeyValuePair <string, Message> message in this.Messages)
{
writer.WritePropertyName(message.Key);
message.Value.writeJson(writer, names, this.Namespace);
}
writer.WriteEndObject();
writer.WriteEndObject();
}
/// <summary>
/// Parses the given JSON object to create a Protocol object
/// </summary>
/// <param name="jtok">JSON object</param>
/// <returns>Protocol object</returns>
private static Protocol Parse(JToken jtok)
{
string name = JsonHelper.GetRequiredString(jtok, "protocol");
string space = JsonHelper.GetOptionalString(jtok, "namespace");
string doc = JsonHelper.GetOptionalString(jtok, "doc");
var names = new SchemaNames();
JToken jtypes = jtok["types"];
var types = new List <Schema>();
if (jtypes is JArray)
{
foreach (JToken jtype in jtypes)
{
var schema = Schema.ParseJson(jtype, names, space);
types.Add(schema);
}
}
var messages = new Dictionary <string, Message>();
JToken jmessages = jtok["messages"];
if (null != jmessages)
{
foreach (JProperty jmessage in jmessages)
{
var message = Message.Parse(jmessage, names, space);
messages.Add(message.Name, message);
}
}
return(new Protocol(name, space, doc, types, messages));
}
public static SchemaTypes Create(
IEnumerable <INamedType> types,
IEnumerable <ITypeBinding> typeBindings,
SchemaNames names)
{
if (types == null)
{
throw new ArgumentNullException(nameof(types));
}
if (typeBindings == null)
{
throw new ArgumentNullException(nameof(typeBindings));
}
SchemaNames n = string.IsNullOrEmpty(names.QueryTypeName)
? new SchemaNames(null, null, null)
: names;
return(new SchemaTypes(types,
typeBindings,
n.QueryTypeName,
n.MutationTypeName,
n.SubscriptionTypeName));
}
/// <summary>
/// Generate list of named schemas from given protocol
/// </summary>
/// <param name="protocol">protocol to process</param>
/// <returns></returns>
protected virtual SchemaNames generateNames(Protocol protocol)
{
var names = new SchemaNames();
foreach (Schema schema in protocol.Types)
{
addName(schema, names);
}
return(names);
}
/// <summary>
/// Generates code for the schema objects
/// </summary>
protected virtual void processSchemas()
{
foreach (Schema schema in this.Schemas)
{
SchemaNames names = generateNames(schema);
foreach (KeyValuePair <SchemaName, NamedSchema> sn in names)
{
switch (sn.Value.Tag)
{
case Schema.Type.Enumeration: processEnum(sn.Value); break;
case Schema.Type.Fixed: processFixed(sn.Value); break;
case Schema.Type.Record: processRecord(sn.Value); break;
case Schema.Type.Error: processRecord(sn.Value); break;
default:
throw new CodeGenException("Names in schema should only be of type NamedSchema, type found " + sn.Value.Tag);
}
}
}
}
private void GenerateSchemas(IEnumerable <Record> results, string outDir)
{
var codegen = new Avro.CodeGen();
var schemaNames = new SchemaNames();
foreach (var result in results)
{
Console.WriteLine("Start processing : {0}", result.Fullname);
var scheme = Schema.Parse(result.Schema, schemaNames);
schemaNames.Add((NamedSchema)scheme);
codegen.AddSchema(scheme);
Console.WriteLine("Generate : {0}", result.Fullname);
}
codegen.GenerateCode();
codegen.WriteTypes(outDir);
Console.WriteLine("Completed.");
}
/// <summary>
/// Recursively search the given schema for named schemas and adds them to the given container
/// </summary>
/// <param name="schema">schema object to search</param>
/// <param name="names">list of named schemas</param>
protected virtual void addName(Schema schema, SchemaNames names)
{
NamedSchema ns = schema as NamedSchema;
if (null != ns)
{
if (names.Contains(ns.SchemaName))
{
return;
}
}
switch (schema.Tag)
{
case Schema.Type.Null:
case Schema.Type.Boolean:
case Schema.Type.Int:
case Schema.Type.Long:
case Schema.Type.Float:
case Schema.Type.Double:
case Schema.Type.Bytes:
case Schema.Type.String:
break;
case Schema.Type.Enumeration:
case Schema.Type.Fixed:
names.Add(ns);
break;
case Schema.Type.Record:
case Schema.Type.Error:
var rs = schema as RecordSchema;
names.Add(rs);
foreach (Field field in rs.Fields)
{
addName(field.Schema, names);
}
break;
case Schema.Type.Array:
var asc = schema as ArraySchema;
addName(asc.ItemSchema, names);
break;
case Schema.Type.Map:
var ms = schema as MapSchema;
addName(ms.ValueSchema, names);
break;
case Schema.Type.Union:
var us = schema as UnionSchema;
foreach (Schema usc in us.Schemas)
{
addName(usc, names);
}
break;
default:
throw new CodeGenException("Unable to add name for " + schema.Name + " type " + schema.Tag);
}
}
private static Schema CreateSchema(
IServiceProvider services,
SchemaContext context,
SchemaNames names,
Action <ISchemaConfiguration> configure,
bool strict)
{
List <SchemaError> errors = new List <SchemaError>();
// setup introspection fields
IntrospectionFields introspectionFields =
new IntrospectionFields(context, e => errors.Add(e));
SchemaNames internalNames = names;
try
{
// configure resolvers, custom types and type mappings.
SchemaConfiguration configuration = new SchemaConfiguration(services);
configure(configuration);
errors.AddRange(configuration.RegisterTypes(context));
configuration.RegisterResolvers(context);
errors.AddRange(context.CompleteTypes());
string queryTypeName = configuration.QueryTypeName ?? names.QueryTypeName;
string mutationTypeName = configuration.MutationTypeName ?? names.MutationTypeName;
string subscriptionTypeName = configuration.SubscriptionTypeName ?? names.SubscriptionTypeName;
internalNames = new SchemaNames(queryTypeName, mutationTypeName, subscriptionTypeName);
}
catch (ArgumentException ex)
{
// TODO : maybe we should throw a more specific
// argument exception that at least contains the config object.
throw new SchemaException(new[]
{
new SchemaError(ex.Message, null)
});
}
if (strict && errors.Any())
{
throw new SchemaException(errors);
}
internalNames = string.IsNullOrEmpty(names.QueryTypeName)
? new SchemaNames(null, null, null)
: names;
if (strict && !context.Types.TryGetType <ObjectType>(
internalNames.QueryTypeName, out ObjectType ot))
{
throw new SchemaException(new SchemaError(
"Schema is missing the mandatory `Query` type."));
}
return(new Schema(
services,
SchemaTypes.Create(
context.Types.GetTypes(),
context.Types.GetTypeBindings(),
internalNames),
introspectionFields));
}
protected RepositoryBase(T context, string schemaName = null)
{
Context = context ?? throw new ArgumentNullException(nameof(context));
_schemaName = schemaName ?? throw new ArgumentNullException(nameof(schemaName));
_fullSchemaName = SchemaNames.SchemaWithTable(schemaName) ?? "";
}
