public TypeData(Type type, string elementName, bool isPrimitive)
{
this.type = type;
this.elementName = elementName;
this.typeName = type.Name;
this.fullTypeName = type.FullName.Replace('+', '.');
if (isPrimitive)
{
sType = SchemaTypes.Primitive;
}
else
{
if (type.IsEnum)
{
sType = SchemaTypes.Enum;
}
else if (typeof(IXmlSerializable).IsAssignableFrom(type))
{
sType = SchemaTypes.XmlSerializable;
}
else if (typeof(System.Xml.XmlNode).IsAssignableFrom(type))
{
sType = SchemaTypes.XmlNode;
}
else if (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type))
{
sType = SchemaTypes.Array;
}
else
{
sType = SchemaTypes.Class;
}
}
}
protected void TryAddType(SchemaType schemaType, bool doNotAddErrorForEmptyName)
{
SchemaManager.SchemaTypes.Add(
schemaType, doNotAddErrorForEmptyName,
Strings.TypeNameAlreadyDefinedDuplicate);
SchemaTypes.Add(schemaType);
}
static void AddSchemaTypes(DiscoveryVersion discoveryVersion, SchemaTypes typesFound, XmlSchema discoverySchema)
{
if ((typesFound & SchemaTypes.ProbeMatchType) == 0)
{
AddProbeMatchType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ProbeType) == 0)
{
AddProbeType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ResolveType) == 0)
{
AddResolveType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.QNameListType) == 0)
{
AddQNameListType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ScopesType) == 0)
{
AddScopesType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.UriListType) == 0)
{
AddUriListType(discoveryVersion, discoverySchema);
}
}
/// <summary>
/// Load Schemas from data source
/// </summary>
/// <returns>Schemas</returns>
public virtual async Task<IEnumerable<ISchema>> Schemas(SchemaTypes type = SchemaTypes.StoredProcedure)
{
var sql = this.statements.Get(type);
var ds = await this.executor.Query(sql);
return ds.Models<Schema>();
}
public IEnumerable <PropertyDeclarationSyntax> GeneratePropertyDeclarations(SourceFileContext ctx)
{
var propertyTyp = SchemaTypes.GetTypFromSchema(Parent.Package, _schema, Name, ctx.CurrentTyp, inParameter: false);
if (propertyTyp.FullName == "System.Nullable<System.DateTime>")
{
// DateTime values generate two properties: one raw as a string, and one DateTime version.
var rawProperty = AutoProperty(Modifier.Public | Modifier.Virtual, ctx.Type <string>(), PropertyName + "Raw", hasSetter: true)
.WithAttribute(ctx.Type <JsonPropertyAttribute>())(Name);
if (_schema.Description is object)
{
rawProperty = rawProperty.WithXmlDoc(XmlDoc.Summary(_schema.Description));
}
yield return(rawProperty);
var valueParameter = Parameter(ctx.Type(propertyTyp), "value");
yield return(Property(Modifier.Public | Modifier.Virtual, ctx.Type(propertyTyp), PropertyName)
.WithAttribute(ctx.Type <JsonIgnoreAttribute>())()
.WithXmlDoc(XmlDoc.Summary(XmlDoc.SeeAlso(ctx.Type <DateTime>()), " representation of ", rawProperty, "."))
.WithGetBody(Return(ctx.Type(typeof(Utilities)).Call(nameof(Utilities.GetDateTimeFromString))(rawProperty)))
.WithSetBody(rawProperty.Assign(ctx.Type(typeof(Utilities)).Call(nameof(Utilities.GetStringFromDateTime))(valueParameter))));
}
else
{
var property = AutoProperty(Modifier.Public | Modifier.Virtual, ctx.Type(propertyTyp), PropertyName, hasSetter: true)
.WithAttribute(ctx.Type <JsonPropertyAttribute>())(Name);
if (_schema.Description is object)
{
property = property.WithXmlDoc(XmlDoc.Summary(_schema.Description));
}
yield return(property);
}
}
protected void TryAddContainer(SchemaType schemaType, bool doNotAddErrorForEmptyName)
{
SchemaManager.SchemaTypes.Add(
schemaType, doNotAddErrorForEmptyName,
Strings.EntityContainerAlreadyExists);
SchemaTypes.Add(schemaType);
}
protected void AddFunctionType(Function function)
{
var space = DataModel == SchemaDataModelOption.EntityDataModel ? "Conceptual" : "Storage";
if (SchemaVersion >= XmlConstants.EdmVersionForV2 &&
SchemaManager.SchemaTypes.ContainsKey(function.FQName))
{
function.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.AmbiguousFunctionAndType(function.FQName, space));
}
else
{
var error = SchemaManager.SchemaTypes.TryAdd(function);
Debug.Assert(error != AddErrorKind.MissingNameError, "Function identity can never be null while adding global functions");
if (error != AddErrorKind.Succeeded)
{
function.AddError(
ErrorCode.AlreadyDefined, EdmSchemaErrorSeverity.Error,
Strings.AmbiguousFunctionOverload(function.FQName, space));
}
else
{
SchemaTypes.Add(function);
}
}
}
public void DeselectAllBoundOperations()
{
foreach (var boundOperation in SchemaTypes.SelectMany(x => x.BoundOperations))
{
boundOperation.IsSelected = false;
}
}
/// <summary>
/// Load data from Database, and return the models.
/// </summary>
/// <returns>Schemas to process</returns>
public virtual async Task<IEnumerable<IDefinition>> Load(SchemaTypes type = SchemaTypes.StoredProcedure)
{
var schemas = await this.Schemas(type);
var definitions = this.Minimize(schemas);
return this.BuildManifest(definitions, schemas);
}
internal TypeData(string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
this.elementName = xmlType;
this.typeName = typeName;
this.fullTypeName = fullTypeName.Replace('+', '.');
this.listItemTypeData = listItemTypeData;
this.sType = schemaType;
}
internal TypeData (string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
this.elementName = xmlType;
this.typeName = typeName;
this.fullTypeName = fullTypeName.Replace ('+', '.');
this.listItemTypeData = listItemTypeData;
this.sType = schemaType;
}
public TypeData(Type type, string elementName, bool isPrimitive, TypeData mappedType, XmlSchemaPatternFacet facet)
{
#if NET_2_0
if (type.IsGenericTypeDefinition)
{
throw new InvalidOperationException("Generic type definition cannot be used in serialization. Only specific generic types can be used.");
}
#endif
this.mappedType = mappedType;
this.facet = facet;
this.type = type;
this.typeName = type.Name;
this.fullTypeName = type.FullName.Replace('+', '.');
if (isPrimitive)
{
sType = SchemaTypes.Primitive;
}
else
{
if (type.IsEnum)
{
sType = SchemaTypes.Enum;
}
else if (typeof(IXmlSerializable).IsAssignableFrom(type))
{
sType = SchemaTypes.XmlSerializable;
}
#if !MOONLIGHT
else if (typeof(System.Xml.XmlNode).IsAssignableFrom(type))
{
sType = SchemaTypes.XmlNode;
}
#endif
else if (type.IsArray || typeof(IEnumerable).IsAssignableFrom(type))
{
sType = SchemaTypes.Array;
}
else
{
sType = SchemaTypes.Class;
}
}
if (IsListType)
{
this.elementName = TypeTranslator.GetArrayName(ListItemTypeData.XmlType);
}
else
{
this.elementName = elementName;
}
if (sType == SchemaTypes.Array || sType == SchemaTypes.Class)
{
hasPublicConstructor = !type.IsInterface && (type.IsArray || type.GetConstructor(Type.EmptyTypes) != null || type.IsAbstract || type.IsValueType);
}
}
public static XmlQualifiedName EnsureProbeMatchSchema(DiscoveryVersion discoveryVersion, XmlSchemaSet schemaSet)
{
Fx.Assert(schemaSet != null, "The schemaSet must be non null.");
Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null.");
// ensure that EPR is added to the schema.
if (discoveryVersion == DiscoveryVersion.WSDiscoveryApril2005 || discoveryVersion == DiscoveryVersion.WSDiscoveryCD1)
{
EndpointAddressAugust2004.GetSchema(schemaSet);
}
else if (discoveryVersion == DiscoveryVersion.WSDiscovery11)
{
EndpointAddress10.GetSchema(schemaSet);
}
else
{
Fx.Assert("The discoveryVersion is not supported.");
}
// do not add/find Probe related schema items
SchemaTypes typesFound = SchemaTypes.ProbeType | SchemaTypes.ResolveType;
SchemaElements elementsFound = SchemaElements.None;
XmlSchema discoverySchema = null;
ICollection discoverySchemas = schemaSet.Schemas(discoveryVersion.Namespace);
if ((discoverySchemas == null) || (discoverySchemas.Count == 0))
{
discoverySchema = CreateSchema(discoveryVersion);
AddImport(discoverySchema, discoveryVersion.Implementation.WsaNamespace);
schemaSet.Add(discoverySchema);
}
else
{
foreach (XmlSchema schema in discoverySchemas)
{
discoverySchema = schema;
if (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ProbeMatchType))
{
typesFound |= SchemaTypes.ProbeMatchType;
break;
}
LocateSchemaTypes(discoveryVersion, schema, ref typesFound);
LocateSchemaElements(discoveryVersion, schema, ref elementsFound);
}
}
if ((typesFound & SchemaTypes.ProbeMatchType) != SchemaTypes.ProbeMatchType)
{
AddSchemaTypes(discoveryVersion, typesFound, discoverySchema);
AddElements(discoveryVersion, elementsFound, discoverySchema);
schemaSet.Reprocess(discoverySchema);
}
return(discoveryVersion.Implementation.QualifiedNames.ProbeMatchType);
}
/// <summary>
/// Executed when entering the page for selecting schema types.
/// It fires PageEntering event which ensures all types are loaded on the UI.
/// It also ensures all related entities are computed and cached.
/// </summary>
/// <param name="args">Event arguments being passed to the method.</param>
public override async Task OnPageEnteringAsync(WizardEnteringArgs args)
{
this.IsEntered = true;
await base.OnPageEnteringAsync(args);
View = new SchemaTypes()
{
DataContext = this
};
PageEntering?.Invoke(this, EventArgs.Empty);
}
internal TypeData(string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
this.hasPublicConstructor = true;
base..ctor();
this.elementName = xmlType;
this.typeName = typeName;
this.fullTypeName = fullTypeName.Replace('+', '.');
this.listItemTypeData = listItemTypeData;
this.sType = schemaType;
this.hasPublicConstructor = true;
}
/// <summary>
/// Get SQL Schema Statement
/// </summary>
/// <param name="type">Schema Type</param>
/// <returns>Schema Select Statement</returns>
public virtual string Get(SchemaTypes type = SchemaTypes.StoredProcedure)
{
switch (type)
{
case SchemaTypes.StoredProcedure:
return StoredProcedures;
case SchemaTypes.Table:
return Tables;
default:
throw new ArgumentException("Unknown schema type.");
}
}
/// <summary>
/// Resolve the type - if the type is not found, return appropriate error
/// </summary>
/// <returns></returns>
public bool TryResolveType(string namespaceName, string typeName, out SchemaType schemaType)
{
// For resolving entity container names, namespace can be null
string fullyQualifiedName = String.IsNullOrEmpty(namespaceName) ? typeName : namespaceName + "." + typeName;
schemaType = SchemaTypes.LookUpEquivalentKey(fullyQualifiedName);
if (schemaType != null)
{
return(true);
}
return(false);
}
/// <summary>
/// Determines how code referring to this data model should be refer to it; this takes
/// into account whether it's a placeholder, an array etc.
/// </summary>
internal Typ GetTypForReference()
{
var ret = IsPlaceholder ? Typ.Of <object>() : Typ;
if (IsArray)
{
ret = Typ.Generic(typeof(IList <>), ret);
}
if (_schema.AdditionalProperties is object)
{
ret = SchemaTypes.GetTypFromAdditionalProperties(Package, _schema.AdditionalProperties, Name, ret, inParameter: false);
}
return(ret);
}
/// <summary>
/// Create
/// </summary>
/// <param name="type">Type</param>
/// <param name="name">Name</param>
/// <param name="statement">Statement</param>
/// <returns>Success</returns>
public virtual async Task<bool> Create(SchemaTypes type, string name, string statement)
{
var exists = (from t in await this.reader.Load(type)
where t.Name == name
&& t.Preface == SqlStatements.Schema
select true).FirstOrDefault();
if (!exists)
{
Trace.TraceInformation("Creating {0} to load data into table: '{1}'.", type, this.tableName);
return await this.executor.NonQuery(statement) == -1;
}
return true;
}
/// <summary>
/// Create
/// </summary>
/// <param name="type">Type</param>
/// <param name="name">Name</param>
/// <param name="statement">Statement</param>
/// <returns>Success</returns>
public virtual async Task <bool> Create(SchemaTypes type, string name, string statement)
{
var exists = (from t in await this.reader.Load(type)
where t.Name == name &&
t.Preface == SqlStatements.Schema
select true).FirstOrDefault();
if (!exists)
{
Trace.TraceInformation("Creating {0} to load data into table: '{1}'.", type, this.tableName);
return(await this.executor.NonQuery(statement) == -1);
}
return(true);
}
public ParameterModel(PackageModel package, string name, JsonSchema schema, Typ parentTyp)
{
Name = name;
CodeParameterName = name.ToLocalVariableName(package);
// It's unclear why these properties don't get the "__" treatment, but apparently they don't.
PropertyName = name.ToMemberName(addUnderscoresToEscape: false);
Location = schema.Location switch
{
"query" => RequestParameterType.Query,
"path" => RequestParameterType.Path,
_ => throw new InvalidOperationException($"Unhandled parameter location: '{_schema.Location}'")
};
EnumModel = schema.Enum__ is object?new EnumModel(name, schema) : null;
_schema = schema;
Typ = SchemaTypes.GetTypFromSchema(package, schema, name, currentTyp: parentTyp, inParameter: true);
}
/// <summary>
/// Executed when entering the page for selecting schema types.
/// It fires PageEntering event which ensures all types are loaded on the UI.
/// It also ensures all related entities are computed and cached.
/// </summary>
/// <param name="args">Event arguments being passed to the method.</param>
public override async Task OnPageEnteringAsync(WizardEnteringArgs args)
{
this.IsEntered = true;
await base.OnPageEnteringAsync(args).ConfigureAwait(false);
View = new SchemaTypes()
{
DataContext = this
};
PageEntering?.Invoke(this, EventArgs.Empty);
if (this.View is SchemaTypes view)
{
view.SelectedSchemaTypesCount.Text = SchemaTypes.Count(x => x.IsSelected).ToString(CultureInfo.InvariantCulture);
view.SelectedBoundOperationsCount.Text = SchemaTypes
.Where(x => x.IsSelected && x.BoundOperations?.Any() == true).SelectMany(x => x.BoundOperations)
.Count(x => x.IsSelected).ToString(CultureInfo.InvariantCulture);
}
}
internal void CompleteSchema(
SchemaTypesDefinition schemaTypesDefinition)
{
if (schemaTypesDefinition is null)
{
throw new ArgumentNullException(nameof(schemaTypesDefinition));
}
if (_sealed)
{
throw new InvalidOperationException(
"This schema is already sealed and cannot be mutated.");
}
DirectiveTypes = schemaTypesDefinition.DirectiveTypes;
_types = new SchemaTypes(schemaTypesDefinition);
_directiveTypes = DirectiveTypes.ToDictionary(t => t.Name);
_sealed = true;
}
public static XmlQualifiedName EnsureProbeSchema(DiscoveryVersion discoveryVersion, XmlSchemaSet schemaSet)
{
Fx.Assert(schemaSet != null, "The schemaSet must be non null.");
Fx.Assert(discoveryVersion != null, "The discoveryVersion must be non null.");
// do not find/add ProbeMatch related schema items
SchemaTypes typesFound = SchemaTypes.ProbeMatchType | SchemaTypes.ResolveType;
SchemaElements elementsFound = SchemaElements.XAddrs | SchemaElements.MetadataVersion;
XmlSchema discoverySchema = null;
ICollection discoverySchemas = schemaSet.Schemas(discoveryVersion.Namespace);
if ((discoverySchemas == null) || (discoverySchemas.Count == 0))
{
discoverySchema = CreateSchema(discoveryVersion);
schemaSet.Add(discoverySchema);
}
else
{
foreach (XmlSchema schema in discoverySchemas)
{
discoverySchema = schema;
if (schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ProbeType))
{
typesFound |= SchemaTypes.ProbeType;
break;
}
LocateSchemaTypes(discoveryVersion, schema, ref typesFound);
LocateSchemaElements(discoveryVersion, schema, ref elementsFound);
}
}
if ((typesFound & SchemaTypes.ProbeType) != SchemaTypes.ProbeType)
{
AddSchemaTypes(discoveryVersion, typesFound, discoverySchema);
AddElements(discoveryVersion, elementsFound, discoverySchema);
schemaSet.Reprocess(discoverySchema);
}
return(discoveryVersion.Implementation.QualifiedNames.ProbeType);
}
public async Task GetSchemaTypesSuccess()
{
SchemaTypes expectedSchemaTypes = new SchemaTypes
{
AvailableSchemaTypes = new string[]
{
"achievements", "userstats"
}
};
Uri uri = new Uri(new Uri(ClientSettings.Singleton.XConEndpoint), "/schema");
this.mockHandler.Expect(uri.ToString())
.Respond(res => this.ExpectedJsonResponse(expectedSchemaTypes));
ConfigResponse <IEnumerable <string> > schemaTypes = await ConfigurationManager.GetSchemaTypesAsync();
Assert.AreEqual(DefaultCorrelationVector, schemaTypes.CorrelationId);
Assert.AreEqual(2, schemaTypes.Result.Count());
}
private Schema InitSchema(IGraphQLClient gqlClient)
{
var request = new GraphQLRequest {
Query = GetIntrospectionQuery()
};
var result = Task.Run(async() => await gqlClient.SendQueryAsync <JObject>(request, CancellationToken.None))
.GetAwaiter()
.GetResult()
.Data;
var queryType = (JObject)result["__schema"]["queryType"];
var types = ((JArray)result["__schema"]["types"]).Cast <JObject>().ToArray();
var dummySchema = new Schema();
dummySchema.Initialize();
var schemaTypes = new SchemaTypes(dummySchema, new DefaultServiceProvider());
var cache = new Dictionary <string, IGraphType>();
var qt = ResolveGraphType(_ => schemaTypes[_] ?? (cache.ContainsKey(_) ? cache[_] : null), types, queryType, cache);
var commonTypes = cache.Values.ToArray();
foreach (var type in types)
{
ResolveGraphType(_ => schemaTypes[_] ?? (cache.ContainsKey(_) ? cache[_] : null), types, type, cache);
}
var newSchema = new Schema();
newSchema.Query = (IObjectGraphType)qt;
foreach (var type in cache.Values.Except(commonTypes))
{
newSchema.RegisterType(type);
}
newSchema.Initialize();
return(newSchema);
}
public TypeData (Type type, string elementName, bool isPrimitive, TypeData mappedType, XmlSchemaPatternFacet facet)
{
#if NET_2_0
if (type.IsGenericTypeDefinition)
throw new InvalidOperationException ("Generic type definition cannot be used in serialization. Only specific generic types can be used.");
#endif
this.mappedType = mappedType;
this.facet = facet;
this.type = type;
this.typeName = type.Name;
this.fullTypeName = type.FullName.Replace ('+', '.');
if (isPrimitive)
sType = SchemaTypes.Primitive;
else
{
if (type.IsEnum)
sType = SchemaTypes.Enum;
else if (typeof(IXmlSerializable).IsAssignableFrom (type))
sType = SchemaTypes.XmlSerializable;
#if !MOONLIGHT
else if (typeof (System.Xml.XmlNode).IsAssignableFrom (type))
sType = SchemaTypes.XmlNode;
#endif
else if (type.IsArray || typeof(IEnumerable).IsAssignableFrom (type))
sType = SchemaTypes.Array;
else
sType = SchemaTypes.Class;
}
if (IsListType)
this.elementName = TypeTranslator.GetArrayName (ListItemTypeData.XmlType);
else
this.elementName = elementName;
if (sType == SchemaTypes.Array || sType == SchemaTypes.Class) {
hasPublicConstructor = !type.IsInterface && (type.IsArray || type.GetConstructor (Type.EmptyTypes) != null || type.IsAbstract || type.IsValueType);
}
}
public SchemaFieldBuilder(SchemaDocumentBuilder documentBuilder,
VersionKey version)
{
Doc = documentBuilder;
var state = version.AsState();
var interpreter = new Interpreter(state);
var compoundFields = documentBuilder.Document
.Compounds.Values
.Select(c => (c.Name, c.Fields));
var niObjectFields = documentBuilder.Document
.NiObjects.Values
.Select(ni => (ni.Name, ni.Fields));
IncludedFieldsByTypeName = compoundFields.Concat(niObjectFields)
.ToDictionary(
p => p.Name,
p => p.Fields
.Where(f => IsFieldIncluded(f, interpreter, version))
.ToList()
);
FieldTypes = IncludedFieldsByTypeName
.SelectMany(kvp =>
kvp.Value.Select(field =>
(field, documentBuilder.SchemaTypes.GetFieldType(field))))
.ToDictionary(ft => ft.field, ft => ft.Item2);
FieldTypes = IncludedFieldsByTypeName
.SelectMany(kvp =>
kvp.Value.Select(field =>
(field, documentBuilder.SchemaTypes.GetFieldType(field))))
.ToDictionary(ft => ft.field, ft => ft.Item2);
FieldBuilders = IncludedFieldsByTypeName
.SelectMany(kvp => kvp.Value.Select(field => (field, BuildField(kvp.Key, field))))
.ToDictionary(p => p.field, p => p.Item2);
}
public TypeData (Type type, string elementName, bool isPrimitive)
{
this.type = type;
this.elementName = elementName;
this.typeName = type.Name;
this.fullTypeName = type.FullName.Replace ('+', '.');
if (isPrimitive)
sType = SchemaTypes.Primitive;
else
{
if (type.IsEnum)
sType = SchemaTypes.Enum;
else if (typeof(IXmlSerializable).IsAssignableFrom (type))
sType = SchemaTypes.XmlSerializable;
else if (typeof (System.Xml.XmlNode).IsAssignableFrom (type))
sType = SchemaTypes.XmlNode;
else if (type.IsArray || typeof(IEnumerable).IsAssignableFrom (type))
sType = SchemaTypes.Array;
else
sType = SchemaTypes.Class;
}
}
IDataContext GetDB(SchemaTypes tipe)
{
if (tipe == SchemaTypes.StreamData)
{
return container.Get<InMemoryDb>();
}
else if (tipe == SchemaTypes.RelationalData)
{
return container.Get<DocumentDb>();
}
else
{
var dx = container.Get<ColumnarDb>();
if (Context != null)
{
dx.UserName = Context.User.Identity.Name;
}
return dx;
}
}
/// <summary>
/// Loads bound operations except the ones that require a type that is excluded
/// </summary>
/// <param name="schemaType">a schema type model.</param>
/// <param name="boundOperations">a list of all the bound operations.</param>
/// <param name="excludedSchemaTypes">A collection of schema types that will be excluded from generated code.</param>
/// <param name="schemaTypeModels">a dictionary of schema type and the associated schematypemodel.</param>
private void LoadBoundOperations(SchemaTypeModel schemaType,
IDictionary <IEdmType, List <IEdmOperation> > boundOperations, ICollection <string> excludedSchemaTypes,
IDictionary <string, SchemaTypeModel> schemaTypeModels)
{
var toLoad = new ObservableCollection <BoundOperationModel>();
var alreadyAdded = new HashSet <string>();
foreach (KeyValuePair <IEdmType, List <IEdmOperation> > boundOperation in boundOperations)
{
IEdmType edmType = boundOperation.Key;
foreach (IEdmOperation operation in boundOperation.Value)
{
string name = $"{operation.Name}({edmType.FullTypeName()})";
if (!alreadyAdded.Contains(name))
{
var boundOperationModel = new BoundOperationModel
{
Name = name,
ShortName = operation.Name,
IsSelected = IsBoundOperationIncluded(operation, excludedSchemaTypes)
};
boundOperationModel.PropertyChanged += (s, args) =>
{
if (s is BoundOperationModel currentBoundOperationModel)
{
IEnumerable <IEdmOperationParameter> parameters = operation.Parameters;
foreach (var parameter in parameters)
{
var parameterTypeName = parameter.Type.IsCollection()
? parameter.Type.AsCollection()?.ElementType()?.FullName()
: parameter.Type.FullName();
if (parameterTypeName != null &&
schemaTypeModels.TryGetValue(parameterTypeName, out SchemaTypeModel model) &&
!model.IsSelected && model.IsSelected != currentBoundOperationModel.IsSelected)
{
model.IsSelected = currentBoundOperationModel.IsSelected;
}
}
string returnTypeName = operation.ReturnType?.IsCollection() == true
? operation.ReturnType?.AsCollection()?.ElementType()?.FullName()
: operation.ReturnType?.FullName();
if (returnTypeName != null &&
schemaTypeModels.TryGetValue(returnTypeName, out SchemaTypeModel schemaTypeModel) &&
!schemaTypeModel.IsSelected &&
schemaTypeModel.IsSelected != currentBoundOperationModel.IsSelected)
{
schemaTypeModel.IsSelected = currentBoundOperationModel.IsSelected;
}
if (this.View is SchemaTypes view)
{
view.SelectedBoundOperationsCount.Text = SchemaTypes
.Where(x => x.IsSelected && x.BoundOperations?.Any() == true)
.SelectMany(x => x.BoundOperations).Count(x => x.IsSelected).ToString(CultureInfo.InvariantCulture);
}
}
};
toLoad.Add(boundOperationModel);
alreadyAdded.Add(name);
}
}
}
schemaType.BoundOperations = toLoad.OrderBy(o => o.Name).ToList();
}
public static TypeData CreateCustomType (string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
TypeData td = new TypeData (typeName, fullTypeName, xmlType, schemaType, listItemTypeData);
return td;
}
public static TypeData CreateCustomType(string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
return(new TypeData(typeName, fullTypeName, xmlType, schemaType, listItemTypeData));
}
XmlTypeMapping CreateTypeMapping (XmlQualifiedName typeQName, SchemaTypes schemaType, XmlQualifiedName root)
{
string typeName = CodeIdentifier.MakeValid (typeQName.Name);
typeName = typeIdentifiers.AddUnique (typeName, null);
TypeData typeData = new TypeData (typeName, typeName, typeName, schemaType, null);
string rootElem;
string rootNs;
if (root != null) {
rootElem = root.Name;
rootNs = root.Namespace;
}
else {
rootElem = typeQName.Name;
rootNs = "";
}
XmlTypeMapping map = new XmlTypeMapping (rootElem, rootNs, typeData, typeQName.Name, typeQName.Namespace);
map.IncludeInSchema = true;
RegisterTypeMapping (typeQName, typeData, map);
return map;
}
static void LocateSchemaTypes(DiscoveryVersion discoveryVersion, XmlSchema schema, ref SchemaTypes typesFound)
{
if (((typesFound & SchemaTypes.QNameListType) != SchemaTypes.QNameListType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.QNameListType)))
{
typesFound |= SchemaTypes.QNameListType;
}
if (((typesFound & SchemaTypes.UriListType) != SchemaTypes.UriListType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.UriListType)))
{
typesFound |= SchemaTypes.UriListType;
}
if (((typesFound & SchemaTypes.ScopesType) != SchemaTypes.ScopesType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ScopesType)))
{
typesFound |= SchemaTypes.ScopesType;
}
}
static void AddSchemaTypes(DiscoveryVersion discoveryVersion, SchemaTypes typesFound, XmlSchema discoverySchema)
{
if ((typesFound & SchemaTypes.ProbeMatchType) == 0)
{
AddProbeMatchType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ProbeType) == 0)
{
AddProbeType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ResolveType) == 0)
{
AddResolveType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.QNameListType) == 0)
{
AddQNameListType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.ScopesType) == 0)
{
AddScopesType(discoveryVersion, discoverySchema);
}
if ((typesFound & SchemaTypes.UriListType) == 0)
{
AddUriListType(discoveryVersion, discoverySchema);
}
}
/// <summary>
/// Creates a list of types that needs to be loaded on the UI.
/// Initially all the types are loaded
/// </summary>
/// <param name="schemaTypes">A list of schema types that need to be laoded.</param>
/// <param name="boundOperations">The associated bound operations.</param>
public void LoadSchemaTypes(
IEnumerable <IEdmSchemaType> schemaTypes, IDictionary <IEdmStructuredType, List <IEdmOperation> > boundOperations)
{
var toLoad = new List <SchemaTypeModel>();
foreach (var type in schemaTypes)
{
if (!SchemaTypeModelMap.ContainsKey(type.FullName()) || SchemaTypeModelMap.Count() != schemaTypes.Count())
{
SchemaTypes = toLoad;
SchemaTypeModelMap.Clear();
break;
}
}
if (SchemaTypes.Any())
{
return;
}
foreach (var schemaType in schemaTypes)
{
var schemaTypeModel = new SchemaTypeModel()
{
Name = schemaType.FullTypeName(),
ShortName = EdmHelper.GetTypeNameFromFullName(schemaType.FullTypeName())
};
// Create propertyChange handler.
// Anytime a property is selected/unslected, the handler ensures
// all the related types and operations are selected/unselected
schemaTypeModel.PropertyChanged += (s, args) =>
{
if (schemaTypeModel.IsSelected && schemaType is IEdmStructuredType structuredType)
{
//Check for the base type and automatically select it if not selected already.
string baseTypeFullName = structuredType.BaseType?.FullTypeName();
if (baseTypeFullName != null)
{
AddRelatedType(baseTypeFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(baseTypeFullName, out SchemaTypeModel baseTypeSchemaTypeModel) &&
!baseTypeSchemaTypeModel.IsSelected)
{
baseTypeSchemaTypeModel.IsSelected = true;
}
}
// Check the required navigational property types and ensure they are selected as well
foreach (var property in structuredType.DeclaredProperties)
{
string propertyName = property is IEdmNavigationProperty?property.Type.ToStructuredType().FullTypeName() : property.Type.FullName();
if (property.Type.ToStructuredType() != null || property.Type.IsEnum())
{
propertyName = property.Type.ToStructuredType()?.FullTypeName() ?? property.Type.FullName();
AddRelatedType(propertyName, structuredType.FullTypeName());
bool hasProperty = SchemaTypeModelMap.TryGetValue(propertyName, out SchemaTypeModel navigationPropertyModel);
if (hasProperty && !navigationPropertyModel.IsSelected)
{
navigationPropertyModel.IsSelected = true;
}
}
}
// Check for bound operations and ensure related types are also selected.
// In this case related types means return types and parameter types.
if (boundOperations.TryGetValue(structuredType, out List <IEdmOperation> operations))
{
foreach (var operation in operations)
{
// Check if return type of associated bound operation has been selected.
if (operation.ReturnType != null && (operation.ReturnType.ToStructuredType() != null || operation.ReturnType.IsEnum()))
{
string returnTypeFullName = operation.ReturnType.ToStructuredType()?.FullTypeName() ?? operation.ReturnType.FullName();
AddRelatedType(returnTypeFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(returnTypeFullName, out SchemaTypeModel referencedSchemaTypeModel) &&
!referencedSchemaTypeModel.IsSelected)
{
referencedSchemaTypeModel.IsSelected = true;
}
}
// Check if parameter types of associated bound operations has been selected.
IEnumerable <IEdmOperationParameter> parameters = operation.Parameters;
foreach (var parameter in parameters)
{
if (parameter.Type.ToStructuredType() != null || parameter.Type.IsEnum())
{
string parameterFullName = parameter.Type.ToStructuredType()?.FullTypeName() ?? parameter.Type.FullName();
AddRelatedType(parameterFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(parameterFullName, out SchemaTypeModel model) && !model.IsSelected)
{
model.IsSelected = true;
}
}
}
}
}
}
else if (!schemaTypeModel.IsSelected)
{
// automatically deselect related types for deselected type
if (RelatedTypes.TryGetValue(schemaTypeModel.Name, out ICollection <string> relatedTypes))
{
foreach (var relatedType in relatedTypes)
{
if (SchemaTypeModelMap.TryGetValue(relatedType, out SchemaTypeModel relatedSchemaTypeModel) &&
relatedSchemaTypeModel.IsSelected)
{
relatedSchemaTypeModel.IsSelected = false;
}
}
}
}
};
toLoad.Add(schemaTypeModel);
schemaTypeModel.IsSelected = true;
SchemaTypeModelMap.Add(schemaType.FullTypeName(), schemaTypeModel);
}
SchemaTypes = toLoad.OrderBy(o => o.Name).ToList();
}
static void LocateSchemaTypes(DiscoveryVersion discoveryVersion, XmlSchema schema, ref SchemaTypes typesFound)
{
if (((typesFound & SchemaTypes.QNameListType) != SchemaTypes.QNameListType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.QNameListType)))
{
typesFound |= SchemaTypes.QNameListType;
}
if (((typesFound & SchemaTypes.UriListType) != SchemaTypes.UriListType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.UriListType)))
{
typesFound |= SchemaTypes.UriListType;
}
if (((typesFound & SchemaTypes.ScopesType) != SchemaTypes.ScopesType) &&
(schema.SchemaTypes.Contains(discoveryVersion.Implementation.QualifiedNames.ScopesType)))
{
typesFound |= SchemaTypes.ScopesType;
}
}
/// <summary>
/// Creates a list of types that needs to be loaded on the UI.
/// Initially all the types are loaded
/// </summary>
/// <param name="schemaTypes">A list of schema types that need to be laoded.</param>
/// <param name="boundOperations">The associated bound operations.</param>
public void LoadSchemaTypes(
IEnumerable <IEdmSchemaType> schemaTypes, IDictionary <IEdmType, List <IEdmOperation> > boundOperations)
{
var toLoad = new List <SchemaTypeModel>();
foreach (var type in schemaTypes)
{
if (!SchemaTypeModelMap.ContainsKey(type.FullName()) ||
SchemaTypeModelMap.Count != schemaTypes.Count())
{
SchemaTypes = toLoad;
SchemaTypeModelMap.Clear();
break;
}
}
if (SchemaTypes.Any())
{
return;
}
foreach (var schemaType in schemaTypes)
{
var schemaTypeModel = new SchemaTypeModel
{
Name = schemaType.FullTypeName(),
ShortName = EdmHelper.GetTypeNameFromFullName(schemaType.FullTypeName())
};
// Create propertyChange handler.
// Anytime a property is selected/unslected, the handler ensures
// all the related types and operations are selected/unselected
schemaTypeModel.PropertyChanged += (s, args) =>
{
if (schemaTypeModel.IsSelected && schemaType is IEdmStructuredType structuredType)
{
//Check for the base type and automatically select it if not selected already.
string baseTypeFullName = structuredType.BaseType?.FullTypeName();
if (baseTypeFullName != null)
{
AddRelatedType(baseTypeFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(baseTypeFullName,
out SchemaTypeModel baseTypeSchemaTypeModel) &&
!baseTypeSchemaTypeModel.IsSelected)
{
baseTypeSchemaTypeModel.IsSelected = true;
}
}
// Check the required property types and ensure they are selected as well
foreach (var property in structuredType.DeclaredProperties)
{
IEdmTypeReference propertyType = property.Type.IsCollection()
? property.Type.AsCollection().ElementType()
: property.Type;
if (propertyType.ToStructuredType() != null || propertyType.IsEnum())
{
string propertyTypeName = propertyType.ToStructuredType()?.FullTypeName() ?? propertyType.FullName();
AddRelatedType(propertyTypeName, structuredType.FullTypeName());
bool hasProperty = SchemaTypeModelMap.TryGetValue(propertyTypeName, out SchemaTypeModel propertySchemaTypeModel);
if (hasProperty && !propertySchemaTypeModel.IsSelected)
{
propertySchemaTypeModel.IsSelected = true;
}
}
}
// Check for bound operations and ensure related types are also selected.
// In this case related types means return types and parameter types.
if (boundOperations.TryGetValue(structuredType, out List <IEdmOperation> operations))
{
foreach (var operation in operations)
{
// Check if return type of associated bound operation has been selected.
if (operation.ReturnType != null &&
(operation.ReturnType.ToStructuredType() != null || operation.ReturnType.IsEnum()))
{
string returnTypeFullName =
operation.ReturnType.ToStructuredType()?.FullTypeName() ??
operation.ReturnType.FullName();
AddRelatedType(returnTypeFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(returnTypeFullName,
out SchemaTypeModel referencedSchemaTypeModel) &&
!referencedSchemaTypeModel.IsSelected)
{
referencedSchemaTypeModel.IsSelected = true;
}
}
// Check if parameter types of associated bound operations has been selected.
IEnumerable <IEdmOperationParameter> parameters = operation.Parameters;
foreach (var parameter in parameters)
{
if (parameter.Type.ToStructuredType() != null || parameter.Type.IsEnum())
{
string parameterFullName =
parameter.Type.ToStructuredType()?.FullTypeName() ??
parameter.Type.FullName();
AddRelatedType(parameterFullName, structuredType.FullTypeName());
if (SchemaTypeModelMap.TryGetValue(parameterFullName,
out SchemaTypeModel model) && !model.IsSelected)
{
model.IsSelected = true;
}
}
}
}
}
}
else if (!schemaTypeModel.IsSelected)
{
// automatically deselect related types for deselected type
if (RelatedTypes.TryGetValue(schemaTypeModel.Name, out ICollection <string> relatedTypes))
{
foreach (var relatedType in relatedTypes)
{
if (SchemaTypeModelMap.TryGetValue(relatedType,
out SchemaTypeModel relatedSchemaTypeModel) &&
relatedSchemaTypeModel.IsSelected)
{
relatedSchemaTypeModel.IsSelected = false;
}
}
}
// deselect all related bound operations
foreach (var boundOperation in schemaTypeModel.BoundOperations)
{
boundOperation.IsSelected = false;
}
}
if (this.View is SchemaTypes view)
{
view.SelectedSchemaTypesCount.Text = SchemaTypes.Count(x => x.IsSelected).ToString(CultureInfo.InvariantCulture);
}
};
// load bound operations that require the schema type
var boundOperationsToLoad = boundOperations
.Where(x => x.Key == schemaType || x.Key.AsElementType() == schemaType)
.ToDictionary(x => x.Key, x => x.Value);
LoadBoundOperations(schemaTypeModel, boundOperationsToLoad,
ExcludedSchemaTypeNames.ToList(), SchemaTypeModelMap);
toLoad.Add(schemaTypeModel);
schemaTypeModel.IsSelected = true;
SchemaTypeModelMap.Add(schemaType.FullTypeName(), schemaTypeModel);
}
SchemaTypes = toLoad.OrderBy(o => o.Name).ToList();
_schemaTypesCount = SchemaTypes.Count();
_boundOperationsCount = SchemaTypes.Where(x => x?.BoundOperations?.Any() == true)
.SelectMany(x => x.BoundOperations).Count();
}
internal TypeData (string typeName, string fullTypeName, string xmlType, SchemaTypes schemaType, TypeData listItemTypeData)
{
this.elementName = xmlType;
this.typeName = typeName;
this.fullTypeName = fullTypeName.Replace ('+', '.');
this.listItemTypeData = listItemTypeData;
this.sType = schemaType;
this.hasPublicConstructor = true;
LookupTypeConvertor ();
}
