public void ShouldNotRejectSameSource() { DataContract source = new DataContract(Store); bool result = AggregationConnectionBuilder.CanAcceptSourceAndTarget(source, source); Assert.IsTrue(result); }
public void ShouldNotRejectSameLink() { DataContract source = new DataContract(Store); DataContract target = new DataContract(Store); DataContractBaseCanBeContainedOnContracts link = new DataContractBaseCanBeContainedOnContracts(source, target); ModelElementReference dataElement = new ModelElementReference(Store); dataElement.SetLinkedElement(link.Id); source.DataMembers.Add(dataElement); bool result = AggregationConnectionBuilder.CanAcceptSourceAndTarget(source, target); Assert.IsTrue(result); }
public void TestInitialize() { serviceProvider = new MockMappingServiceProvider(); attributes = new NameValueCollection(); attributes.Add("elementNameProperty", "Name"); #region Data Contract dcStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(DataContractDslDomainModel)); dcDomainModel = dcStore.GetDomainModel<DataContractDslDomainModel>(); dcTransaction = dcStore.TransactionManager.BeginTransaction(); dcModel = (DataContractModel)dcDomainModel.CreateElement(new Partition(dcStore), typeof(DataContractModel), null); dcModel.ProjectMappingTable = projectMappingTableName; dc = dcStore.ElementFactory.CreateElement(DataContract.DomainClassId) as DataContract; primitiveDataElement = dcStore.ElementFactory.CreateElement(PrimitiveDataType.DomainClassId) as PrimitiveDataType; primitiveDataElement.Name = primitiveDataElementName; dc.DataMembers.Add(primitiveDataElement); dcModel.Contracts.Add(dc); #endregion #region Service Contract scStore = new Store(serviceProvider, typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel)); scDomainModel = scStore.GetDomainModel<ServiceContractDslDomainModel>(); scTransaction = scStore.TransactionManager.BeginTransaction(); scModel = (ServiceContractModel)scDomainModel.CreateElement(new Partition(scStore), typeof(ServiceContractModel), null); scModel.ProjectMappingTable = projectMappingTableName; msg = scStore.ElementFactory.CreateElement(Message.DomainClassId) as Message; msg.Name = messageName; //Create the moniker //mel://[DSLNAMESPACE]\[MODELELEMENTTYPE]\[MODELELEMENT.GUID]@[PROJECT]\[MODELFILE] string requestMoniker = string.Format(@"mel://{0}\{1}\{2}@{3}\{4}", primitiveDataElement.GetType().Namespace, primitiveDataElement.GetType().Name, primitiveDataElement.Id.ToString(), dataContractModelProjectName, dataContractModelFileName); part = scStore.ElementFactory.CreateElement(DataContractMessagePart.DomainClassId) as DataContractMessagePart; part.Name = partName; part.Type = new MockModelBusReference(primitiveDataElement); msg.MessageParts.Add(part); scModel.Messages.Add(msg); #endregion }
private DataContract CreateDataContract(string name) { DataContract dataContract = new DataContract(DataContractStore); dataContract.Name = name; return dataContract; }
protected override ModelElement ResolveModelElement(string instanceNamespace) { if (this.processFault) { return ResolveFaultElement(instanceNamespace); } using (Transaction transaction = DataContractStore.TransactionManager.BeginTransaction()) { DataContract dc = new DataContract(DataContractStore); dc.DataContractModel = new DataContractModel(DataContractStore); dc.DataContractModel.ProjectMappingTable = "WCF"; dc.Name = instanceNamespace; WCFDataContract extender = new WCFDataContract(); dc.ObjectExtender = extender; extender.ModelElement = dc; transaction.Commit(); return dc; } }
public void ShouldGetNewNameOnSelfReference() { DataContract source = new DataContract(Store); source.Name = "DC"; AggregationConnectionBuilder.Connect(source, source); Assert.AreEqual(1, source.DataMembers.Count); ModelElementReference dataElement = (ModelElementReference)source.DataMembers[0]; Assert.AreEqual("DC", source.Name); Assert.AreNotEqual(source.Name, dataElement.Name); Assert.AreEqual("DC1", dataElement.Name); }
public void ShouldGetNewNameOnMultipleTargets() { DataContract source = new DataContract(Store); source.Name = "Source"; DataContract target = new DataContract(Store); target.Name = "Target"; DataContractBaseCanBeContainedOnContracts link = new DataContractBaseCanBeContainedOnContracts(source, target); ModelElementReference dataElement = new ModelElementReference(Store); dataElement.Name = "DcdeName"; dataElement.SetLinkedElement(link.Id); source.DataMembers.Add(dataElement); AggregationConnectionBuilder.Connect(source, target); Assert.AreEqual(1, target.DataMembers.Count); dataElement = (ModelElementReference)target.DataMembers[0]; Assert.AreEqual("Source", dataElement.Name); AggregationConnectionBuilder.Connect(source, target); Assert.AreEqual(2, target.DataMembers.Count); dataElement = (ModelElementReference)target.DataMembers[1]; Assert.AreEqual("Source1", dataElement.Name); AggregationConnectionBuilder.Connect(source, target); Assert.AreEqual(3, target.DataMembers.Count); dataElement = (ModelElementReference)target.DataMembers[2]; Assert.AreEqual("Source2", dataElement.Name); }
public static DslModeling::LinkedElementCollection<DataMember> GetDataMembers(DataContract element) { return GetRoleCollection<DslModeling::LinkedElementCollection<DataMember>, DataMember>(element, DataContractDomainRoleId); }
public static void SetDataContract(DataMember element, DataContract newDataContract) { DslModeling::DomainRoleInfo.SetLinkedElement(element, DataMemberDomainRoleId, newDataContract); }
/// <summary> /// Constructor /// Creates a DataContractHasDataMembers link in the same Partition as the given DataContract /// </summary> /// <param name="source">DataContract to use as the source of the relationship.</param> /// <param name="target">DataMember to use as the target of the relationship.</param> public DataContractHasDataMembers(DataContract source, DataMember target) : base((source != null ? source.Partition : null), new DslModeling::RoleAssignment[]{new DslModeling::RoleAssignment(DataContractHasDataMembers.DataContractDomainRoleId, source), new DslModeling::RoleAssignment(DataContractHasDataMembers.DataMemberDomainRoleId, target)}, null) { }
protected override ModelElement ResolveModelElement(string instanceNamespace) { using (Transaction transaction = DataContractStore.TransactionManager.BeginTransaction()) { DataContract dc = new DataContract(DataContractStore); dc.DataContractModel = new DataContractModel(DataContractStore); dc.DataContractModel.ProjectMappingTable = "ASMX"; dc.Name = "FooDC"; AsmxDataContract extender = new AsmxDataContract(); dc.ObjectExtender = extender; extender.ModelElement = dc; transaction.Commit(); return dc; } }
private static void WriteChildElements(DslModeling::SerializationContext serializationContext, DataContract element, global::System.Xml.XmlWriter writer) { // DataContractHasDataMembers global::System.Collections.ObjectModel.ReadOnlyCollection<DataContractHasDataMembers> allDataContractHasDataMembersInstances = DataContractHasDataMembers.GetLinksToDataMembers(element); if (!serializationContext.Result.Failed && allDataContractHasDataMembersInstances.Count > 0) { writer.WriteStartElement("dataMembers"); global::System.Type typeofDataContractHasDataMembers = typeof(DataContractHasDataMembers); foreach (DataContractHasDataMembers eachDataContractHasDataMembersInstance in allDataContractHasDataMembersInstances) { if (serializationContext.Result.Failed) break; if (eachDataContractHasDataMembersInstance.GetType() != typeofDataContractHasDataMembers) { // Derived relationships will be serialized in full-form. DslModeling::DomainClassXmlSerializer derivedRelSerializer = serializationContext.Directory.GetSerializer(eachDataContractHasDataMembersInstance.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(derivedRelSerializer != null, "Cannot find serializer for " + eachDataContractHasDataMembersInstance.GetDomainClass().Name + "!"); derivedRelSerializer.Write(serializationContext, eachDataContractHasDataMembersInstance, writer); } else { // No need to serialize the relationship itself, just serialize the role-player directly. DslModeling::ModelElement targetElement = eachDataContractHasDataMembersInstance.DataMember; DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer(targetElement.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert(targetSerializer != null, "Cannot find serializer for " + targetElement.GetDomainClass().Name + "!"); targetSerializer.Write(serializationContext, targetElement, writer); } } writer.WriteEndElement(); } }
/// <summary> /// Reads all instances of relationship DataContractHasDataMembers. /// </summary> /// <remarks> /// The caller will position the reader at the open tag of the first XML element inside the relationship tag, so it can be /// either the first instance, or a bogus tag. This method will deserialize all instances and ignore all bogus tags. When the /// method returns, the reader will be positioned at the end tag of the relationship (or EOF if somehow that happens). /// </remarks> /// <param name="serializationContext">Serialization context.</param> /// <param name="element">In-memory DataContract instance that will get the deserialized data.</param> /// <param name="reader">XmlReader to read serialized data from.</param> private static void ReadDataContractHasDataMembersInstances(DslModeling::SerializationContext serializationContext, DataContract element, global::System.Xml.XmlReader reader) { while (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element) { DslModeling::DomainClassXmlSerializer newDataMemberOfDataContractHasDataMembersSerializer = serializationContext.Directory.GetSerializer(DataMember.DomainClassId); global::System.Diagnostics.Debug.Assert(newDataMemberOfDataContractHasDataMembersSerializer != null, "Cannot find serializer for DataMember!"); DataMember newDataMemberOfDataContractHasDataMembers = newDataMemberOfDataContractHasDataMembersSerializer.TryCreateInstance(serializationContext, reader, element.Partition) as DataMember; if (newDataMemberOfDataContractHasDataMembers != null) { element.DataMembers.Add(newDataMemberOfDataContractHasDataMembers); DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newDataMemberOfDataContractHasDataMembers.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newDataMemberOfDataContractHasDataMembers.GetDomainClass().Name + "!"); targetSerializer.Read(serializationContext, newDataMemberOfDataContractHasDataMembers, reader); } else { global::System.Type typeofDataContractHasDataMembers = typeof(DataContractHasDataMembers); DslModeling::DomainRelationshipXmlSerializer newDataContractHasDataMembersSerializer = serializationContext.Directory.GetSerializer(DataContractHasDataMembers.DomainClassId) as DslModeling::DomainRelationshipXmlSerializer; global::System.Diagnostics.Debug.Assert(newDataContractHasDataMembersSerializer != null, "Cannot find serializer for DataContractHasDataMembers!"); DataContractHasDataMembers newDataContractHasDataMembers = newDataContractHasDataMembersSerializer.TryCreateInstance (serializationContext, reader, element.Partition) as DataContractHasDataMembers; if (newDataContractHasDataMembers != null) { if (newDataContractHasDataMembers.GetType() == typeofDataContractHasDataMembers) { // The relationship should be serialized in short-form. DataContractDslSerializationBehaviorSerializationMessages.ExpectingShortFormRelationship(serializationContext, reader, typeof(DataContractHasDataMembers)); } DslModeling::DomainRoleInfo.SetRolePlayer (newDataContractHasDataMembers, DataContractHasDataMembers.DataContractDomainRoleId, element); DslModeling::DomainClassXmlSerializer targetSerializer = serializationContext.Directory.GetSerializer (newDataContractHasDataMembers.GetDomainClass().Id); global::System.Diagnostics.Debug.Assert (targetSerializer != null, "Cannot find serializer for " + newDataContractHasDataMembers.GetDomainClass().Name + "!"); targetSerializer.Read(serializationContext, newDataContractHasDataMembers, reader); } else { // Unknown element, skip DslModeling::SerializationUtilities.Skip(reader); } } } }
/// <summary> /// This method deserializes all child model elements. /// </summary> /// <remarks> /// The caller will position the reader at the open tag of the first child XML element to deserialized. /// This method will read as many child elements as it can. It returns under three circumstances: /// 1) When an unknown child XML element is encountered. In this case, this method will position the reader at the /// open tag of the unknown element. This implies that if the first child XML element is unknown, this method /// should return immediately and do nothing. /// 2) When all child XML elemnets are read. In this case, the reader will be positioned at the end tag of the parent element. /// 3) EOF. /// </remarks> /// <param name="serializationContext">Serialization context.</param> /// <param name="reader">XmlReader to read serialized data from.</param> /// <param name="element">In-memory DataContract instance that will get the deserialized data.</param> private static void ReadChildElements(DslModeling::SerializationContext serializationContext, DataContract element, global::System.Xml.XmlReader reader) { if (!serializationContext.Result.Failed && !reader.EOF && reader.NodeType == global::System.Xml.XmlNodeType.Element) { if (string.Compare(reader.LocalName, "dataMembers", global::System.StringComparison.CurrentCulture) == 0) { if (reader.IsEmptyElement) { // No instance of this relationship, just skip DslModeling::SerializationUtilities.Skip(reader); } else { DslModeling::SerializationUtilities.SkipToFirstChild(reader); // Skip the open tag of <dataMembers> ReadDataContractHasDataMembersInstances(serializationContext, element, reader); DslModeling::SerializationUtilities.Skip(reader); // Skip the close tag of </dataMembers> } } } }