void ImportMessageParts()
{
SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo;
ImportMessage(method.InputMembersMapping, InputMessage);
ImportMessage(method.OutputMembersMapping, OutputMessage);
foreach (SoapHeaderMapping hf in method.Headers)
{
if (hf.Custom)
{
continue;
}
Message msg = new Message();
msg.Name = Operation.Name + hf.HeaderType.Name;
MessagePart part = new MessagePart();
part.Name = hf.HeaderType.Name;
msg.Parts.Add(part);
ServiceDescription.Messages.Add(msg);
if (method.Use == SoapBindingUse.Literal)
{
// MS.NET reflects header classes in a weird way. The root element
// name is the CLR class name unless it is specified in an XmlRootAttribute.
// The usual is to use the xml type name by default, but not in this case.
XmlRootAttribute root;
XmlAttributes ats = new XmlAttributes(hf.HeaderType);
if (ats.XmlRoot != null)
{
root = ats.XmlRoot;
}
else
{
root = new XmlRootAttribute(hf.HeaderType.Name);
}
if (root.Namespace == null)
{
root.Namespace = TypeInfo.LogicalType.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace);
}
if (root.ElementName == null)
{
root.ElementName = hf.HeaderType.Name;
}
XmlTypeMapping mapping = ReflectionImporter.ImportTypeMapping(hf.HeaderType, root);
part.Element = new XmlQualifiedName(mapping.ElementName, mapping.Namespace);
SchemaExporter.ExportTypeMapping(mapping);
}
else
{
XmlTypeMapping mapping = SoapReflectionImporter.ImportTypeMapping(hf.HeaderType, TypeInfo.LogicalType.GetWebServiceEncodedNamespace(ServiceDescription.TargetNamespace));
part.Type = new XmlQualifiedName(mapping.ElementName, mapping.Namespace);
SoapSchemaExporter.ExportTypeMapping(mapping);
}
}
}
void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped)
{
if (members.Count == 1 && members[0].Any && members[0].ElementName.Length == 0 && !wrapped)
{
string typeName = SchemaExporter.ExportAnyType(members[0].Namespace);
MessagePart part = new MessagePart();
part.Name = members[0].MemberName;
part.Type = new XmlQualifiedName(typeName, members[0].Namespace);
message.Parts.Add(part);
}
else
{
SchemaExporter.ExportMembersMapping(members);
if (wrapped)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
part.Element = new XmlQualifiedName(members.ElementName, members.Namespace);
message.Parts.Add(part);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping member = members[i];
MessagePart part = new MessagePart();
part.Name = member.MemberName;
part.Element = new XmlQualifiedName(member.ElementName, member.Namespace);
message.Parts.Add(part);
}
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Literal, null));
}
void Run()
{
var exporter = new SchemaExporter();
exporter.InitializeContext();
var context = exporter.Context;
Process = context.ProcessInfo;
exporter.Context.FileSystem.CheckinComment = App.Model.CheckinComment;
exporter.Context.FileSystem.IntegrateWithTFSAndCheckInAutomatically = App.Config.IntegrateWithTFSAndCheckInAutomatically;
exporter.Export(SchemaName);
if (context.ErrorList.Any())
{
context.ProcessInfo.Text = string.Join(Environment.NewLine, context.ErrorList);
Thread.Sleep(TimeSpan.FromSeconds(2));
refresher.Stop();
return;
}
OnProcessCompletedSuccessfully();
}
internal XmlDataContractCriticalHelper(
[DynamicallyAccessedMembers(ClassDataContract.DataContractPreserveMemberTypes)]
Type type) : base(type)
{
if (type.IsDefined(Globals.TypeOfDataContractAttribute, false))
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.IXmlSerializableCannotHaveDataContract, DataContract.GetClrTypeFullName(type))));
}
if (type.IsDefined(Globals.TypeOfCollectionDataContractAttribute, false))
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.IXmlSerializableCannotHaveCollectionDataContract, DataContract.GetClrTypeFullName(type))));
}
bool hasRoot;
XmlSchemaType? xsdType;
XmlQualifiedName xmlName;
SchemaExporter.GetXmlTypeInfo(type, out xmlName, out xsdType, out hasRoot);
XmlName = xmlName;
XsdType = xsdType;
HasRoot = hasRoot;
XmlDictionary dictionary = new XmlDictionary();
Name = dictionary.Add(XmlName.Name);
Namespace = dictionary.Add(XmlName.Namespace);
object[]? xmlRootAttributes = UnderlyingType?.GetCustomAttributes(Globals.TypeOfXmlRootAttribute, false).ToArray();
if (xmlRootAttributes == null || xmlRootAttributes.Length == 0)
{
if (hasRoot)
{
_topLevelElementName = Name;
_topLevelElementNamespace = (this.XmlName.Namespace == Globals.SchemaNamespace) ? DictionaryGlobals.EmptyString : Namespace;
_isTopLevelElementNullable = true;
}
}
else
{
if (hasRoot)
{
XmlRootAttribute xmlRootAttribute = (XmlRootAttribute)xmlRootAttributes[0];
_isTopLevelElementNullable = xmlRootAttribute.IsNullable;
string elementName = xmlRootAttribute.ElementName;
_topLevelElementName = (elementName == null || elementName.Length == 0) ? Name : dictionary.Add(DataContract.EncodeLocalName(elementName));
string?elementNs = xmlRootAttribute.Namespace;
_topLevelElementNamespace = (elementNs == null || elementNs.Length == 0) ? DictionaryGlobals.EmptyString : dictionary.Add(elementNs);
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidDataContractException(SR.Format(SR.IsAnyCannotHaveXmlRoot, DataContract.GetClrTypeFullName(UnderlyingType !))));
}
}
}
void CreateLiteralMessage(Message message, MessageBinding messageBinding, XmlMembersMapping members, bool wrapped, bool rpc)
{
if (members.Count == 1 && members[0].Any && members[0].ElementName.Length == 0 && !wrapped)
{
string typeName = SchemaExporter.ExportAnyType(members[0].Namespace);
MessagePart part = new MessagePart();
part.Name = members[0].MemberName;
part.Type = new XmlQualifiedName(typeName, members[0].Namespace);
message.Parts.Add(part);
}
else
{
SchemaExporter.ExportMembersMapping(members, !rpc);
if (wrapped)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
part.Element = new XmlQualifiedName(members.XsdElementName, members.Namespace);
message.Parts.Add(part);
}
else
{
for (int i = 0; i < members.Count; i++)
{
XmlMemberMapping member = members[i];
MessagePart part = new MessagePart();
if (rpc)
{
// Generate massage part with the type attribute
if (member.TypeName == null || member.TypeName.Length == 0)
{
throw new InvalidOperationException(Res.GetString(Res.WsdlGenRpcLitAnonimousType, Method.DeclaringType.Name, Method.Name, member.MemberName));
}
part.Name = member.XsdElementName;
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
}
else
{
part.Name = XmlConvert.EncodeLocalName(member.MemberName);
part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace);
}
message.Parts.Add(part);
}
}
}
messageBinding.Extensions.Add(CreateSoapBodyBinding(SoapBindingUse.Literal, rpc ? members.Namespace : null));
}
public void AllScenario()
{
ConfigurationHelper.ConfigurationDirectoryPath = "Configs";
var schemaExporter = new SchemaExporter();
schemaExporter.InitializeContext();
schemaExporter.Database.CreateTables();
schemaExporter.Context.MsBuildQueue.BuildAfterCodeGenerationIsCompleted = false;
schemaExporter.Export("ERP");
schemaExporter.Context.ErrorList.Should().BeEmpty();
}
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers)
{
// CONSIDER, alexdej: support headerfault.
if (use == SoapBindingUse.Encoded)
{
SoapExporter.ExportMembersMapping(inHeaderMappings, false);
if (outHeaderMappings != null)
{
SoapExporter.ExportMembersMapping(outHeaderMappings, false);
}
}
else
{
SchemaExporter.ExportMembersMapping(inHeaderMappings);
if (outHeaderMappings != null)
{
SchemaExporter.ExportMembersMapping(outHeaderMappings);
}
}
CodeIdentifiers identifiers = new CodeIdentifiers();
int inCount = 0, outCount = 0;
for (int i = 0; i < headers.Length; i++)
{
SoapReflectedHeader soapHeader = headers[i];
if (!soapHeader.custom)
{
continue;
}
XmlMemberMapping member;
if ((soapHeader.direction & SoapHeaderDirection.In) != 0)
{
member = inHeaderMappings[inCount++];
if (soapHeader.direction != SoapHeaderDirection.In)
{
outCount++;
}
}
else
{
member = outHeaderMappings[outCount++];
}
MessagePart part = new MessagePart();
part.Name = member.ElementName;
if (use == SoapBindingUse.Encoded)
{
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
}
else
{
part.Element = new XmlQualifiedName(member.ElementName, member.Namespace);
}
Message message = new Message();
message.Name = identifiers.AddUnique(methodName + part.Name, message);
message.Parts.Add(part);
HeaderMessages.Add(message);
ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, use);
if ((soapHeader.direction & SoapHeaderDirection.In) != 0)
{
OperationBinding.Input.Extensions.Add(soapHeaderBinding);
}
if ((soapHeader.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
{
OperationBinding.Output.Extensions.Add(soapHeaderBinding);
}
}
}
void ImportMessage(XmlMembersMapping members, Message msg)
{
SoapMethodStubInfo method = (SoapMethodStubInfo)MethodStubInfo;
bool needsEnclosingElement = (method.ParameterStyle == SoapParameterStyle.Wrapped &&
method.SoapBindingStyle == SoapBindingStyle.Document);
if (needsEnclosingElement)
{
MessagePart part = new MessagePart();
part.Name = "parameters";
XmlQualifiedName qname = new XmlQualifiedName(members.ElementName, members.Namespace);
if (method.Use == SoapBindingUse.Literal)
{
part.Element = qname;
}
else
{
part.Type = qname;
}
msg.Parts.Add(part);
}
else
{
for (int n = 0; n < members.Count; n++)
{
MessagePart part = new MessagePart();
part.Name = members[n].MemberName;
if (method.Use == SoapBindingUse.Literal)
{
if (members[n].Any)
{
part.Type = new XmlQualifiedName("any", members[n].Namespace);
}
else
{
part.Element = new XmlQualifiedName(members[n].ElementName, members[n].Namespace);
}
}
else
{
string namesp = members[n].TypeNamespace;
if (namesp == "")
{
namesp = members[n].Namespace;
}
part.Name = members[n].ElementName;
part.Type = new XmlQualifiedName(members[n].TypeName, namesp);
}
msg.Parts.Add(part);
}
}
if (method.Use == SoapBindingUse.Literal)
{
SchemaExporter.ExportMembersMapping(members);
}
else
{
SoapSchemaExporter.ExportMembersMapping(members, needsEnclosingElement);
}
}
protected override bool ReflectMethod()
{
LogicalTypeInfo ti = TypeStubManager.GetLogicalTypeInfo(ServiceType);
HttpOperationBinding sob = new HttpOperationBinding();
sob.Location = "/" + MethodStubInfo.Name;
OperationBinding.Extensions.Add(sob);
if (!Method.IsVoid)
{
MimeXmlBinding mxb = new MimeXmlBinding();
mxb.Part = "Body";
OperationBinding.Output.Extensions.Add(mxb);
MessagePart part = new MessagePart();
part.Name = "Body";
XmlTypeMapping map = ReflectionImporter.ImportTypeMapping(Method.ReturnType, ti.GetWebServiceLiteralNamespace(ServiceDescription.TargetNamespace));
XmlQualifiedName qname = new XmlQualifiedName(map.ElementName, map.Namespace);
part.Element = qname;
OutputMessage.Parts.Add(part);
SchemaExporter.ExportTypeMapping(map);
}
XmlReflectionMember[] mems = new XmlReflectionMember [Method.Parameters.Length];
for (int n = 0; n < Method.Parameters.Length; n++)
{
ParameterInfo param = Method.Parameters [n];
XmlReflectionMember mem = new XmlReflectionMember();
mem.MemberName = param.Name;
Type ptype = param.ParameterType;
if (ptype.IsByRef)
{
ptype = ptype.GetElementType();
}
mem.MemberType = ptype;
mems [n] = mem;
}
XmlMembersMapping memap = ReflectionImporter.ImportMembersMapping("", ti.WebServiceAbstractNamespace, mems, false);
bool allPrimitives = true;
for (int n = 0; n < memap.Count; n++)
{
XmlMemberMapping mem = memap[n];
MessagePart part = new MessagePart();
XmlQualifiedName pqname;
if (mem.TypeNamespace == "")
{
pqname = new XmlQualifiedName(mem.TypeName, XmlSchema.Namespace);
}
else
{
pqname = new XmlQualifiedName(mem.TypeName, mem.TypeNamespace);
allPrimitives = false;
}
part.Type = pqname;
part.Name = mem.ElementName;
InputMessage.Parts.Add(part);
}
if (!allPrimitives)
{
SoapSchemaExporter.ExportMembersMapping(memap);
}
return(true);
}
void CreateHeaderMessages(string methodName, SoapBindingUse use, XmlMembersMapping inHeaderMappings, XmlMembersMapping outHeaderMappings, SoapReflectedHeader[] headers, bool rpc)
{
//
if (use == SoapBindingUse.Encoded)
{
SoapExporter.ExportMembersMapping(inHeaderMappings, false);
if (outHeaderMappings != null)
{
SoapExporter.ExportMembersMapping(outHeaderMappings, false);
}
}
else
{
SchemaExporter.ExportMembersMapping(inHeaderMappings);
if (outHeaderMappings != null)
{
SchemaExporter.ExportMembersMapping(outHeaderMappings);
}
}
CodeIdentifiers identifiers = new CodeIdentifiers();
int inCount = 0, outCount = 0;
for (int i = 0; i < headers.Length; i++)
{
SoapReflectedHeader soapHeader = headers[i];
if (!soapHeader.custom)
{
continue;
}
XmlMemberMapping member;
if ((soapHeader.direction & SoapHeaderDirection.In) != 0)
{
member = inHeaderMappings[inCount++];
if (soapHeader.direction != SoapHeaderDirection.In)
{
outCount++;
}
}
else
{
member = outHeaderMappings[outCount++];
}
MessagePart part = new MessagePart();
part.Name = member.XsdElementName;
if (use == SoapBindingUse.Encoded)
{
part.Type = new XmlQualifiedName(member.TypeName, member.TypeNamespace);
}
else
{
part.Element = new XmlQualifiedName(member.XsdElementName, member.Namespace);
}
Message message = new Message();
message.Name = identifiers.AddUnique(methodName + part.Name, message);
message.Parts.Add(part);
HeaderMessages.Add(message);
ServiceDescriptionFormatExtension soapHeaderBinding = CreateSoapHeaderBinding(new XmlQualifiedName(message.Name, Binding.ServiceDescription.TargetNamespace), part.Name, rpc ? member.Namespace : null, use);
if ((soapHeader.direction & SoapHeaderDirection.In) != 0)
{
OperationBinding.Input.Extensions.Add(soapHeaderBinding);
}
if ((soapHeader.direction & SoapHeaderDirection.Out) != 0)
{
OperationBinding.Output.Extensions.Add(soapHeaderBinding);
}
if ((soapHeader.direction & SoapHeaderDirection.Fault) != 0)
{
if (soapMethod.IsClaimsConformance)
{
throw new InvalidOperationException(Res.GetString(Res.BPConformanceHeaderFault, soapMethod.methodInfo.ToString(), soapMethod.methodInfo.DeclaringType.FullName, "Direction", typeof(SoapHeaderDirection).Name, SoapHeaderDirection.Fault.ToString()));
}
OperationBinding.Output.Extensions.Add(soapHeaderBinding);
}
}
}
