internal static TempAssembly GenerateTempAssembly(XmlMapping xmlMapping, Type type, string defaultNamespace, string location)
{
if (xmlMapping == null)
{
throw new ArgumentNullException(nameof(xmlMapping));
}
xmlMapping.CheckShallow();
if (xmlMapping.IsSoap)
{
return(null);
}
return(new TempAssembly(new XmlMapping[] { xmlMapping }, new Type[] { type }, defaultNamespace, location));
}
internal bool CanRead(XmlMapping mapping, XmlReader xmlReader)
{
if (mapping == null)
{
return(false);
}
if (mapping.Accessor.Any)
{
return(true);
}
TempMethod method = _methods[mapping.Key];
return(xmlReader.IsStartElement(method.name, method.ns));
}
public static QueryMapping GetMapping(string mappingId)
{
if (mappingId != null)
{
Type type = FindLoadedType(mappingId);
if (type != null)
{
return(new AttributeMapping(type));
}
if (File.Exists(mappingId))
{
return(XmlMapping.FromXml(File.ReadAllText(mappingId)));
}
}
return(new ImplicitMapping());
}
/// <include file='doc\SoapReflectionImporter.uex' path='docs/doc[@for="XmlReflectionImporter.ImportTypeMapping1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlTypeMapping ImportTypeMapping(Type type, string defaultNamespace)
{
ElementAccessor element = new ElementAccessor();
element.IsSoap = true;
element.Mapping = ImportTypeMapping(_modelScope.GetTypeModel(type), new RecursionLimiter());
element.Name = element.Mapping.DefaultElementName;
element.Namespace = element.Mapping.Namespace == null ? defaultNamespace : element.Mapping.Namespace;
element.Form = XmlSchemaForm.Qualified;
XmlTypeMapping xmlMapping = new XmlTypeMapping(_typeScope, element);
xmlMapping.SetKeyInternal(XmlMapping.GenerateKey(type, null, defaultNamespace));
xmlMapping.IsSoap = true;
xmlMapping.GenerateSerializer = true;
return(xmlMapping);
}
public void CallingDeserializeProperly()
{
// Arrange
var called = false;
Func <string, XmlMapping> fakeHandler = (string f) =>
{
called = true; // do your test of the input and put your result here
return(new XmlMapping());
};
// Act
var m = XmlMapping.Create("test");
XmlMapping.DeserializeHandler = fakeHandler;
// Assert
Assert.IsTrue(called);
}
public void TestNestedEntity_XmlMapped_DeeplyNested()
{
var provider = GetProvider().WithMapping(XmlMapping.FromXml(Nested_XmlMapped_DeeplyNested.Xml));
var items = provider.GetTable <Nested_XmlMapped_DeeplyNested.Employee>().ToList();
Assert.Equal(9, items.Count);
foreach (var item in items)
{
Assert.NotEqual(null, item.Person);
Assert.NotEqual(null, item.Person.Title);
Assert.NotEqual(null, item.Person.Name);
Assert.NotEqual(null, item.Person.Name.First);
Assert.NotEqual(null, item.Address);
Assert.NotEqual(null, item.Address.Street);
}
}
/// <summary>
/// Creates the repository. Init the provider and establish
/// a database connection
/// </summary>
/// <returns></returns>
private static DbEntityRepository CreateRepository()
{
DbEntityProvider dbentprovider;
string connectionString = ConfigurationManager.AppSettings["ConnORA"];
string MapPath = Utils.GetMapPath("MapORA");
string provider = ConfigurationManager.AppSettings["ProviderORA"];
var mapping = XmlMapping.FromXml(File.ReadAllText(MapPath));
dbentprovider = DbEntityProvider.From(provider, connectionString, mapping, QueryPolicy.Default);
//May not be needed for all databases,
//some need a little kick start before serving requests
DbInit(dbentprovider);
return(new DbEntityRepository(dbentprovider));
}
public ReflectionXmlSerializationWriter(XmlMapping xmlMapping, XmlWriter xmlWriter, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
{
Init(xmlWriter, namespaces, encodingStyle, id, null);
if (!xmlMapping.IsWriteable || !xmlMapping.GenerateSerializer)
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, nameof(xmlMapping)));
}
if (xmlMapping is XmlTypeMapping || xmlMapping is XmlMembersMapping)
{
_mapping = xmlMapping;
}
else
{
throw new ArgumentException(SR.Format(SR.XmlInternalError, nameof(xmlMapping)));
}
}
public void TestAssociation_XmlMapping_DifferenteKeys_Customer()
{
var provider = GetProvider().WithMapping(
XmlMapping.FromXml(Association_XmlMapping_DifferentKeys.Xml, typeof(Association_XmlMapping_DifferentKeys.Customer).Assembly));
var items = provider.GetTable <Association_XmlMapping_DifferentKeys.Order>()
.Where(o => o.Customer.ContactName.StartsWith("Maria"))
.ToList();
Assert.Equal(25, items.Count);
foreach (var item in items)
{
Assert.NotEqual(null, item.ID);
Assert.NotEqual(null, item.CustomerID);
Assert.Equal(null, item.Customer); // not retrieved, no policy
}
}
public void TestAssociation_XmlMapping_DifferentKeys_Orders()
{
var provider = GetProvider().WithMapping(
XmlMapping.FromXml(Association_XmlMapping_DifferentKeys.Xml, typeof(Association_XmlMapping_DifferentKeys.Customer).Assembly));
var items = provider.GetTable <Association_XmlMapping_DifferentKeys.Customer>()
.Where(c => c.Orders.Count() > 1)
.ToList();
Assert.Equal(88, items.Count);
foreach (var item in items)
{
Assert.NotEqual(null, item.ID);
Assert.NotEqual(null, item.ContactName);
Assert.NotEqual(null, item.Phone);
Assert.NotEqual(null, item.Orders);
Assert.Equal(0, item.Orders.Count);
}
}
public XmlMapping AddMapping(DirectoryInfo sourceDir, bool includeAttributeData = false)
{
StringBuilder sb = new StringBuilder();
if (sourceDir == null || !sourceDir.Exists)
{
throw new ArgumentException("Source Directory must exist.", nameof(sourceDir));
}
XmlMapping existingMapping = this.ImportMappings.FirstOrDefault(m => m.Source.Name == sourceDir.FullName);
if (existingMapping != null)
{
throw new ArgumentException($"Can not add duplicate mapping with name \"{sourceDir.FullName}\". XML Mappings must have unique paths.", nameof(sourceDir));
}
XmlMapping mapping = new XmlMapping(sourceDir, includeAttributeData);
this.addMapping(mapping);
return(mapping);
}
public override object[] GetInitializers(LogicalMethodInfo[] methodInfos)
{
XmlReflectionImporter importer = new XmlReflectionImporter();
XmlMapping[] sers = new XmlMapping [methodInfos.Length];
for (int n = 0; n < sers.Length; n++)
{
LogicalMethodInfo metinfo = methodInfos[n];
if (metinfo.IsVoid)
{
sers[n] = null;
}
else
{
LogicalTypeInfo sti = TypeStubManager.GetLogicalTypeInfo(metinfo.DeclaringType);
object[] ats = methodInfos[n].ReturnTypeCustomAttributeProvider.GetCustomAttributes(typeof(XmlRootAttribute), true);
XmlRootAttribute root = ats.Length > 0 ? ats[0] as XmlRootAttribute : null;
sers[n] = importer.ImportTypeMapping(methodInfos[n].ReturnType, root, sti.GetWebServiceLiteralNamespace(sti.WebServiceNamespace));
}
}
return(XmlSerializer.FromMappings(sers));
}
/// <summary>
/// Validate required values for Import Job
/// </summary>
/// <returns>True if validation succeeds</returns>
private bool validateData(XmlMapping mappingData)
{
var errorList = new List <string>();
bool pathExists = true;
if (mappingData.Source?.Source == null || !mappingData.Source.Source.Exists)
{
pathExists = false;
string mapPath = mappingData.Source?.Source == null ? "Path is empty" : mappingData.Source.Source.FullName;
errorList.Add($"Data source must be a valid directory. Verify the source path exists. Path: {mapPath}");
}
if (pathExists)
{
this.currentFileList = mappingData.Source.Source.GetFiles("*.*", SearchOption.AllDirectories);
if (this.currentFileList == null || this.currentFileList.Length <= 0)
{
errorList.Add("Source directory must contain valid XML files. No files were found.");
}
}
if (mappingData.ParentIDSource == Enumerations.ParentSource.Global && mappingData.GlobalParentID == Guid.Empty)
{
errorList.Add("A valid GlobalParentID must be specified when TemplateMapSource is specified as Global");
}
if (errorList.Any())
{
foreach (var error in errorList)
{
LogStatus(error);
}
return(false);
}
return(true);
}
internal object InvokeReader(XmlMapping mapping, XmlReader xmlReader, XmlDeserializationEvents events, string encodingStyle)
{
XmlSerializationReader reader = null;
try
{
encodingStyle = ValidateEncodingStyle(encodingStyle, mapping.Key);
reader = Contract.Reader;
reader.Init(xmlReader, events, encodingStyle, this);
if (_methods[mapping.Key].readMethod == null)
{
if (_readerMethods == null)
{
_readerMethods = Contract.ReadMethods;
}
string methodName = (string)_readerMethods[mapping.Key];
if (methodName == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlNotSerializable, mapping.Accessor.Name));
}
_methods[mapping.Key].readMethod = GetMethodFromType(reader.GetType(), methodName);
}
return(_methods[mapping.Key].readMethod.Invoke(reader, Array.Empty <object>()));
}
catch (SecurityException e)
{
throw new InvalidOperationException(SR.XmlNoPartialTrust, e);
}
finally
{
if (reader != null)
{
reader.Dispose();
}
}
}
internal void InvokeWriter(XmlMapping mapping, XmlWriter xmlWriter, object o, XmlSerializerNamespaces namespaces, string encodingStyle, string id)
{
XmlSerializationWriter writer = null;
try
{
encodingStyle = ValidateEncodingStyle(encodingStyle, mapping.Key);
writer = Contract.Writer;
writer.Init(xmlWriter, namespaces, encodingStyle, id, this);
if (_methods[mapping.Key].writeMethod == null)
{
if (_writerMethods == null)
{
_writerMethods = Contract.WriteMethods;
}
string methodName = (string)_writerMethods[mapping.Key];
if (methodName == null)
{
throw new InvalidOperationException(SR.Format(SR.XmlNotSerializable, mapping.Accessor.Name));
}
_methods[mapping.Key].writeMethod = GetMethodFromType(writer.GetType(), methodName);
}
_methods[mapping.Key].writeMethod.Invoke(writer, new object[] { o });
}
catch (SecurityException e)
{
throw new InvalidOperationException(SR.XmlNoPartialTrust, e);
}
finally
{
if (writer != null)
{
writer.Dispose();
}
}
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer7"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSerializer(Type type, XmlAttributeOverrides overrides, Type[] extraTypes, XmlRootAttribute root, string defaultNamespace, string location)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
DefaultNamespace = defaultNamespace;
_rootType = type;
XmlReflectionImporter importer = new XmlReflectionImporter(overrides, defaultNamespace);
if (extraTypes != null)
{
for (int i = 0; i < extraTypes.Length; i++)
{
importer.IncludeType(extraTypes[i]);
}
}
_mapping = importer.ImportTypeMapping(type, root, defaultNamespace);
#if !uapaot
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace, location);
#endif
}
internal static TempAssembly GenerateTempAssembly(XmlMapping xmlMapping)
{
return(GenerateTempAssembly(xmlMapping, null, null));
}
public void Run()
{
string absoluteAssemblyDir = Path.GetFullPath(BuildAssemblyPath);
string assemblyPath = Path.Combine(absoluteAssemblyDir, BuildAssemblyName);
AppDomain.CurrentDomain.AssemblyResolve += (sender, e) =>
{
// FIXME: Imprecise
var requestedAssemblyName = new AssemblyName(e.Name).Name;
if (!requestedAssemblyName.Contains("System"))
{
string requestedAssemblyDll = requestedAssemblyName + ".dll";
foreach (string reference in References)
{
if (reference.ToLowerInvariant().Contains(requestedAssemblyDll.ToLowerInvariant()))
{
return(Assembly.LoadFrom(reference));
}
}
var candidateAssemblyPath = Path.Combine(absoluteAssemblyDir, requestedAssemblyDll);
if (File.Exists(candidateAssemblyPath))
{
return(Assembly.LoadFrom(candidateAssemblyPath));
}
}
return(null);
};
string serializersAssemblyPath = Path.ChangeExtension(assemblyPath, ".XmlSerializers.dll");
Assembly assembly = Assembly.LoadFrom(assemblyPath);
List <Type> serializableTypes = new List <Type>();
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsDefined(typeof(XmlRootAttribute), false))
{
serializableTypes.Add(type);
}
}
List <XmlMapping> mappings = new List <XmlMapping>();
XmlReflectionImporter importer = new XmlReflectionImporter();
foreach (Type type in serializableTypes)
{
XmlMapping mapping = importer.ImportTypeMapping(type);
mappings.Add(mapping);
}
CompilerParameters compilerParameters = new CompilerParameters();
compilerParameters.TempFiles = new TempFileCollection();
compilerParameters.IncludeDebugInformation = false;
compilerParameters.GenerateInMemory = false;
compilerParameters.OutputAssembly = serializersAssemblyPath;
if (KeyFile != null)
{
compilerParameters.CompilerOptions += " /keyfile:\"" + KeyFile + "\"";
}
XmlSerializer.GenerateSerializer(serializableTypes.ToArray(),
mappings.ToArray(), compilerParameters);
}
/// <include file='doc\XmlSerializer.uex' path='docs/doc[@for="XmlSerializer.XmlSerializer1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public XmlSerializer(Type type, string defaultNamespace)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
DefaultNamespace = defaultNamespace;
_rootType = type;
_mapping = GetKnownMapping(type, defaultNamespace);
if (_mapping != null)
{
_primitiveType = type;
return;
}
#if !uapaot
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
lock (s_cache)
{
_tempAssembly = s_cache[defaultNamespace, type];
if (_tempAssembly == null)
{
{
XmlSerializerImplementation contract = null;
Assembly assembly = TempAssembly.LoadGeneratedAssembly(type, null, out contract);
if (assembly == null)
{
// need to reflect and generate new serialization assembly
XmlReflectionImporter importer = new XmlReflectionImporter(defaultNamespace);
_mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
_tempAssembly = GenerateTempAssembly(_mapping, type, defaultNamespace);
}
else
{
// we found the pre-generated assembly, now make sure that the assembly has the right serializer
// try to avoid the reflection step, need to get ElementName, namespace and the Key form the type
_mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
_tempAssembly = new TempAssembly(new XmlMapping[] { _mapping }, assembly, contract);
}
}
}
s_cache.Add(defaultNamespace, type, _tempAssembly);
}
}
if (_mapping == null)
{
_mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
#else
XmlSerializerImplementation contract = GetXmlSerializerContractFromGeneratedAssembly();
if (contract != null)
{
this.innerSerializer = contract.GetSerializer(type);
}
else if (ReflectionMethodEnabled)
{
var importer = new XmlReflectionImporter(defaultNamespace);
_mapping = importer.ImportTypeMapping(type, null, defaultNamespace);
if (_mapping == null)
{
_mapping = XmlReflectionImporter.GetTopLevelMapping(type, defaultNamespace);
}
}
#endif
}
private void WriteMember(object o, object choiceSource, ElementAccessor[] elements, TextAccessor text, ChoiceIdentifierAccessor choice, TypeDesc memberTypeDesc, bool writeAccessors, XmlMapping parentMapping = null)
{
if (memberTypeDesc.IsArrayLike &&
!(elements.Length == 1 && elements[0].Mapping is ArrayMapping))
{
WriteArray(o, choiceSource, elements, text, choice, memberTypeDesc);
}
else
{
WriteElements(o, choiceSource, elements, text, choice, "a", writeAccessors, memberTypeDesc.IsNullable, parentMapping);
}
}
/// <summary>
/// Method to simplify removeMapping
/// </summary>
/// <param name="mapping">Mapping to remove</param>
private void removeMapping(XmlMapping mapping)
{
this.ImportMappings.Remove(mapping);
}
internal string GenerateTypedSerializer(string readMethod, string writeMethod, XmlMapping mapping, CodeIdentifiers classes, string baseSerializer, string readerClass, string writerClass)
{
string serializerName = CodeIdentifier.MakeValid(Accessor.UnescapeName(mapping.Accessor.Mapping.TypeDesc.Name));
serializerName = classes.AddUnique(serializerName + "Serializer", mapping);
_writer.WriteLine();
_writer.Write("public sealed class ");
_writer.Write(CodeIdentifier.GetCSharpName(serializerName));
_writer.Write(" : ");
_writer.Write(baseSerializer);
_writer.WriteLine(" {");
_writer.Indent++;
_writer.WriteLine();
_writer.Write("public override ");
_writer.Write(typeof(bool).FullName);
_writer.Write(" CanDeserialize(");
_writer.Write(typeof(XmlReader).FullName);
_writer.WriteLine(" xmlReader) {");
_writer.Indent++;
if (mapping.Accessor.Any)
{
_writer.WriteLine("return true;");
}
else
{
_writer.Write("return xmlReader.IsStartElement(");
WriteQuotedCSharpString(mapping.Accessor.Name);
_writer.Write(", ");
WriteQuotedCSharpString(mapping.Accessor.Namespace);
_writer.WriteLine(");");
}
_writer.Indent--;
_writer.WriteLine("}");
if (writeMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override void Serialize(object objectToSerialize, ");
_writer.Write(typeof(XmlSerializationWriter).FullName);
_writer.WriteLine(" writer) {");
_writer.Indent++;
_writer.Write("((");
_writer.Write(writerClass);
_writer.Write(")writer).");
_writer.Write(writeMethod);
_writer.Write("(");
if (mapping is XmlMembersMapping)
{
_writer.Write("(object[])");
}
_writer.WriteLine("objectToSerialize);");
_writer.Indent--;
_writer.WriteLine("}");
}
if (readMethod != null)
{
_writer.WriteLine();
_writer.Write("protected override object Deserialize(");
_writer.Write(typeof(XmlSerializationReader).FullName);
_writer.WriteLine(" reader) {");
_writer.Indent++;
_writer.Write("return ((");
_writer.Write(readerClass);
_writer.Write(")reader).");
_writer.Write(readMethod);
_writer.WriteLine("();");
_writer.Indent--;
_writer.WriteLine("}");
}
_writer.Indent--;
_writer.WriteLine("}");
return(serializerName);
}
private void WriteStructMethod(StructMapping mapping, string n, string ns, object o, bool isNullable, bool needType, XmlMapping parentMapping = null)
{
if (mapping.IsSoap && mapping.TypeDesc.IsRoot)
{
return;
}
if (!mapping.IsSoap)
{
if (o == null)
{
if (isNullable)
{
WriteNullTagLiteral(n, ns);
}
return;
}
if (!needType &&
o.GetType() != mapping.TypeDesc.Type)
{
if (WriteDerivedTypes(mapping, n, ns, o, isNullable))
{
return;
}
if (mapping.TypeDesc.IsRoot)
{
if (WriteEnumAndArrayTypes(mapping, o, n, ns, parentMapping))
{
return;
}
WriteTypedPrimitive(n, ns, o, true);
return;
}
throw CreateUnknownTypeException(o);
}
}
if (!mapping.TypeDesc.IsAbstract)
{
if (mapping.TypeDesc.Type != null && typeof(XmlSchemaObject).IsAssignableFrom(mapping.TypeDesc.Type))
{
EscapeName = false;
}
XmlSerializerNamespaces xmlnsSource = null;
MemberMapping[] members = TypeScope.GetAllMembers(mapping);
int xmlnsMember = FindXmlnsIndex(members);
if (xmlnsMember >= 0)
{
MemberMapping member = members[xmlnsMember];
xmlnsSource = (XmlSerializerNamespaces)GetMemberValue(o, member.Name);
}
if (!mapping.IsSoap)
{
WriteStartElement(n, ns, o, false, xmlnsSource);
if (!mapping.TypeDesc.IsRoot)
{
if (needType)
{
WriteXsiType(mapping.TypeName, mapping.Namespace);
}
}
}
else if (xmlnsSource != null)
{
WriteNamespaceDeclarations(xmlnsSource);
}
for (int i = 0; i < members.Length; i++)
{
MemberMapping m = members[i];
string memberName = m.Name;
object memberValue = GetMemberValue(o, memberName);
bool isSpecified = true;
bool shouldPersist = true;
if (m.CheckSpecified != SpecifiedAccessor.None)
{
string specifiedMemberName = m.Name + "Specified";
isSpecified = (bool)GetMemberValue(o, specifiedMemberName);
}
if (m.CheckShouldPersist)
{
string methodInvoke = "ShouldSerialize" + m.Name;
MethodInfo method = o.GetType().GetTypeInfo().GetDeclaredMethod(methodInvoke);
shouldPersist = (bool)method.Invoke(o, Array.Empty <object>());
}
if (m.Attribute != null)
{
if (isSpecified && shouldPersist)
{
WriteMember(memberValue, m.Attribute, m.TypeDesc, o);
}
}
}
for (int i = 0; i < members.Length; i++)
{
MemberMapping m = members[i];
string memberName = m.Name;
object memberValue = GetMemberValue(o, memberName);
bool isSpecified = true;
bool shouldPersist = true;
if (m.CheckSpecified != SpecifiedAccessor.None)
{
string specifiedMemberName = m.Name + "Specified";
isSpecified = (bool)GetMemberValue(o, specifiedMemberName);
}
if (m.CheckShouldPersist)
{
string methodInvoke = "ShouldSerialize" + m.Name;
MethodInfo method = o.GetType().GetTypeInfo().GetDeclaredMethod(methodInvoke);
shouldPersist = (bool)method.Invoke(o, Array.Empty <object>());
}
if (m.Xmlns != null)
{
continue;
}
bool checkShouldPersist = m.CheckShouldPersist && (m.Elements.Length > 0 || m.Text != null);
if (!checkShouldPersist)
{
shouldPersist = true;
}
object choiceSource = null;
if (m.ChoiceIdentifier != null)
{
choiceSource = GetMemberValue(o, m.ChoiceIdentifier.MemberName);
}
if (isSpecified && shouldPersist)
{
WriteMember(memberValue, choiceSource, m.ElementsSortedByDerivation, m.Text, m.ChoiceIdentifier, m.TypeDesc, true, parentMapping);
}
}
if (!mapping.IsSoap)
{
WriteEndElement(o);
}
}
}
private bool WriteEnumAndArrayTypes(StructMapping structMapping, object o, string n, string ns, XmlMapping parentMapping)
{
if (o is Enum)
{
Writer.WriteStartElement(n, ns);
EnumMapping enumMapping = null;
Type enumType = o.GetType();
foreach (var m in parentMapping.Scope.TypeMappings)
{
var em = m as EnumMapping;
if (em != null && em.TypeDesc.Type == enumType)
{
enumMapping = em;
break;
}
}
Debug.Assert(enumMapping != null);
WriteXsiType(enumMapping.TypeName, ns);
Writer.WriteString(WriteEnumMethod(enumMapping, o));
Writer.WriteEndElement();
return(true);
}
if (o is Array)
{
Debug.Assert(parentMapping != null);
Writer.WriteStartElement(n, ns);
ArrayMapping arrayMapping = null;
Type arrayType = o.GetType();
foreach (var m in parentMapping.Scope.TypeMappings)
{
var am = m as ArrayMapping;
if (am != null && am.TypeDesc.Type == arrayType)
{
arrayMapping = am;
break;
}
}
Debug.Assert(arrayMapping != null);
WriteXsiType(arrayMapping.TypeName, ns);
WriteMember(o, null, arrayMapping.ElementsSortedByDerivation, null, null, arrayMapping.TypeDesc, true);
Writer.WriteEndElement();
return(true);
}
return(false);
}
public static System.Reflection.Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings, System.CodeDom.Compiler.CompilerParameters parameters)
{
}
public static System.Reflection.Assembly GenerateSerializer(Type[] types, XmlMapping[] mappings)
{
}
/// <summary>
/// Method to simplify addMapping
/// </summary>
/// <param name="mapping">Mapping to add</param>
private void addMapping(XmlMapping mapping)
{
this.ImportMappings.Add(mapping);
}
internal static TempAssembly GenerateTempAssembly(XmlMapping xmlMapping, Type type, string defaultNamespace)
{
return(GenerateTempAssembly(xmlMapping, type, defaultNamespace, null));
}
private void WriteElement(object o, ElementAccessor element, string arrayName, bool writeAccessor, XmlMapping parentMapping = null)
{
string name = writeAccessor ? element.Name : element.Mapping.TypeName;
string ns = element.Any && element.Name.Length == 0 ? null : (element.Form == XmlSchemaForm.Qualified ? (writeAccessor ? element.Namespace : element.Mapping.Namespace) : "");
if (element.Mapping is NullableMapping)
{
if (o != null)
{
ElementAccessor e = element.Clone();
e.Mapping = ((NullableMapping)element.Mapping).BaseMapping;
WriteElement(o, e, arrayName, writeAccessor);
}
else if (element.IsNullable)
{
WriteNullTagLiteral(element.Name, ns);
}
}
else if (element.Mapping is ArrayMapping)
{
var mapping = (ArrayMapping)element.Mapping;
if (element.IsNullable && o == null)
{
WriteNullTagLiteral(element.Name, element.Form == XmlSchemaForm.Qualified ? element.Namespace : "");
}
else if (mapping.IsSoap)
{
if (mapping.Elements == null || mapping.Elements.Length != 1)
{
throw new InvalidOperationException(SR.XmlInternalError);
}
var itemElement = mapping.Elements[0];
var itemMapping = itemElement.Mapping as StructMapping;
var itemName = writeAccessor ? itemElement.Name : itemMapping.TypeName;
var itemNamespace = itemElement.Any && itemElement.Name.Length == 0 ? null : (itemElement.Form == XmlSchemaForm.Qualified ? (writeAccessor ? itemElement.Namespace : itemMapping.Namespace) : "");
if (!writeAccessor)
{
WritePotentiallyReferencingElement(name, ns, o, mapping.TypeDesc.Type, true, element.IsNullable);
}
else
{
WritePotentiallyReferencingElement(name, ns, o, null, false, element.IsNullable);
}
}
else if (element.IsUnbounded)
{
TypeDesc arrayTypeDesc = mapping.TypeDesc.CreateArrayTypeDesc();
var enumerable = (IEnumerable)o;
foreach (var e in enumerable)
{
element.IsUnbounded = false;
WriteElement(e, element, arrayName, writeAccessor);
element.IsUnbounded = true;
}
}
else
{
if (o != null)
{
WriteStartElement(name, ns, false);
WriteArrayItems(mapping.ElementsSortedByDerivation, null, null, mapping.TypeDesc, o);
WriteEndElement();
}
}
}
else if (element.Mapping is EnumMapping)
{
if (element.Mapping.IsSoap)
{
Writer.WriteStartElement(name, ns);
WriteEnumMethod((EnumMapping)element.Mapping, o);
WriteEndElement();
}
else
{
WritePrimitive(WritePrimitiveMethodRequirement.WriteElementString, name, ns, element.Default, o, element.Mapping, false, true, element.IsNullable);
}
}
else if (element.Mapping is PrimitiveMapping)
{
PrimitiveMapping mapping = (PrimitiveMapping)element.Mapping;
if (mapping.TypeDesc == QnameTypeDesc)
{
WriteQualifiedNameElement(name, ns, element.Default, (XmlQualifiedName)o, element.IsNullable, mapping.IsSoap, mapping);
}
else
{
WritePrimitiveMethodRequirement suffixNullable = mapping.IsSoap ? WritePrimitiveMethodRequirement.Encoded : WritePrimitiveMethodRequirement.None;
WritePrimitiveMethodRequirement suffixRaw = mapping.TypeDesc.XmlEncodingNotRequired ? WritePrimitiveMethodRequirement.Raw : WritePrimitiveMethodRequirement.None;
WritePrimitive(element.IsNullable
? WritePrimitiveMethodRequirement.WriteNullableStringLiteral | suffixNullable | suffixRaw
: WritePrimitiveMethodRequirement.WriteElementString | suffixRaw,
name, ns, element.Default, o, mapping, mapping.IsSoap, true, element.IsNullable);
}
}
else if (element.Mapping is StructMapping)
{
var mapping = (StructMapping)element.Mapping;
if (mapping.IsSoap)
{
WritePotentiallyReferencingElement(name, ns, o, !writeAccessor ? mapping.TypeDesc.Type : null, !writeAccessor, element.IsNullable);
}
else
{
WriteStructMethod(mapping, name, ns, o, element.IsNullable, needType: false, parentMapping: parentMapping);
}
}
else if (element.Mapping is SpecialMapping)
{
if (element.Mapping is SerializableMapping)
{
WriteSerializable((IXmlSerializable)o, name, ns, element.IsNullable, !element.Any);
}
else
{
// XmlNode, XmlElement
var node = o as XmlNode;
if (node != null)
{
WriteElementLiteral(node, name, ns, element.IsNullable, element.Any);
}
else
{
throw CreateInvalidAnyTypeException(o);
}
}
}
else
{
throw new InvalidOperationException(SR.XmlInternalError);
}
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings);
private void WriteElements(object o, object enumSource, ElementAccessor[] elements, TextAccessor text, ChoiceIdentifierAccessor choice, string arrayName, bool writeAccessors, bool isNullable, XmlMapping parentMapping = null)
{
if (elements.Length == 0 && text == null)
{
return;
}
if (elements.Length == 1 && text == null)
{
WriteElement(o, elements[0], arrayName, writeAccessors, parentMapping);
}
else
{
if (isNullable && choice == null && o == null)
{
return;
}
int anyCount = 0;
var namedAnys = new List <ElementAccessor>();
ElementAccessor unnamedAny = null; // can only have one
string enumTypeName = choice == null ? null : choice.Mapping.TypeDesc.FullName;
for (int i = 0; i < elements.Length; i++)
{
ElementAccessor element = elements[i];
if (element.Any)
{
anyCount++;
if (element.Name != null && element.Name.Length > 0)
{
namedAnys.Add(element);
}
else if (unnamedAny == null)
{
unnamedAny = element;
}
}
else if (choice != null)
{
if (o != null && o.GetType() == element.Mapping.TypeDesc.Type)
{
WriteElement(o, element, arrayName, writeAccessors);
return;
}
}
else
{
TypeDesc td = element.IsUnbounded ? element.Mapping.TypeDesc.CreateArrayTypeDesc() : element.Mapping.TypeDesc;
if (o.GetType() == td.Type)
{
WriteElement(o, element, arrayName, writeAccessors);
return;
}
}
}
if (anyCount > 0)
{
var elem = o as XmlElement;
if (elem != null)
{
foreach (ElementAccessor element in namedAnys)
{
if (element.Name == elem.Name && element.Namespace == elem.NamespaceURI)
{
WriteElement(elem, element, arrayName, writeAccessors);
return;
}
}
if (choice != null)
{
throw CreateChoiceIdentifierValueException(choice.Mapping.TypeDesc.FullName, choice.MemberName, elem.Name, elem.NamespaceURI);
}
if (unnamedAny != null)
{
WriteElement(elem, unnamedAny, arrayName, writeAccessors);
return;
}
throw CreateUnknownAnyElementException(elem.Name, elem.NamespaceURI);
}
}
if (text != null)
{
bool useReflection = text.Mapping.TypeDesc.UseReflection;
string fullTypeName = text.Mapping.TypeDesc.CSharpName;
WriteText(o, text);
return;
}
if (elements.Length > 0 && o != null)
{
throw CreateUnknownTypeException(o);
}
}
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, Type type)
{
}
private void importData(XmlMapping currentMapping)
{
SetParent(currentMapping);
var template = (SCItems.TemplateItem) this.GetItem(currentMapping.TemplateID);
var ds = currentMapping.Source.Source;
this._currentItemIndex = 0;
for (; _currentItemIndex < this.currentFileList.Length; this._currentItemIndex++)
{
if (checkContinue())
{
// run process to import the actual data
try
{
// load the xml document from file into an xdocument
var currentFileItem = this.currentFileList[this._currentItemIndex];
var currentXdoc = new XmlDocument();
currentXdoc.Load(currentFileItem.FullName);
// select name element by xpath
var nameElement = currentXdoc.SelectSingleNode(currentMapping.NameNodePath);
var name = nameElement == null ? "" : nameElement.Value ?? nameElement.InnerText;
if (string.IsNullOrWhiteSpace(name))
{
LogStatus("Name and Parent cannot be blank.", currentFileItem.Name);
continue;
}
if (currentMapping.CleanNames)
{
name = SCItems.ItemUtil.ProposeValidItemName(name);
}
// get parent according to import settings
var parent = this.getParent(currentMapping, currentXdoc);
// only proceed if a parent and name are present since they are required by Sitecore
if (string.IsNullOrWhiteSpace(name) || parent == null)
{
LogStatus("Name and Parent cannot be blank.", currentFileItem.Name);
continue;
}
var newItem = template.CreateItemFrom(name, parent);
fileToItemList.Add(currentFileItem.FullName, newItem.ID); // this allows quick reference to all processed files related to a Sitecore item
var fields = newItem.GetEditableFields();
using (new SC.SecurityModel.SecurityDisabler())
{
using (new SCItems.EditContext(newItem))
{
foreach (var mapping in currentMapping.FieldMappings)
{
try
{
var field = fields.FirstOrDefault(f => f.Name.ToLower() == mapping.FieldName.ToLower());
if (field != null)
{
var fieldElement = currentXdoc.SelectSingleNode(mapping.XPath);
var fieldValue = fieldElement == null ? "" : fieldElement.Value ?? fieldElement.InnerText;
if (!string.IsNullOrWhiteSpace(fieldValue))
{
field.SetValueByType(fieldValue);
}
}
}
catch (Exception ex)
{
LogStatus($"[Field: {mapping.FieldName}] {ex.Message}", currentFileItem.Name);
}
}
}
}
this.CurrentPercent = ((this._currentItemIndex + 1) * 100) / this.currentFileList.Length;
if (this.IsAsync)
{
this.BgWorker.ReportProgress(this.CurrentPercent, currentMapping.Source.Name);
}
}
catch (Exception ex)
{
LogStatus(ex.Message);
}
}
else
{
break;
}
}
}
public XmlSerializerMappingKey(XmlMapping mapping)
{
this.Mapping = mapping;
}
public static XmlSerializer[] FromMappings(XmlMapping[] mappings, System.Security.Policy.Evidence evidence)
{
}