private SwaggerParameter CreatePrimitiveParameter(string name, string description, Type type, IList <Attribute> parentAttributes,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var typeDescription = JsonObjectTypeDescription.FromType(type, parentAttributes, Settings.DefaultEnumHandling);
var parameterType = typeDescription.Type.HasFlag(JsonObjectType.Object) ? typeof(string) : type; // object types must be treated as string
var operationParameter = _schemaGenerator.Generate <SwaggerParameter>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender);
if (parameterType.GetTypeInfo().IsEnum)
{
operationParameter.SchemaReference = _schemaGenerator.Generate <JsonSchema4>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender);
}
else
{
_schemaGenerator.ApplyPropertyAnnotations(operationParameter, type, parentAttributes, typeDescription);
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
private void LoadDefaultReturnType(SwaggerOperation operation, MethodInfo method, string xmlDescription,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var returnType = method.ReturnType;
if (returnType == typeof(Task))
{
returnType = typeof(void);
}
else if (returnType.Name == "Task`1")
{
returnType = returnType.GenericTypeArguments[0];
}
if (IsVoidResponse(returnType))
{
operation.Responses["204"] = new SwaggerResponse
{
Description = xmlDescription ?? string.Empty,
};
}
else
{
var typeDescription = JsonObjectTypeDescription.FromType(returnType,
method.ReturnParameter?.GetCustomAttributes(), Settings.DefaultEnumHandling);
operation.Responses["200"] = new SwaggerResponse
{
Description = xmlDescription ?? string.Empty,
IsNullableRaw = typeDescription.IsNullable,
Schema = CreateAndAddSchema(returnType, typeDescription.IsNullable, null, schemaResolver, schemaDefinitionAppender)
};
}
}
private SwaggerParameter CreatePrimitiveParameter(string name, string description, Type type, IList <Attribute> parentAttributes,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var typeDescription = JsonObjectTypeDescription.FromType(type, parentAttributes, Settings.DefaultEnumHandling);
SwaggerParameter operationParameter;
if (typeDescription.IsEnum)
{
// TODO(incompatibility): We use "schema" even it is not allowed in non-body parameters
var parameterType = type.Name == "Nullable`1" ? type.GetGenericTypeArguments().Single() : type;
operationParameter = new SwaggerParameter
{
Type = typeDescription.Type, // Used as fallback for generators which do not check the "schema" property
Schema = _schemaGenerator.Generate <JsonSchema4>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender)
};
}
else
{
var parameterType = typeDescription.Type.HasFlag(JsonObjectType.Object) ? typeof(string) : type; // object types must be treated as string
operationParameter = _schemaGenerator.Generate <SwaggerParameter>(parameterType, parentAttributes, schemaResolver, schemaDefinitionAppender);
_schemaGenerator.ApplyPropertyAnnotations(operationParameter, type, parentAttributes, typeDescription);
}
operationParameter.Name = name;
operationParameter.IsRequired = parentAttributes?.Any(a => a.GetType().Name == "RequiredAttribute") ?? false;
operationParameter.IsNullableRaw = typeDescription.IsNullable;
if (description != string.Empty)
{
operationParameter.Description = description;
}
return(operationParameter);
}
/// <exception cref="InvalidOperationException">Could not find value type of dictionary type.</exception>
private void GenerateDictionary <TSchemaType>(Type type, TSchemaType schema, ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
where TSchemaType : JsonSchema4, new()
{
var genericTypeArguments = ReflectionExtensions.GetGenericTypeArguments(type);
var valueType = genericTypeArguments.Length == 2 ? genericTypeArguments[1] : typeof(object);
if (valueType == typeof(object))
{
schema.AdditionalPropertiesSchema = JsonSchema4.CreateAnySchema();
}
else
{
if (RequiresSchemaReference(valueType, null))
{
schema.AdditionalPropertiesSchema = new JsonSchema4
{
SchemaReference = Generate(valueType, schemaResolver, schemaDefinitionAppender)
};
}
else
{
schema.AdditionalPropertiesSchema = Generate(valueType, schemaResolver, schemaDefinitionAppender);
}
}
schema.AllowAdditionalProperties = true;
}
private void GeneratePropertiesAndInheritance(Type type, JsonSchema4 schema, ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var properties = GetTypeProperties(type);
#if !LEGACY
var declaredFields = type.GetTypeInfo().DeclaredFields
.Where(f => f.IsPublic);
var declaredProperties = type.GetTypeInfo().DeclaredProperties
.Where(p => p.GetMethod?.IsPublic == true || p.SetMethod?.IsPublic == true);
#else
var declaredFields = type.GetTypeInfo()
.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
var declaredProperties = type.GetTypeInfo()
.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance)
.Where(p => p.GetGetMethod()?.IsPublic == true || p.GetSetMethod()?.IsPublic == true);
#endif
foreach (var property in declaredProperties.Where(p => properties == null || properties.Contains(p.Name)))
{
LoadPropertyOrField(property, property.PropertyType, type, schema, schemaResolver, schemaDefinitionAppender);
}
foreach (var field in declaredFields.Where(p => properties == null || properties.Contains(p.Name)))
{
LoadPropertyOrField(field, field.FieldType, type, schema, schemaResolver, schemaDefinitionAppender);
}
GenerateInheritance(type, schema, schemaResolver, schemaDefinitionAppender);
}
private void AddBodyParameter(SwaggerOperationExtended operation, ISchemaResolver schemaResolver,
ParameterInfo parameter)
{
var operationParameter = CreateBodyParameter(parameter, schemaResolver);
operation.Parameters.Add(operationParameter);
}
private void AddPrimitiveParameter(SwaggerOperationExtended operation, ISchemaResolver schemaResolver,
ParameterInfo parameter)
{
var operationParameter = CreatePrimitiveParameter(parameter, schemaResolver);
operationParameter.Kind = SwaggerParameterKindExtended.Query;
operation.Parameters.Add(operationParameter);
}
public PluginService(ILogger <PluginService> logger,
TFPluginServer pluginServer, ISchemaResolver schemaResolver)
{
_log = logger;
_pluginServer = pluginServer;
_schemaResolver = schemaResolver;
_log.LogInformation("PluginService constructed");
}
/// <summary>Initializes a new instance of the <see cref="SwaggerGenerator"/> class.</summary>
/// <param name="schemaGenerator">The schema generator.</param>
/// <param name="schemaGeneratorSettings">The schema generator settings.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <param name="schemaDefinitionAppender">The schema definition appender.</param>
public SwaggerGenerator(JsonSchemaGenerator schemaGenerator, JsonSchemaGeneratorSettings schemaGeneratorSettings,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
_schemaGenerator = schemaGenerator;
_schemaResolver = schemaResolver;
_schemaDefinitionAppender = schemaDefinitionAppender;
_settings = schemaGeneratorSettings;
}
public TSqlBuilder(
ITableNameResolver tableNameResolver,
IColumnNameResolver columnNameResolver) : base(
tableNameResolver,
columnNameResolver)
{
this.schemaResolver = new DefaultSchemaResolver(DefaultSchema);
}
public TSqlBuilder(
ITableNameResolver tableNameResolver,
IColumnNameResolver columnNameResolver,
ISchemaResolver schemaResolver) : base(
tableNameResolver,
columnNameResolver)
{
this.schemaResolver = schemaResolver;
}
private void AddPrimitiveParameter(string name, SwaggerOperation operation, ParameterInfo parameter,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var operationParameter = CreatePrimitiveParameter(name, parameter, schemaResolver, schemaDefinitionAppender);
operationParameter.Kind = SwaggerParameterKind.Query;
operationParameter.IsRequired = operationParameter.IsRequired || parameter.HasDefaultValue == false;
operation.Parameters.Add(operationParameter);
}
private SwaggerParameter CreateBodyParameter(ParameterInfo parameter, ISchemaResolver schemaResolver)
{
var operationParameter = new SwaggerParameter();
operationParameter.Schema = CreateAndAddSchema <SwaggerParameter>(parameter.ParameterType, schemaResolver);
operationParameter.Name = "request";
operationParameter.Kind = SwaggerParameterKind.body;
return(operationParameter);
}
/// <summary>Generates a <see cref="JsonSchema4" /> object for the given type and adds the mapping to the given resolver.</summary>
/// <typeparam name="TSchemaType">The type of the schema type.</typeparam>
/// <param name="type">The type.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <returns>The schema.</returns>
/// <exception cref="InvalidOperationException">Could not find value type of dictionary type.</exception>
/// <exception cref="InvalidOperationException">Could not find item type of enumeration type.</exception>
public TSchemaType Generate <TSchemaType>(Type type, ISchemaResolver schemaResolver)
where TSchemaType : JsonSchema4, new()
{
var schema = new TSchemaType();
var typeDescription = JsonObjectTypeDescription.FromType(type);
schema.Type = typeDescription.Type;
schema.Format = typeDescription.Format;
if (schema.Type.HasFlag(JsonObjectType.Object))
{
if (typeDescription.IsDictionary)
{
GenerateDictionary(type, schema, schemaResolver);
}
else
{
if (type == typeof(object))
{
return(new TSchemaType
{
Type = JsonObjectType.Object,
AllowAdditionalProperties = false
});
}
schema.TypeName = GetTypeName(type);
if (schemaResolver.HasSchema(type))
{
schema.SchemaReference = schemaResolver.GetSchema(type);
return(schema);
}
GenerateObject(type, schema, schemaResolver);
GenerateInheritance(type, schema, schemaResolver);
}
}
else if (schema.Type.HasFlag(JsonObjectType.Array))
{
schema.Type = JsonObjectType.Array;
var itemType = type.GenericTypeArguments.Length == 0 ? type.GetElementType() : type.GenericTypeArguments[0];
if (itemType == null)
{
throw new InvalidOperationException("Could not find item type of enumeration type '" + type.FullName + "'.");
}
schema.Item = Generate <JsonSchema4>(itemType, schemaResolver);
}
TryLoadEnumerations(type, schema);
return(schema);
}
public SqlServerDataContext(
SqlServerConnectionProvider connectionProvider,
ITableNameResolver tableNameResolver,
IColumnNameResolver columnNameResolver,
ISchemaResolver schemaResolver) : base(
connectionProvider,
new TSqlBuilder(tableNameResolver, columnNameResolver, schemaResolver),
new SqlCache())
{
}
private void GenerateInheritance(Type type, JsonSchema4 schema, ISchemaResolver schemaResolver)
{
var baseType = type.GetTypeInfo().BaseType;
if (baseType != null && baseType != typeof(object))
{
var baseSchema = Generate <JsonProperty>(baseType, schemaResolver);
schema.AllOf.Add(baseSchema);
}
}
private TSchemaType CreateAndAddSchema <TSchemaType>(Type type, ISchemaResolver schemaResolver)
where TSchemaType : JsonSchema4, new()
{
if (type.Name == "Task`1")
{
type = type.GenericTypeArguments[0];
}
if (type.Name == "JsonResult`1")
{
type = type.GenericTypeArguments[0];
}
var info = JsonObjectTypeDescription.FromType(type);
if (info.Type.HasFlag(JsonObjectType.Object))
{
if (!schemaResolver.HasSchema(type))
{
var schemaGenerator = new RootTypeJsonSchemaGenerator(_service);
schemaGenerator.Generate <JsonSchema4>(type, schemaResolver);
}
//load
//目前先屏蔽处理某些特定类型的异常
//Dictionary<string,string>
JsonSchema4 t = null;
try
{
t = schemaResolver.GetSchema(type);
}
catch (Exception)
{
}
return(new TSchemaType
{
Type = JsonObjectType.Object,
SchemaReference = t
});
}
if (info.Type.HasFlag(JsonObjectType.Array))
{
var itemType = type.GenericTypeArguments.Length == 0 ? type.GetElementType() : type.GenericTypeArguments[0];
return(new TSchemaType
{
Type = JsonObjectType.Array,
Item = CreateAndAddSchema <JsonSchema4>(itemType, schemaResolver)
});
}
var generator = new RootTypeJsonSchemaGenerator(_service);
return(generator.Generate <TSchemaType>(type, schemaResolver));
}
/// <exception cref="InvalidOperationException">The operation has more than one body parameter.</exception>
private void GenerateForController(SwaggerService service, Type controllerType, string excludedMethodName,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var hasIgnoreAttribute = controllerType.GetTypeInfo().GetCustomAttributes()
.Any(a => a.GetType().Name == "SwaggerIgnoreAttribute");
if (!hasIgnoreAttribute)
{
var operations = new List <Tuple <SwaggerOperationDescription, MethodInfo> >();
foreach (var method in GetActionMethods(controllerType, excludedMethodName))
{
var httpPaths = GetHttpPaths(controllerType, method);
var httpMethods = GetSupportedHttpMethods(method).ToList();
foreach (var httpPath in httpPaths)
{
foreach (var httpMethod in httpMethods)
{
var operation = new SwaggerOperation
{
IsDeprecated = method.GetCustomAttribute <ObsoleteAttribute>() != null
};
var parameters = method.GetParameters().ToList();
LoadParameters(operation, parameters, httpPath, schemaResolver, schemaDefinitionAppender);
LoadReturnType(operation, method, schemaResolver, schemaDefinitionAppender);
LoadMetaData(operation, method);
LoadOperationTags(method, operation, controllerType);
var operationDescription = new SwaggerOperationDescription
{
Path = Regex.Replace(httpPath, "{(.*?)(:(.*?))?}", match =>
{
if (operation.ActualParameters.Any(p => p.Kind == SwaggerParameterKind.Path && match.Groups[1].Value == p.Name))
{
return("{" + match.Groups[1].Value + "}");
}
return(string.Empty);
}).TrimEnd('/'),
Method = httpMethod,
Operation = operation
};
operationDescription.Operation.OperationId = GetOperationId(service, controllerType.Name, method);
operations.Add(new Tuple <SwaggerOperationDescription, MethodInfo>(operationDescription, method));
}
}
}
AddOperationDescriptionsToDocument(service, operations, schemaResolver);
}
AppendRequiredSchemasToDefinitions(service, schemaResolver);
}
private void AddFileParameter(ParameterInfo parameter, bool isFileArray, SwaggerOperation operation,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var attributes = parameter.GetCustomAttributes().ToList();
// TODO: Check if there is a way to control the property name
var operationParameter = CreatePrimitiveParameter(parameter.Name, parameter.GetXmlDocumentation(),
parameter.ParameterType, attributes, schemaResolver, schemaDefinitionAppender);
InitializeFileParameter(operationParameter, isFileArray);
operation.Parameters.Add(operationParameter);
}
private TSchemaType CreateAndAddSchema <TSchemaType>(Type type, ISchemaResolver schemaResolver)
where TSchemaType : JsonSchema4, new()
{
if (type.Name == "Task`1")
{
type = type.GenericTypeArguments[0];
}
if (type.Name == "JsonResult`1")
{
type = type.GenericTypeArguments[0];
}
var info = JsonObjectTypeDescription.FromType(type);
if (info.Type.HasFlag(JsonObjectType.Object))
{
if (type == typeof(object))
{
return(new TSchemaType
{
Type = JsonObjectType.Object,
AllowAdditionalProperties = false
});
}
if (!schemaResolver.HasSchema(type))
{
var schemaGenerator = new RootTypeJsonSchemaGenerator(_service, JsonSchemaGeneratorSettings);
schemaGenerator.Generate <JsonSchema4>(type, schemaResolver);
}
return(new TSchemaType
{
Type = JsonObjectType.Object,
SchemaReference = schemaResolver.GetSchema(type)
});
}
if (info.Type.HasFlag(JsonObjectType.Array))
{
var itemType = type.GenericTypeArguments.Length == 0 ? type.GetElementType() : type.GenericTypeArguments[0];
return(new TSchemaType
{
Type = JsonObjectType.Array,
Item = CreateAndAddSchema <JsonSchema4>(itemType, schemaResolver)
});
}
var generator = new RootTypeJsonSchemaGenerator(_service, JsonSchemaGeneratorSettings);
return(generator.Generate <TSchemaType>(type, schemaResolver));
}
/// <exception cref="InvalidOperationException">Could not find value type of dictionary type.</exception>
private void GenerateDictionary <TSchemaType>(Type type, TSchemaType schema, ISchemaResolver schemaResolver)
where TSchemaType : JsonSchema4, new()
{
if (type.GenericTypeArguments.Length != 2)
{
throw new InvalidOperationException("Could not find value type of dictionary type '" + type.FullName + "'.");
}
var valueType = type.GenericTypeArguments[1];
schema.AdditionalPropertiesSchema = Generate <JsonProperty>(valueType, schemaResolver);
schema.AllowAdditionalProperties = true;
}
internal override EntityDesignerViewModel LoadModelAndDiagram(
SerializationResult serializationResult, Partition modelPartition, string modelFileName, Partition diagramPartition,
string diagramFileName, ISchemaResolver schemaResolver, ValidationController validationController,
ISerializerLocator serializerLocator)
{
EntityDesignerViewModel evm = null;
using (new VsUtils.HourglassHelper())
{
evm = LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController, serializerLocator);
var diagram = CreateDiagramHelper(diagramPartition, evm);
}
return evm;
}
private bool TryAddFileParameter(JsonObjectTypeDescription info, SwaggerOperation operation, ParameterInfo parameter,
ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
var isFileArray = IsFileArray(parameter.ParameterType, info);
if (info.Type == JsonObjectType.File || isFileArray)
{
AddFileParameter(parameter, isFileArray, operation, schemaResolver, schemaDefinitionAppender);
return(true);
}
return(false);
}
private void GenerateKnownTypes(Type type, ISchemaResolver schemaResolver, ISchemaDefinitionAppender schemaDefinitionAppender)
{
foreach (dynamic knownTypeAttribute in type.GetTypeInfo().GetCustomAttributes().Where(a => a.GetType().Name == "KnownTypeAttribute"))
{
var typeDescription = JsonObjectTypeDescription.FromType(knownTypeAttribute.Type, null, Settings.DefaultEnumHandling);
var isIntegerEnum = typeDescription.Type == JsonObjectType.Integer;
if (!schemaResolver.HasSchema(knownTypeAttribute.Type, isIntegerEnum))
{
var knownSchema = Generate(knownTypeAttribute.Type, schemaResolver, schemaDefinitionAppender);
schemaDefinitionAppender.Append(knownSchema.ActualSchema);
}
}
}
private void LoadReturnType(SwaggerOperation operation, MethodInfo method, ISchemaResolver schemaResolver)
{
if (method.ReturnType.FullName != "System.Void" && method.ReturnType.FullName != "System.Threading.Tasks.Task")
{
operation.Responses["200"] = new SwaggerResponse
{
Schema = CreateAndAddSchema <JsonSchema4>(method.ReturnType, schemaResolver)
};
}
else
{
operation.Responses["200"] = new SwaggerResponse();
}
}
internal override EntityDesignerViewModel LoadModelAndDiagram(
SerializationResult serializationResult, Partition modelPartition, string modelFileName, Partition diagramPartition,
string diagramFileName, ISchemaResolver schemaResolver, ValidationController validationController,
ISerializerLocator serializerLocator)
{
EntityDesignerViewModel evm = null;
using (new VsUtils.HourglassHelper())
{
evm = LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController, serializerLocator);
var diagram = CreateDiagramHelper(diagramPartition, evm);
}
return(evm);
}
private void GenerateInheritance(Type type, JsonSchema4 schema, ISchemaResolver schemaResolver)
{
var baseType = type.GetTypeInfo().BaseType;
if (baseType != null && baseType != typeof(object))
{
if (Settings.FlattenInheritanceHierarchy)
{
GeneratePropertiesAndInheritance(baseType, schema, schemaResolver);
}
else
{
var baseSchema = Generate <JsonProperty>(baseType, schemaResolver);
schema.AllOf.Add(baseSchema);
}
}
}
/// <summary>Processes the specified method information.</summary>
/// <param name="operationDescription">The operation description.</param>
/// <param name="methodInfo">The method information.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <param name="allOperationDescriptions">All operation descriptions.</param>
/// <returns>true if the operation should be added to the Swagger specification.</returns>
public bool Process(SwaggerOperationDescription operationDescription, MethodInfo methodInfo,
ISchemaResolver schemaResolver, IList <SwaggerOperationDescription> allOperationDescriptions)
{
if (operationDescription.Operation.Security == null)
{
operationDescription.Operation.Security = new List <SwaggerSecurityRequirement>();
}
var scopes = GetScopes(operationDescription, methodInfo, schemaResolver, allOperationDescriptions);
operationDescription.Operation.Security.Add(new SwaggerSecurityRequirement
{
{ _name, scopes }
});
return(true);
}
/// <summary>Gets the security scopes for an operation.</summary>
/// <param name="operationDescription">The operation description.</param>
/// <param name="methodInfo">The method information.</param>
/// <param name="schemaResolver">The schema resolver.</param>
/// <param name="allOperationDescriptions">All operation descriptions.</param>
/// <returns>The scopes.</returns>
protected virtual IEnumerable <string> GetScopes(SwaggerOperationDescription operationDescription, MethodInfo methodInfo,
ISchemaResolver schemaResolver, IList <SwaggerOperationDescription> allOperationDescriptions)
{
var allAttributes = methodInfo.GetCustomAttributes().Concat(
methodInfo.DeclaringType.GetTypeInfo().GetCustomAttributes());
var authorizeAttributes = allAttributes.Where(a => a.GetType().Name == "AuthorizeAttribute").ToList();
if (!authorizeAttributes.Any())
{
return(Enumerable.Empty <string>());
}
return(authorizeAttributes
.SelectMany((dynamic attr) => ((string)attr.Roles).Split(','))
.Distinct());
}
private void AppendRequiredSchemasToDefinitions(SwaggerService service, ISchemaResolver schemaResolver)
{
foreach (var schema in schemaResolver.Schemas)
{
if (!service.Definitions.Values.Contains(schema))
{
var typeName = schema.GetTypeName(Settings.TypeNameGenerator);
if (!service.Definitions.ContainsKey(typeName))
{
service.Definitions[typeName] = schema;
}
else
{
service.Definitions["ref_" + Guid.NewGuid().ToString().Replace("-", "_")] = schema;
}
}
}
}
internal override EntityDesignerViewModel LoadModel(
SerializationResult serializationResult, Partition partition, string fileName, ISchemaResolver schemaResolver,
ValidationController validationController, ISerializerLocator serializerLocator)
{
var docData = VSHelpers.GetDocData(PackageManager.Package, fileName) as IEntityDesignDocData;
docData.CreateAndLoadBuffer();
EntityDesignerViewModel evm = null;
var serializationContext = new SerializationContext(GetDirectory(partition.Store), fileName, serializationResult);
var transactionContext = new TransactionContext();
transactionContext.Add(SerializationContext.TransactionContextKey, serializationContext);
using (var t = partition.Store.TransactionManager.BeginTransaction("Load Model from " + fileName, true, transactionContext))
{
var uri = Tools.XmlDesignerBase.Base.Util.Utils.FileName2Uri(fileName);
var context = PackageManager.Package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext(uri);
evm =
ModelTranslatorContextItem.GetEntityModelTranslator(context).TranslateModelToDslModel(null, partition) as
EntityDesignerViewModel;
if (evm == null)
{
serializationResult.Failed = true;
}
else
{
if (t.IsActive)
{
t.Commit();
}
}
}
// Validate imported model
if (!serializationResult.Failed
&& (validationController != null))
{
validationController.Validate(partition, ValidationCategories.Load);
}
return evm;
}
private TSchemaType HandleSpecialTypes <TSchemaType>(Type type, ISchemaResolver schemaResolver)
where TSchemaType : JsonSchema4, new()
{
var typeMapper = Settings.TypeMappers.FirstOrDefault(m => m.MappedType == type);
if (typeMapper != null)
{
var schema = typeMapper.GetSchema <TSchemaType>(this, schemaResolver);
if (schema != null)
{
return(schema);
}
}
if (type == typeof(JObject) || type == typeof(JToken) || type == typeof(object))
{
return(JsonSchema4.CreateAnySchema <TSchemaType>());
}
return(null);
}
public override HostDesignerModel LoadModelAndDiagram(
SerializationResult serializationResult,
Partition modelPartition,
string modelFileName,
Partition diagramPartition,
string diagramFileName,
ISchemaResolver schemaResolver,
ValidationController validationController,
ISerializerLocator serializerLocator)
{
ISchemaResolver resolver = new CustomModelingSchemaResolver(schemaResolver, "GeneratedCode\\HostDesignerSchema.xsd");
return base.LoadModelAndDiagram(
serializationResult,
modelPartition,
modelFileName,
diagramPartition,
diagramFileName,
resolver,
validationController,
serializerLocator);
}
public override MetaModel LoadModel(SerializationResult serializationResult, Store store, string fileName, ISchemaResolver schemaResolver, DslValidation.ValidationController validationController, ISerializerLocator serializerLocator)
{
return LoadModel(serializationResult, store.DefaultPartition, fileName, schemaResolver, validationController, serializerLocator, true, true);
}
public CustomModelingSchemaResolver(ISchemaResolver defaultResolver, string schemaFileName)
{
this.defaultResolver = defaultResolver;
this.schemaFileName = schemaFileName;
}
