public void AddCoreSchemaIfNeeded(ModelErrors errors)
{
if (this.FindDataServices("Edm").Count == 0)
{
this.AddCoreSchema(errors);
}
}
public void AddCoreSchema(ModelErrors errors)
{
if (string.Equals(this.Version, "1.0", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV3(this, errors);
}
else if (string.Equals(this.Version, "1.1", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV3(this, errors);
}
else if (string.Equals(this.Version, "1.2", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV3(this, errors);
}
else if (string.Equals(this.Version, "2.0", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV3(this, errors);
}
else if (string.Equals(this.Version, "3.0", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV3(this, errors);
}
else if (string.Equals(this.Version, "4.0", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV4(this, errors);
}
else if (string.Equals(this.Version, "4.01", StringComparison.InvariantCulture))
{
CsdlSchemaModel.AddCoreV4(this, errors);
}
else
{
errors.AddErrorOrThrow($"Unknown Version '{this.Version}'.", string.Empty, ModelException.Factory);
}
}
public static void AddErrorXmlParsing(this ModelErrors errors, string msg, Func <ModelErrorInfo, Exception> generator, params XObject[] args)
{
if (errors != null && errors.Errors == null)
{
// fast ignorance
return;
}
var mi = new ModelErrorInfo()
{
Text = msg, Location = ""
};
if (args.Length > 0)
{
var sb = new StringBuilder();
foreach (var o in args)
{
if ((object)o == null)
{
continue;
}
if (o is XElement element)
{
if (sb.Length > 0)
{
sb.Append(" - ");
}
sb.Append(element.Name.ToString());
}
else if (o is XAttribute attribute)
{
if (sb.Length > 0)
{
sb.Append(" - ");
}
sb.Append(attribute.Name.ToString());
}
else
{
}
}
mi.Location = sb.ToString();
}
if ((object)errors == null)
{
if (generator == null)
{
throw new ModelException(msg, new ModelErrors(mi));
}
else
{
throw (generator(mi));
}
}
else
{
errors.Errors?.Add(mi);
}
}
public EdmxModel Read(StreamReader streamReader, bool freeze, ModelErrors errors)
{
var xDoc = XDocument.Load(XmlReader.Create(streamReader, new XmlReaderSettings()
{
CloseInput = true,
IgnoreComments = true,
IgnoreWhitespace = true
}));
return(this.Read(xDoc, freeze, errors));
}
public void ResolveNames(ModelErrors errors)
{
if (this.FindDataServices("Edm").Count == 0)
{
this.AddCoreSchemaIfNeeded(errors);
}
foreach (var schema in this.DataServices)
{
schema.ResolveNames(errors);
}
}
public List <QuerySourceField> LoadCustomQuerySourceFields(string connectionString, string customQueryDefinition)
{
var result = new List <QuerySourceField>();
var dataTypeAdaptor = new DB2SupportDataType();
try
{
using (var transaction = new TransactionScope(TransactionScopeOption.RequiresNew))
{
using (var conn = new DB2Connection(connectionString))
{
conn.Open();
var command = new DB2Command(customQueryDefinition, conn);
command.CommandType = CommandType.Text;
var reader = command.ExecuteReader(CommandBehavior.SchemaOnly);
var schema = reader.GetSchemaTable();
for (int i = 0; i < schema.Rows.Count; i++)
{
string dataType = reader.GetDataTypeName(i);
result.Add(
new QuerySourceField
{
Name = schema.Rows[i]["ColumnName"].ToString() ?? "",
DataType = dataType,
IzendaDataType = dataTypeAdaptor.GetIzendaDataType(dataType),
AllowDistinct = dataTypeAdaptor.GetAllowDistinct(dataType),
ExtendedProperties = "",
Position = Convert.ToInt32(schema.Rows[0]["ColumnOrdinal"].ToString())
}
);
}
}
}
}
catch (DB2Exception ex)
{
var errorMsgBuilder = new StringBuilder();
var modelErrors = new ModelErrors();
for (int i = 0; i < ex.Errors.Count; i++)
{
var error = ex.Errors[i];
errorMsgBuilder.AppendLine(error.Message);
}
modelErrors.AddError("CustomDefinition", errorMsgBuilder.ToString());
throw new IzendaModelException(modelErrors);
}
return(result);
}
public EdmxModel Read(XDocument xDoc, bool freeze, ModelErrors errors)
{
var result = this.ReadDocument(xDoc.Root, errors);
result.AddCoreSchemaIfNeeded(errors);
if (freeze)
{
result.Freeze();
}
this.ResolveNames(result, errors);
return(result);
}
public EdmxModel ReadDocument(XElement root, ModelErrors errors)
{
if (root.Name == EdmConstants.EdmxV3Document)
{
return(this.ReadEdmxDocument(root, EdmConstants.EdmxV3, errors));
}
if (root.Name == EdmConstants.EdmxV4Document)
{
return(this.ReadEdmxDocument(root, EdmConstants.EdmxV4, errors));
}
errors.AddErrorXmlParsing("root", null, root);
return(null);
}
public static bool SetOwnerWithChildren <TThis, TOwner>(this TThis that, ref TOwner thisPropertyOwner, TOwner value, Func <TOwner, IList <TThis> > getChildren)
where TThis : class, IFreezable, IContainerNamedReferences
where TOwner : class
{
if (ReferenceEquals(thisPropertyOwner, value))
{
return(false);
}
if (!(thisPropertyOwner is null))
{
that.ThrowIfFrozen();
}
var oldValue = thisPropertyOwner;
thisPropertyOwner = value;
if (!(oldValue is null))
{
var lst = getChildren(oldValue);
lst.Remove(that);
}
if (!(value is null))
{
var lst = getChildren(value);
var cnt = lst.Count;
if (cnt == 0)
{
lst.Add(that);
}
else
{
if (cnt > 0)
{
if (ReferenceEquals(lst[cnt - 1], that))
{
// already added
}
else
{
var pos = lst.IndexOf(that);
if (pos < 0)
{
lst.Add(that);
}
}
}
}
that.ResolveNamedReferences(ModelErrors.GetIgnorance());
}
return(true);
}
public void ResolveNames(ModelErrors errors)
{
foreach (var entityType in this.EntityType)
{
entityType.ResolveNames(errors);
}
foreach (var entityContainer in this.EntityContainer)
{
entityContainer.ResolveNames(errors);
}
foreach (var association in this.Association)
{
association.ResolveNames(errors);
}
}
public async Task <IActionResult> AddAdmin(string className, UserToAdd userToAdd)
{
var result = await UserService.AddClassroomAdminAsync
(
className,
userToAdd.UserName
);
if (result)
{
return(RedirectToAction("Admins"));
}
else
{
ModelErrors.AddError("UserName", "User not found. (Did the user register?)");
return(View(userToAdd));
}
}
/// <summary>
/// MÉTODO QUE AGREGA UN ERROR AL DICCIONARIO DE ERRORES
/// </summary>
/// <param name="key">KEY A LA QUE SE AGREGARÁ EL ERROR</param>
/// <param name="errorText">TEXTO DEL ERROR</param>
/// <returns></returns>
public IntegrationServiceResponse <T> AddError(string key, string errorText)
{
if (ModelErrors.ContainsKey(key))
{
var error = ModelErrors[key];
error.Add(errorText);
}
else
{
ModelErrors.Add(key, new List <string> {
errorText
});
}
this.IsValid = false;
return(this);
}
public async Task <IActionResult> AddStudent(string sectionName, UserToAdd userToAdd)
{
var result = await UserService.AddSectionStudentAsync
(
ClassroomName,
sectionName,
userToAdd.UserName
);
if (result)
{
return(RedirectToAction("Students"));
}
else
{
ModelErrors.AddError("UserName", "User not found. (Did the user register?)");
return(View(userToAdd));
}
}
public static CsdlSchemaModel AddCoreV4(EdmxModel edmxModel, ModelErrors errors)
{
CsdlSchemaModel schemaModel = new CsdlSchemaModel();
schemaModel.Namespace = "Edm";
edmxModel.DataServices.Add(schemaModel);
// TODO: V4 Scalar
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Binary", new CsdlScalarTypeModelTarget(typeof(byte[]))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Boolean", new CsdlScalarTypeModelTarget(typeof(bool))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Byte", new CsdlScalarTypeModelTarget(typeof(byte))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "DateTime", new CsdlScalarTypeModelTarget(typeof(System.DateTime))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Decimal", new CsdlScalarTypeModelTarget(typeof(decimal))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Double", new CsdlScalarTypeModelTarget(typeof(double))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Single", new CsdlScalarTypeModelTarget(typeof(Single))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Guid", new CsdlScalarTypeModelTarget(typeof(Guid))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Int16", new CsdlScalarTypeModelTarget(typeof(short))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Int32", new CsdlScalarTypeModelTarget(typeof(int))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Int64", new CsdlScalarTypeModelTarget(typeof(long))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "SByte", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "String", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Time", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "DateTimeOffset", new CsdlScalarTypeModelTarget(typeof(System.DateTimeOffset))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Geography", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyPoint", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyLineString", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyPolygon", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyMultiPoint", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyMultiLineString", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyMultiPolygon", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeographyCollection", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Geometry", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryPoint", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryLineString", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryPolygon", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryMultiPoint", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryMultiLineString", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryMultiPolygon", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "GeometryCollection", new CsdlScalarTypeModelTarget(typeof(string))));
schemaModel.AddScalarType(new CsdlScalarTypeModel("Edm", "Stream", new CsdlScalarTypeModelTarget(typeof(string))));
return(schemaModel);
}
public EdmxModel ReadEdmxDocument(XElement rootEdmx, EdmConstants.EdmxConstants edmxConstants, ModelErrors errors)
{
// http://www.odata.org/documentation/odata-version-3-0/common-schema-definition-language-csdl/
var edmxModel = new EdmxModel();
if (rootEdmx.HasAttributes)
{
foreach (var attr in rootEdmx.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrVersion)
{
edmxModel.Version = attr.Value;
}
else if (CheckAndAddAnnotation(attr, edmxModel))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, rootEdmx, attr);
}
}
}
var references = new List <string>();
foreach (var ele1 in rootEdmx.Elements())
{
if (ele1.Name == edmxConstants.EdmxAnnotationsReference)
{
// TODO: AnnotationsReference
}
else if (ele1.Name == edmxConstants.EdmxReference)
{
if (ele1.HasAttributes)
{
var url = ele1.Attribute(EdmConstants.AttrUrl).Value;
if (!string.IsNullOrEmpty(url))
{
edmxModel.References.Add(url);
references.Add(url);
}
}
}
else if (ele1.Name == edmxConstants.EdmxDataServices)
{
if (ele1.HasAttributes)
{
// TODO edmxConstants.EdmxDataServices Attributes
edmxModel.DataServiceVersion = ele1.Attribute(edmxConstants.AttrDataServiceVersion).Value;
}
foreach (var eleSchema in ele1.Elements())
{
if (eleSchema.Name == EdmConstants.CSDL1_0.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL1_0, errors);
}
else if (eleSchema.Name == EdmConstants.CSDL1_1.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL1_1, errors);
}
else if (eleSchema.Name == EdmConstants.CSDL1_2.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL1_2, errors);
}
else if (eleSchema.Name == EdmConstants.CSDL2_0.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL2_0, errors);
}
else if (eleSchema.Name == EdmConstants.CSDL3_0.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL3_0, errors);
}
else if (eleSchema.Name == EdmConstants.CSDL4_0.Schema)
{
ReadCSDLDocument(edmxModel, eleSchema, EdmConstants.CSDL4_0, errors);
}
else
{
errors.AddErrorXmlParsing("ReadEdmxDocument-EdmxDataServices", null, ele1, eleSchema);
}
}
}
else
{
errors.AddErrorXmlParsing("ReadEdmxDocument", null, ele1);
}
}
// <edmx:DataServices xmlns:m="http://schemas.microsoft.com/ado/2007/08/dataservices/metadata" m:DataServiceVersion="2.0">
return(edmxModel);
}
public void BuildAssociation(EdmxModel edmxModel, ModelSchema modelSchema, CsdlAssociationModel association, MetaModelBuilder metaModelBuilder, ModelErrors errors)
{
foreach (var associationEnd in association.AssociationEnd)
{
if (associationEnd.TypeModel is null)
{
if (!(associationEnd.TypeName is null))
{
errors.AddErrorOrThrow($"{associationEnd.TypeName} not found.", $"{association.FullName} - {associationEnd.FullName}");
}
continue;
}
//associationEnd.GetMultiplicity()
//var roleName = associationEnd.RoleName;
//associationEnd.TypeModel
}
var lstOneOptional = association.AssociationEnd.Where(end => end.GetMultiplicity() == MultiplicityKind.OneOptional).ToList();
var lstOne = association.AssociationEnd.Where(end => end.GetMultiplicity() == MultiplicityKind.One).ToList();
var lstMultiple = association.AssociationEnd.Where(end => end.GetMultiplicity() == MultiplicityKind.Multiple).ToList();
if ((lstOneOptional.Count == 1) && (lstMultiple.Count == 1))
{
var masterEnd = lstOneOptional[0];
var foreignEnd = lstMultiple[0];
var lstMasterProperty = masterEnd.TypeModel.NavigationProperty.Where(np => np.FromRoleName == masterEnd.RoleName).ToList();
var lstForeignProperty = foreignEnd.TypeModel.NavigationProperty.Where(np => np.FromRoleName == foreignEnd.RoleName).ToList();
if ((lstMasterProperty.Count == 1) && (lstForeignProperty.Count == 1))
{
//modelSchema.ComplexTypes.FindByKey2(lstMasterProperty[0])
//modelSchema.ComplexTypes.FindByKey2(lstMasterProperty[0].TypeModel.Nam)
var result = metaModelBuilder.CreateModelRelation(
association.Name,
association.FullName,
lstMasterProperty[0].ToRoleModel.TypeName,
lstMasterProperty[0].Name,
lstForeignProperty[0].ToRoleModel.TypeName,
lstForeignProperty[0].Name
);
modelSchema.Relations.Add(result);
}
}
}
public void ReadCsdlEntityType(
CsdlSchemaModel schemaModel,
XElement eleEntityType,
EdmConstants.CSDLConstants csdlConstants,
ModelErrors errors)
{
var entityType = new CsdlEntityTypeModel();
if (eleEntityType.HasAttributes)
{
foreach (var attr in eleEntityType.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
entityType.Name = attr.Value;
}
else if (attr.Name == EdmConstants.AttrBaseType)
{
entityType.BaseType = attr.Value;
}
else if (attr.Name == EdmConstants.AttrAbstract)
{
entityType.Abstract = ConvertToBoolean(attr.Value);
}
else if (attr.Name == EdmConstants.AttrOpenType)
{
entityType.OpenType = ConvertToBoolean(attr.Value);
}
else if (attr.Name == EdmConstants.AttrHasStream)
{
entityType.HasStream = ConvertToBoolean(attr.Value);
}
else if (CheckAndAddAnnotation(attr, entityType))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, attr);
}
}
}
schemaModel.EntityType.Add(entityType);
foreach (var ele2 in eleEntityType.Elements())
{
if (ele2.Name == csdlConstants.Key)
{
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, attr);
}
}
}
foreach (var ele3 in ele2.Elements())
{
var propertyRef = new CsdlPrimaryKeyModel();
if (ele3.Name == csdlConstants.PropertyRef)
{
if (ele3.HasAttributes)
{
foreach (var attr in ele3.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
propertyRef.Name = attr.Value;
}
else if (CheckAndAddAnnotation(attr, propertyRef))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3, attr);
}
}
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3);
}
entityType.Keys.Add(propertyRef);
}
}
else if (ele2.Name == csdlConstants.Property)
{
var property = new CsdlPropertyModel();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
property.Name = attr.Value;
}
else if (attr.Name == EdmConstants.AttrType)
{
property.TypeName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrNullable)
{
property.Nullable = ConvertToBoolean(attr.Value, true);
}
else if (attr.Name == EdmConstants.AttrMaxLength)
{
property.MaxLength = ConvertToShort(attr.Value, 0);
}
else if (attr.Name == EdmConstants.AttrFixedLength)
{
property.FixedLength = ConvertToBoolean(attr.Value, false);
}
else if (attr.Name == EdmConstants.AttrPrecision)
{
property.Precision = ConvertToByte(attr.Value, 0);
}
else if (attr.Name == EdmConstants.AttrScale)
{
property.Scale = ConvertToByte(attr.Value, 0);
}
else if (attr.Name == EdmConstants.AttrUnicode)
{
property.Unicode = ConvertToBoolean(attr.Value, true);
}
else if (attr.Name == EdmConstants.AttrCollation)
{
property.Collation = attr.Value;
}
else if (attr.Name == EdmConstants.AttrSRID)
{
property.SRID = attr.Value;
}
else if (attr.Name == EdmConstants.AttrDefaultValue)
{
property.DefaultValue = attr.Value;
}
else if (attr.Name == EdmConstants.AttrConcurrencyMode)
{
property.ConcurrencyMode = attr.Value;
}
else if (CheckAndAddAnnotation(attr, property))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, attr);
}
}
}
entityType.Property.Add(property);
foreach (var ele3 in ele2.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3);
}
}
}
else if (ele2.Name == csdlConstants.NavigationProperty)
{
var navigationProperty = new CsdlNavigationPropertyModel();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
navigationProperty.Name = attr.Value;
}
else if (attr.Name == EdmConstants.AttrRelationship)
{
navigationProperty.RelationshipName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrFromRole)
{
navigationProperty.FromRoleName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrToRole)
{
navigationProperty.ToRoleName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrContainsTarget)
{
navigationProperty.ContainsTarget = ConvertToBoolean(attr.Value, false);
}
else if (attr.Name == EdmConstants.AttrType)
{
navigationProperty.TypeName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrPartner)
{
navigationProperty.PartnerName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrNullable)
{
navigationProperty.Nullable = ConvertToBoolean(attr.Value, true);
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, attr);
}
}
}
entityType.NavigationProperty.Add(navigationProperty);
foreach (var ele3 in ele2.Elements())
{
var referentialConstraint = new CsdlReferentialConstraintV4Model();
//var propertyRef = new CsdlPrimaryKeyModel();
if (ele3.Name == csdlConstants.ReferentialConstraint)
{
if (ele3.HasAttributes)
{
foreach (var attr in ele3.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrProperty)
{
referentialConstraint.PropertyName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrReferencedProperty)
{
referentialConstraint.ReferencedPropertyName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, referentialConstraint))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3, attr);
}
}
}
foreach (var ele4 in ele3.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3, ele4);
}
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2, ele3);
}
navigationProperty.ReferentialConstraint.Add(referentialConstraint);
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityType, ele2);
}
}
}
public CommitmentsRestClientTestsFixture WithError(string field, string message)
{
ModelErrors.Add(new ErrorDetail(field, message));
return(this);
}
public ModelScalarType BuildScalarType(EdmxModel edmxModel, ModelSchema modelSchema, CsdlScalarTypeModel scalarTypeModel, MetaModelBuilder metaModelBuilder, ModelErrors errors)
{
if (string.Equals(scalarTypeModel.Namespace, "Edm", StringComparison.Ordinal))
{
return(null);
}
//
#warning BuildScalarType - when does this happen?
var name = scalarTypeModel.Name;
var fullName = scalarTypeModel.FullName;
ModelScalarType result = new ModelScalarType {
Name = name,
ExternalName = fullName
};
modelSchema.ScalarTypes.Add(result);
return(result);
}
public void ReadCsdlEntityContainer(
CsdlSchemaModel schemaModel,
XElement eleEntityContainer,
EdmConstants.CSDLConstants csdlConstants,
ModelErrors errors
)
{
var entityContainer = new CsdlEntityContainerModel();
if (eleEntityContainer.HasAttributes)
{
foreach (var attr in eleEntityContainer.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
entityContainer.Name = attr.Value;
}
else if (attr.Name == csdlConstants.AttrIsDefaultEntityContainer)
{
entityContainer.IsDefaultEntityContainer = ConvertToBoolean(attr.Value);
}
else if (CheckAndAddAnnotation(attr, entityContainer))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, attr);
}
}
}
foreach (var ele2 in eleEntityContainer.Elements())
{
if (ele2.Name == csdlConstants.EntitySet)
{
var entitySet = new CsdlEntitySetModel();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
entitySet.Name = attr.Value;
}
else if (attr.Name == EdmConstants.AttrEntityType)
{
entitySet.EntityTypeName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, entitySet))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, attr);
}
}
}
entityContainer.EntitySet.Add(entitySet);
foreach (var ele3 in ele2.Elements())
{
if (ele3.Name == csdlConstants.NavigationPropertyBinding)
{
var navigationPropertyBinding = new CsdlNavigationPropertyBindingModel();
if (ele3.HasAttributes)
{
foreach (var attr in ele3.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrPath)
{
navigationPropertyBinding.PathName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrTarget)
{
navigationPropertyBinding.TargetName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, navigationPropertyBinding))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, attr);
}
}
}
entitySet.NavigationPropertyBinding.Add(navigationPropertyBinding);
foreach (var ele4 in ele3.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, ele3, ele4);
}
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, ele3);
}
}
}
else if (ele2.Name == csdlConstants.AssociationSet)
{
var associationSet = new CsdlAssociationSetModel();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
associationSet.Name = attr.Value;
}
else if (attr.Name == EdmConstants.AttrAssociation)
{
associationSet.AssociationName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, associationSet))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, attr);
}
}
}
entityContainer.AssociationSet.Add(associationSet);
foreach (var ele3 in ele2.Elements())
{
if (ele3.Name == csdlConstants.End)
{
var associationSetEndModel = new CsdlAssociationSetEndModel();
if (ele3.HasAttributes)
{
foreach (var attr in ele3.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrRole)
{
associationSetEndModel.RoleName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrEntitySet)
{
associationSetEndModel.EntitySetName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, associationSet))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, attr);
}
}
}
associationSet.End.Add(associationSetEndModel);
foreach (var ele4 in ele3.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, ele3, ele4);
}
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2, ele3);
}
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleEntityContainer, ele2);
}
}
schemaModel.EntityContainer.Add(entityContainer);
}
public EdmxModel Read(string location, bool freeze, ModelErrors errors)
{
var streamReader = this.MetadataResolver.Resolve(location);
return(this.Read(streamReader, freeze, errors));
}
public void ReadCsdlAssociation(CsdlSchemaModel schemaModel, XElement eleAssociation, EdmConstants.CSDLConstants csdlConstants, ModelErrors errors)
{
var association = new CsdlAssociationModel();
if (eleAssociation.HasAttributes)
{
foreach (var attr in eleAssociation.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrName)
{
association.Name = attr.Value;
//} else if (attr.Name == csdlConstants.AttrIsDefaultEntityContainer) {
// association.IsDefaultEntityContainer = ConvertToBoolean(attr.Value);
}
else if (CheckAndAddAnnotation(attr, association))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, attr);
}
}
}
schemaModel.Association.Add(association);
// children
foreach (var ele2 in eleAssociation.Elements())
{
if (ele2.Name == csdlConstants.End)
{
var associationEnd = new CsdlAssociationEndModel();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrRole)
{
associationEnd.RoleName = attr.Value;
//} else if (attr.Name == EdmConstants.AttrEntitySet) {
// associationEnd.EntitySetName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrType)
{
associationEnd.TypeName = attr.Value;
}
else if (attr.Name == EdmConstants.AttrMultiplicity)
{
associationEnd.Multiplicity = attr.Value;
}
else if (CheckAndAddAnnotation(attr, associationEnd))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, attr);
}
}
}
association.AssociationEnd.Add(associationEnd);
foreach (var ele3 in ele2.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3);
}
}
}
else if (ele2.Name == csdlConstants.ReferentialConstraint)
{
var referentialConstraint = new CsdlReferentialConstraintV3Model();
if (ele2.HasAttributes)
{
foreach (var attr in ele2.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (CheckAndAddAnnotation(attr, referentialConstraint))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, attr);
}
}
}
foreach (var ele3 in ele2.Elements())
{
var isPrincipal = (ele3.Name == csdlConstants.Principal);
var isDependent = (ele3.Name == csdlConstants.Dependent);
if (isPrincipal || isDependent)
{
var referentialConstraintPartner = new CsdlReferentialConstraintPartnerV3Model();
if (ele3.HasAttributes)
{
foreach (var attr in ele3.Attributes())
{
if (attr.Name == EdmConstants.AttrRole)
{
referentialConstraintPartner.RoleName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, referentialConstraintPartner))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3, attr);
}
}
}
foreach (var ele4 in ele3.Elements())
{
if (ele4.Name == csdlConstants.PropertyRef)
{
var propertyRef = new CsdlPropertyRefModel();
if (ele4.HasAttributes)
{
foreach (var attr in ele4.Attributes())
{
if (attr.Name == EdmConstants.AttrName)
{
propertyRef.PropertyName = attr.Value;
}
else if (CheckAndAddAnnotation(attr, propertyRef))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3, ele4, attr);
}
}
}
foreach (var ele5 in ele4.Elements())
{
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3, ele4, ele5);
}
}
referentialConstraintPartner.PropertyRef.Add(propertyRef);
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3, ele4);
}
}
if (isPrincipal)
{
referentialConstraint.Principal = referentialConstraintPartner;
}
else if (isDependent)
{
referentialConstraint.Dependent = referentialConstraintPartner;
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3);
}
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2, ele3);
}
}
association.ReferentialConstraint.Add(referentialConstraint);
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, eleAssociation, ele2);
}
}
}
public CsdlSchemaModel ReadCSDLDocument(EdmxModel edmxModel, XElement eleSchema, EdmConstants.CSDLConstants csdlConstants, ModelErrors errors)
{
var schemaModel = new CsdlSchemaModel();
if (eleSchema.HasAttributes)
{
foreach (var attr in eleSchema.Attributes())
{
if (attr.IsNamespaceDeclaration)
{
//
}
else if (attr.Name == EdmConstants.AttrNamespace)
{
schemaModel.Namespace = attr.Value;
//} else if (attr.Name == csdlConstants.AttrIsDefaultEntityContainer) {
// association.IsDefaultEntityContainer = ConvertToBoolean(attr.Value);
}
else if (CheckAndAddAnnotation(attr, schemaModel))
{
}
else
{
errors.AddErrorXmlParsing("ReadCSDLDocument", null, null, eleSchema, attr);
}
}
}
edmxModel.DataServices.Add(schemaModel);
// children
foreach (var ele1 in eleSchema.Elements())
{
if (ele1.Name == csdlConstants.Annotations)
{
ReadCsdlAnnotations(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.Association)
{
ReadCsdlAssociation(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.ComplexType)
{
ReadCsdlComplexType(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.EntityContainer)
{
ReadCsdlEntityContainer(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.EntityType)
{
ReadCsdlEntityType(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.EnumType)
{
ReadCsdlEnumType(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.Function)
{
ReadCsdlFunction(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.Using)
{
ReadCsdlUsing(schemaModel, ele1, csdlConstants, errors);
}
else if (ele1.Name == csdlConstants.ValueTerm)
{
ReadCsdlValueTerm(schemaModel, ele1, csdlConstants, errors);
}
else
{
throw new NotImplementedException(ele1.Name.ToString());
}
}
//errors.AddError("ReadCSDLDocument", ele1, ele2, ele3, ele4, attr);
return(schemaModel);
}
public void Mapping_OData_SQL_ProjectOnlinemetadata_Test()
{
var testCfg = OfaSchlupfer.TestCfg.Get();
var repCSProjectServer = testCfg.ProjectServer.CreateWithSuffix("/_api/ProjectData/[en-us]");
repCSProjectServer.AuthenticationMode = "SPOIDCRL";
var srcPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\ProjectOnlinemetadata.xml");
IServiceCollection services = new ServiceCollection();
services.AddLogging((builder) => { builder.AddDebug(); });
services.AddOfaSchlupferModel();
services.AddOfaSchlupferEntity();
services.AddOfaSchlupferODataRepository();
services.AddSqlRepository();
services.AddServiceClientCredentials((builder) => { });
//services.AddHttpClient((builder) => { });
var serviceProvider = services.BuildServiceProvider();
using (var scope = serviceProvider.CreateScope()) {
var scopedServiceProvider = scope.ServiceProvider;
var modelRoot = scopedServiceProvider.GetRequiredService <ModelRoot>();
var modelRepositorySource = modelRoot.CreateRepository("Source", "OData");
var modelDefininition = modelRepositorySource.CreateModelDefinition(null);
Assert.Same(modelDefininition, modelRepositorySource.ModelDefinition);
modelDefininition.MetaData = System.IO.File.ReadAllText(srcPath);
var oDataRepositorySource = (ODataRepositoryImplementation)modelRepositorySource.GetReferenceRepositoryModel();
Assert.NotNull(oDataRepositorySource);
Assert.Same(modelRepositorySource, oDataRepositorySource.Owner);
Assert.NotNull(oDataRepositorySource.GetEdmxModel());
var modelSchemaSource = modelRepositorySource.GetModelSchema(null, null);
Assert.NotNull(modelSchemaSource);
EntitySchema entitySchema = modelRepositorySource.ModelSchema.GetEntitySchema();
Assert.NotNull(entitySchema);
var modelRepositoryTarget = modelRoot.CreateRepository("Target", "SQL");
var sqlRepositoryTarget = (SqlRepositoryImplementation)modelRepositoryTarget.GetReferenceRepositoryModel();
sqlRepositoryTarget.ConnectionString = testCfg.SQLConnectionString;
Assert.NotNull(sqlRepositoryTarget);
{
var metaModelBuilder = new MetaModelBuilder();
var errors = new ModelErrors();
var modelSchemaTarget = modelRepositoryTarget.GetModelSchema(metaModelBuilder, errors);
Assert.NotNull(modelSchemaTarget);
if (errors.HasErrors())
{
this.output.WriteLine(errors.ToString());
}
Assert.False(errors.HasErrors());
Assert.True(sqlRepositoryTarget.ModelDatabase.Tables.Count > 0);
foreach (var table in sqlRepositoryTarget.ModelDatabase.Tables)
{
Assert.True(table.Columns.Count > 0);
}
Assert.NotNull(modelSchemaTarget);
Assert.True(modelSchemaTarget.Entities.Count > 0);
Assert.True(modelSchemaTarget.ComplexTypes.Count > 0);
foreach (var modelEntityTarget in modelRepositoryTarget.ModelSchema.Entities)
{
Assert.NotNull(modelEntityTarget.EntityTypeName);
Assert.NotNull(modelEntityTarget.EntityType);
}
foreach (var modelComplexTypesTarget in modelRepositoryTarget.ModelSchema.ComplexTypes)
{
if (modelComplexTypesTarget.Properties.Count == 0)
{
var message = $"{modelComplexTypesTarget.Name} has no properties.";
this.output.WriteLine(message);
Assert.Equal("Error", message);
}
if (modelComplexTypesTarget.Indexes.Count == 0)
{
var message = $"{modelComplexTypesTarget.Name} has no indexes.";
this.output.WriteLine(message);
Assert.Equal("Error", message);
}
}
}
{
var serializeSettings = new Newtonsoft.Json.JsonSerializerSettings {
TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple,
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Objects
};
serializeSettings.Converters.Add(new OfaSchlupfer.MSSQLReflection.Model.SqlNameJsonConverter());
//serializeSettings.Converters.Add(new OfaSchlupfer.MSSQLReflection.Model.ModelSqlTableJsonConverter());
//serializeSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();
//serializeSettings.TraceWriter = new XunitTraceWriter(output);
try {
var schemaAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(sqlRepositoryTarget.ModelDatabase, Newtonsoft.Json.Formatting.Indented, serializeSettings);
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\Mapping_OData_SQL_ProjectOnlinemetadata_Test-target-ModelDatabase-Before.json");
System.IO.File.WriteAllText(outputPath, schemaAsJson);
} catch (Exception error) {
this.output.WriteLine(error.ToString());
throw;
}
}
{
var mappingModelRepositorySourceTarget = modelRoot.CreateMapping("SourceTarget", modelRepositorySource, modelRepositoryTarget);
var mappingModelSchema = mappingModelRepositorySourceTarget.CreateMappingModelSchema("SourceTarget", modelRepositorySource.ModelSchema, modelRepositoryTarget.ModelSchema, true, false, "");
var mappingModelBuilder = new MappingModelBuilder {
MappingModelRepository = mappingModelRepositorySourceTarget
};
var errors = new ModelErrors();
mappingModelBuilder.EnabledForCreatedMappings = true;
mappingModelBuilder.Comment = "Mapping_OData_SQL_ProjectOnlinemetadata_Test";
mappingModelBuilder.Build(errors);
if (errors.HasErrors())
{
this.output.WriteLine(errors.ToString());
}
Assert.False(errors.HasErrors());
foreach (var modelEntityTarget in modelRepositoryTarget.ModelSchema.Entities)
{
Assert.NotNull(modelEntityTarget.EntityTypeName);
Assert.NotNull(modelEntityTarget.EntityType);
}
foreach (var modelComplexTypesTarget in modelRepositoryTarget.ModelSchema.ComplexTypes)
{
if (modelComplexTypesTarget.Properties.Count == 0)
{
var message = $"{modelComplexTypesTarget.Name} has no properties";
this.output.WriteLine(message);
Assert.Equal("Error", message);
}
}
}
{
#warning HEEEEEEEEEEEEEEERE
var metaModelBuilder = new MetaModelBuilder();
var errors = new ModelErrors();
var sqlModelSchemaBuilder = new SqlModelSchemaBuilder();
sqlModelSchemaBuilder.BuildModelSqlDatabase(
modelRepositoryTarget.ModelSchema,
sqlRepositoryTarget.ModelDatabase,
metaModelBuilder,
errors
);
if (errors.HasErrors())
{
this.output.WriteLine(errors.ToString());
}
Assert.False(errors.HasErrors());
}
var cred = new SharePointOnlineServiceClientCredentials(repCSProjectServer, null);
var oDataClient = new ODataServiceClient(new Uri(repCSProjectServer.GetUrlNormalized()), cred, null)
{
ModelRepository = modelRepositorySource
};
var oDataRequest = oDataClient.Query("Projects");
// oDataClient.ConnectionString = repCSProjectServer;
// oDataClient.SetConnectionString(repCSProjectServer, "/_api/ProjectData/[en-us]");
var srcPathData = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\ProjectOnlineData-Projects.json");
var responceContentString = System.IO.File.ReadAllText(srcPathData);
var operationResponse = new AzureOperationResponse <ODataRequest> {
Request = new System.Net.Http.HttpRequestMessage(),
Response = new System.Net.Http.HttpResponseMessage()
{
Content = new System.Net.Http.StringContent(responceContentString)
}
};
ODataDeserializtion d = new ODataDeserializtion(oDataRequest, oDataClient);
var deserializeResult = d.Deserialize(responceContentString);
Assert.NotNull(deserializeResult);
Assert.IsType <List <IEntity> >(deserializeResult);
var lstEntity = deserializeResult as List <IEntity>;
Assert.Equal(60, lstEntity.Count);
{
var serializeSettings = new Newtonsoft.Json.JsonSerializerSettings {
TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple,
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto
};
var schemaAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(modelRoot, Newtonsoft.Json.Formatting.Indented, serializeSettings);
try {
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\Mapping_OData_SQL_ProjectOnlinemetadata_Test-root.json");
System.IO.File.WriteAllText(outputPath, schemaAsJson);
} catch {
throw;
}
}
{
var serializeSettings = new Newtonsoft.Json.JsonSerializerSettings {
TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple,
TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Objects
};
serializeSettings.Converters.Add(new OfaSchlupfer.MSSQLReflection.Model.SqlNameJsonConverter());
//serializeSettings.Converters.Add(new OfaSchlupfer.MSSQLReflection.Model.ModelSqlTableJsonConverter());
//serializeSettings.ContractResolver = new Newtonsoft.Json.Serialization.DefaultContractResolver();
//serializeSettings.TraceWriter = new XunitTraceWriter(output);
try {
var schemaAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(sqlRepositoryTarget.ModelDatabase, Newtonsoft.Json.Formatting.Indented, serializeSettings);
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\Mapping_OData_SQL_ProjectOnlinemetadata_Test-target-ModelDatabase-After.json");
System.IO.File.WriteAllText(outputPath, schemaAsJson);
} catch (Exception error) {
this.output.WriteLine(error.ToString());
throw;
}
}
{
var errors = new ModelErrors();
//sqlRepositoryTarget.UpdateTargetSchema(errors);
var sqlScript = new StringBuilder();
sqlRepositoryTarget.GenerateUpdateSchemaSQL(errors, (name, sql) => {
sqlScript.Append($"-- start{name}\r\n{sql}\r\nGO\r\n-- endof:{name}\r\n\r\n");
});
if (errors.HasErrors())
{
this.output.WriteLine(errors.ToString());
}
Assert.False(errors.HasErrors());
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\Mapping_OData_SQL_ProjectOnlinemetadata_Test.sql");
System.IO.File.WriteAllText(outputPath, sqlScript.ToString());
}
}
}
public void ReadCsdlValueTerm(CsdlSchemaModel schemaModel, XElement ele1, EdmConstants.CSDLConstants csdlConstants, ModelErrors errors)
{
// TODO: ValueTerm
throw new NotImplementedException(ele1.Name.ToString());
}
public override ModelSchema GetModelSchema(MetaModelBuilder metaModelBuilder, ModelErrors errors)
{
var result = this.ModelSchema;
if (result is null)
{
if (this._EdmxModel != null)
{
var builder = new EdmxModelSchemaBuilder();
result = new ModelSchema();
builder.Build(this._EdmxModel, result, metaModelBuilder, errors);
#warning result.Freeze();
this.ModelSchema = result;
}
}
return(result);
}
public void EdmxModelBuilder_v3northwindmetadata_Test()
{
var testCfg = OfaSchlupfer.TestCfg.Get();
IServiceCollection services = new ServiceCollection();
services.AddLogging((builder) => { builder.AddDebug(); });
var serviceProvider = services.BuildServiceProvider();
var srcPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\v3northwindmetadata.xml");
var cachedMetadataResolver = new CachedMetadataResolver();
cachedMetadataResolver.SetDynamicResolution((location) => new System.IO.StreamReader(location));
var edmReader = new EdmReader();
edmReader.MetadataResolver = cachedMetadataResolver;
var errors = new ModelErrors();
var edmxModel = edmReader.Read(srcPath, true, errors);
if (errors.HasErrors())
{
output.WriteLine(errors.ToString());
Assert.Equal("Error Read HasErrors", errors.ToString());
}
EdmxModelSchemaBuilder edmxModelBuilder = new EdmxModelSchemaBuilder();
var modelSchema = edmxModelBuilder.Build(edmxModel, null, null, errors);
if (errors.HasErrors())
{
output.WriteLine(errors.ToString());
Assert.Equal("Error Builder HasErrors", errors.ToString());
}
var defaultEntityContainer = edmxModel.DataServices.SelectMany(_ => _.EntityContainer).FirstOrDefault(_ => _.IsDefaultEntityContainer);
Assert.Equal(defaultEntityContainer.EntitySet.Count, modelSchema.Entities.Count);
foreach (var entity in modelSchema.Entities)
{
if (entity.EntityType == null)
{
throw new Xunit.Sdk.XunitException($"{entity.Name} has no EntityType.");
}
Assert.True(entity.EntityType.Properties.Count > 0);
foreach (var property in entity.EntityType.Properties)
{
Assert.NotNull(property.Name);
Assert.NotNull(property.Type);
//if (string.IsNullOrEmpty(property.Name)) {
// property.Type
//}
}
foreach (var navigationProperty in entity.EntityType.NavigationProperty)
{
Assert.NotNull(navigationProperty.Name);
Assert.NotNull(navigationProperty.ExternalName);
Assert.NotNull(navigationProperty.ItemType);
}
}
}
public void SqlRepositoryImplementation_ReadSQLSchema_Test()
{
var testCfg = OfaSchlupfer.TestCfg.Get();
var repSQLConnectionString = testCfg.SQLConnectionString;
IServiceCollection services = new ServiceCollection();
services.AddLogging((builder) => { builder.AddDebug(); });
var serviceProvider = services.BuildServiceProvider();
var modelRoot = new ModelRoot();
var modelRepository = new ModelRepository();
modelRepository.Name = "ProjectServerSQL";
modelRoot.Repositories.Add(modelRepository);
SqlRepositoryModel sqlRepository = new SqlRepositoryImplementation();
sqlRepository.ConnectionString = repSQLConnectionString;
modelRepository.ReferencedRepositoryModel = sqlRepository;
var errors = new ModelErrors();
MetaModelBuilder metaModelBuilder = new MetaModelBuilder();
sqlRepository.ReadSQLSchema(metaModelBuilder, errors);
if (errors.HasErrors())
{
output.WriteLine(errors.ToString());
}
Assert.False(errors.HasErrors());
Assert.NotNull(sqlRepository.ModelSchema);
Assert.True(sqlRepository.ModelSchema.ComplexTypes.Count > 0);
var entitySchema = sqlRepository.ModelSchema.GetEntitySchema();
Assert.NotNull(entitySchema);
{
var serializeSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializeSettings.TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple;
serializeSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
var schemaAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(sqlRepository.ModelSchema, Newtonsoft.Json.Formatting.Indented, serializeSettings);
try {
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\SqlRepositoryImplementation_ReadSQLSchema_Test_ModelSchema.json");
System.IO.File.WriteAllText(outputPath, schemaAsJson);
} catch {
throw;
}
}
{
var serializeSettings = new Newtonsoft.Json.JsonSerializerSettings();
serializeSettings.TypeNameAssemblyFormatHandling = Newtonsoft.Json.TypeNameAssemblyFormatHandling.Simple;
serializeSettings.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.Auto;
var schemaAsJson = Newtonsoft.Json.JsonConvert.SerializeObject(entitySchema, Newtonsoft.Json.Formatting.Indented, serializeSettings);
try {
string outputPath = System.IO.Path.Combine(testCfg.SolutionFolder, @"test\temp\SqlRepositoryImplementation_ReadSQLSchema_Test_EntitySchema.json");
System.IO.File.WriteAllText(outputPath, schemaAsJson);
} catch {
throw;
}
}
}
#pragma warning restore SA1107 // Code must not contain multiple statements on one line
/// <summary>
/// Gets or sets the type
/// </summary>
#warning kill this?
//[JsonIgnore]
//public ModelSqlElementType Type { get; set; }
public virtual void ResolveNamedReferences(ModelErrors errors)
{
}
public void ResolveNames(EdmxModel edmxModel, ModelErrors errors)
{
edmxModel.ResolveNames(errors);
}
