void ExportCore(object selectedObject, IEnumerable <IClassInfoGraphNode> serializedClassInfoGraphNodes,
XElement root, ElementSchema elementSchema)
{
var typeInfo = XafTypesInfo.Instance.FindTypeInfo(selectedObject.GetType());
var objectInfo = new ObjectInfo(selectedObject.GetType(), typeInfo.KeyMember.GetValue(selectedObject));
if (!(_exportedObjecs.ContainsKey(objectInfo)))
{
_exportedObjecs.Add(objectInfo, null);
var serializedObjectElement = new XElement(elementSchema.SerializedObject);
serializedObjectElement.Add(new XAttribute(elementSchema.Type, selectedObject.GetType().Name));
root.Add(serializedObjectElement);
foreach (var classInfoGraphNode in serializedClassInfoGraphNodes.Where(
node => node.SerializationStrategy != SerializationStrategy.DoNotSerialize))
{
var propertyElement = GetPropertyElement(serializedObjectElement, classInfoGraphNode, elementSchema);
switch (classInfoGraphNode.NodeType)
{
case NodeType.Simple:
SetMemberValue(typeInfo, selectedObject, classInfoGraphNode, propertyElement);
break;
case NodeType.Object:
CreateObjectProperty(typeInfo, selectedObject, propertyElement, classInfoGraphNode, root, elementSchema);
break;
case NodeType.Collection:
CreateCollectionProperty(typeInfo, selectedObject, classInfoGraphNode, root, propertyElement, elementSchema);
break;
}
}
}
}
void HandleError(XElement element, FailReason failReason, ElementSchema elementSchema, IObjectSpace objectSpace = null)
{
objectSpace = objectSpace ?? _objectSpace;
string innerXml = null;
string elementXml;
var firstOrDefault = element.Ancestors(elementSchema.SerializedObject).FirstOrDefault();
if (firstOrDefault != null && firstOrDefault != element)
{
innerXml = element.ToString();
elementXml = firstOrDefault.ToString();
}
else
{
elementXml = element.ToString();
}
if (_errorHandling == ErrorHandling.CreateErrorObjects)
{
var errorInfoObject = objectSpace.Create <IIOError>();
errorInfoObject.Reason = failReason;
errorInfoObject.ElementXml = elementXml;
errorInfoObject.InnerXml = innerXml;
objectSpace.CommitChanges();
throw new UserFriendlyException("Import failed check IOError list for details.");
}
if (_errorHandling == ErrorHandling.ThrowException)
{
throw new UserFriendlyException(new Exception("ImportFailed", new Exception("Reason=" + failReason + "ELEMENTXML=" + elementXml + " INNERXML=" + innerXml)));
}
}
public static string GetTypeAttributeValue(this XElement element, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
var value = element.GetAttributeValue(elementSchema.Type);
return(string.IsNullOrEmpty(value) ? NodeType.Simple.ToString().MakeFirstCharLower() : value);
}
ITypeInfo GetTypeInfo(XElement element, ElementSchema elementSchema, IObjectSpace objectSpace)
{
var typeInfo = ReflectionHelper.FindTypeInfoByName(element.GetAttributeValue(elementSchema.Type));
if (typeInfo == null)
{
HandleError(element, FailReason.TypeNotFound, elementSchema, objectSpace);
}
return(typeInfo);
}
object GetObject(XElement element, ITypeInfo typeInfo, CriteriaOperator criteriaOperator,
ElementSchema elementSchema)
{
if (!ReferenceEquals(criteriaOperator, null))
{
var theObject = _objectSpace.ModifiedObjects.Cast <object>().FirstOrDefault(o => IsAlreadyCreated(typeInfo, criteriaOperator, o));
var objectKeyCriteria = GetObjectKeyCriteria(typeInfo, GetKeys(element, elementSchema), elementSchema);
return(theObject ??
((UnitOfWork)_objectSpace.Session()).FindObject(typeInfo.QueryXPClassInfo(), objectKeyCriteria, true) ?? _objectSpace.CreateObject(typeInfo.Type));
}
return(null);
}
static IEnumerable <XElement> GetKeys(XElement element, ElementSchema elementSchema)
{
if (element.GetAttributeValue(elementSchema.Strategy) == SerializationStrategy.SerializeAsValue.ToString())
{
return(element.Descendants(elementSchema.Key));
}
IEnumerable <XElement> elements = element.Descendants(elementSchema.Property);
var xElements =
elements.Where(xElement => xElement.GetAttributeValue(elementSchema.IsKey).FirstCharacterToUpper() == true.ToString(CultureInfo.InvariantCulture));
return(xElements);
}
object CreateObject(XElement element, ITypeInfo typeInfo, CriteriaOperator objectKeyCriteria,
ElementSchema elementSchema)
{
var xpBaseObject = GetObject(element, typeInfo, objectKeyCriteria, elementSchema);
var keyValuePair = new KeyValuePair <ITypeInfo, CriteriaOperator>(typeInfo, objectKeyCriteria);
if (!_importedObjects.ContainsKey(keyValuePair))
{
_importedObjects.Add(keyValuePair, null);
ImportProperties(typeInfo, xpBaseObject, element, elementSchema);
}
return(xpBaseObject);
}
void CreateCollectionProperty(ITypeInfo typeInfo, object selectedObject, IClassInfoGraphNode classInfoGraphNode,
XElement root, XElement propertyElement, ElementSchema elementSchema)
{
var memberInfo = typeInfo.FindMember(classInfoGraphNode.Name);
if (memberInfo?.GetValue(selectedObject) is IEnumerable theObjects)
{
foreach (var theObject in theObjects)
{
CreateRefElelement(classInfoGraphNode, theObject.GetType(), root, theObject, propertyElement, elementSchema);
}
}
}
public static ElementSchema Get(bool minifyOutput)
{
_defaultSchema = _defaultSchema ?? new ElementSchema()
{
SerializedObjectRef = "SerializedObjectRef", Name = "name", IsKey = "isKey", Property = "Property",
Strategy = "strategy", Type = "type", SerializedObjects = "SerializedObjects",
SerializedObject = "SerializedObject", Key = "Key"
};
_minimalSchema = _minimalSchema ?? new ElementSchema {
IsMinified = true,
SerializedObjectRef = "a", Name = "b", IsKey = "c", Property = "d",
Strategy = "e", Type = "f", SerializedObjects = "g",
SerializedObject = "h", Key = "j"
};
return(minifyOutput ? _minimalSchema : _defaultSchema);
}
XElement GetPropertyElement(XElement serializedObjectElement, IClassInfoGraphNode classInfoGraphNode,
ElementSchema elementSchema)
{
var propertyElement = new XElement(elementSchema.Property);
serializedObjectElement.Add(propertyElement);
if ((_minifyOutput && classInfoGraphNode.NodeType != NodeType.Simple) || !_minifyOutput)
{
propertyElement.Add(new XAttribute(elementSchema.Type, classInfoGraphNode.NodeType.ToString().FirstCharacterToLower()));
}
propertyElement.Add(new XAttribute(elementSchema.Name, classInfoGraphNode.Name));
if ((_minifyOutput && classInfoGraphNode.Key) || !_minifyOutput)
{
propertyElement.Add(new XAttribute(elementSchema.IsKey, classInfoGraphNode.Key));
}
return(propertyElement);
}
void CreateRefElelement(IClassInfoGraphNode classInfoGraphNode, Type objectType, XElement root,
object theObject, XElement propertyElement, ElementSchema elementSchema)
{
var serializedObjectRefElement = new XElement(elementSchema.SerializedObjectRef);
propertyElement.Add(serializedObjectRefElement);
serializedObjectRefElement.Add(new XAttribute(elementSchema.Type, objectType.Name));
serializedObjectRefElement.Add(new XAttribute(elementSchema.Strategy, classInfoGraphNode.SerializationStrategy));
if (theObject != null)
{
var classInfoGraphNodes = _serializeClassInfoGraphNodesCalculator.GetSerializedClassInfoGraphNodes(theObject, objectType.Name).ToArray();
CreateRefKeyElements(XafTypesInfo.CastTypeToTypeInfo(objectType), classInfoGraphNodes, theObject, serializedObjectRefElement, elementSchema);
if (classInfoGraphNode.SerializationStrategy == SerializationStrategy.SerializeAsObject)
{
ExportCore(theObject, classInfoGraphNodes, root, elementSchema);
}
}
}
public static XElement FindObjectFromRefenceElement(this XElement xElement, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
var typeValue = xElement.GetTypeAttributeValue(minifyOutput);
var infos = xElement.Descendants(elementSchema.Key).Select(
element1 => new { Element = element1, Name = element1.GetAttributeValue(elementSchema.Name), element1.Value });
var select =
xElement.Document?.Root?.SerializedObjects(minifyOutput).Where(
element => element.GetTypeAttributeValue(minifyOutput) == typeValue).Descendants(elementSchema.Property).Where(
xElement1 => xElement1.GetAttributeValue(elementSchema.IsKey) == "true").
Select(element1 =>
new { Element = element1.Parent, Name = element1.GetAttributeValue(elementSchema.Name), element1.Value });
return
(select?.Where(
arg => infos.Any(arg1 => arg.Name == arg1.Name && arg.Value == arg1.Value)).
Select(arg2 => arg2.Element).FirstOrDefault());
}
public XDocument Export(IEnumerable <object> baseCollection,
ISerializationConfigurationGroup serializationConfigurationGroup)
{
var xDocument = new XDocument();
_minifyOutput = serializationConfigurationGroup.MinifyOutput;
var elementInfo = ElementSchema.Get(_minifyOutput);
var root = new XElement(elementInfo.SerializedObjects);
root.Add(new XAttribute(ElementSchema.Minified, _minifyOutput));
xDocument.Add(root);
_serializeClassInfoGraphNodesCalculator =
new SerializeClassInfoGraphNodesCalculator(serializationConfigurationGroup, _objectSpace);
foreach (var baseObject in baseCollection)
{
var serializedClassInfoGraphNodes = _serializeClassInfoGraphNodesCalculator.GetSerializedClassInfoGraphNodes(baseObject);
ExportCore(baseObject, serializedClassInfoGraphNodes, root, elementInfo);
}
return(xDocument);
}
int ImportObjects(XDocument document, Func <ITypeInfo, IObjectSpace> objectSpaceQuery)
{
if (document.Root != null)
{
var elementInfo = ElementSchema.Get(document);
_errorObjectSpace = _errorObjectSpace ?? objectSpaceQuery(null);
foreach (var element in document.Root.Nodes().OfType <XElement>())
{
var typeInfo = GetTypeInfo(element, elementInfo, _errorObjectSpace);
_objectSpace = _objectSpace ?? objectSpaceQuery(typeInfo);
var keys = GetKeys(element, elementInfo);
var objectKeyCriteria = GetObjectKeyCriteria(typeInfo, keys, elementInfo);
if (!ReferenceEquals(objectKeyCriteria, null))
{
CreateObject(element, typeInfo, objectKeyCriteria, elementInfo);
}
}
_objectSpace.CommitChanges();
}
return(0);
}
void ImportComplexProperties(XElement element, Action <object, XElement> instance, NodeType nodeType,
ElementSchema elementSchema)
{
var objectElements = GetObjectRefElements(element, nodeType, elementSchema);
var typeInfo = GetTypeInfo(element, elementSchema, _errorObjectSpace);
foreach (var objectElement in objectElements)
{
var memberTypeInfo = GetTypeInfo(objectElement, elementSchema, _errorObjectSpace);
if (memberTypeInfo != null)
{
var refObjectKeyCriteria = GetObjectKeyCriteria(memberTypeInfo, objectElement.Descendants(elementSchema.Key), elementSchema);
object xpBaseObject = null;
var element1 = objectElement;
if (objectElement.GetAttributeValue(elementSchema.Strategy) ==
SerializationStrategy.SerializeAsObject.ToString())
{
var findObjectFromRefenceElement = objectElement.FindObjectFromRefenceElement(elementSchema.IsMinified);
HandleErrorComplex(objectElement, typeInfo, () => {
if (findObjectFromRefenceElement != null)
{
xpBaseObject = CreateObject(findObjectFromRefenceElement, memberTypeInfo, refObjectKeyCriteria, elementSchema);
}
instance.Invoke(xpBaseObject, element1);
}, elementSchema);
}
else
{
HandleErrorComplex(objectElement, typeInfo, () => {
xpBaseObject = GetObject(objectElement, memberTypeInfo, refObjectKeyCriteria, elementSchema);
instance.Invoke(xpBaseObject, element1);
}, elementSchema);
}
}
}
}
public static XElement Property(this IEnumerable <XElement> properties, string name, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(properties.FirstOrDefault(element => element.GetAttributeValue(elementSchema.Name) == name));
}
public static IEnumerable <XElement> Properties(this XElement element, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(element.Descendants(elementSchema.Property));
}
public static IEnumerable <XElement> Properties(this IEnumerable <XElement> elements, NodeType nodeType, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(elements.Descendants(elementSchema.Property).Where(xElement => xElement.GetTypeAttributeValue(minifyOutput) == nodeType.ToString().MakeFirstCharLower()));
}
public static IEnumerable <XElement> ObjectKeyProperties(this XElement element, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(element.Descendants(elementSchema.Property).Where(xElement => xElement.GetAttributeValue(elementSchema.IsKey) == "true"));
}
IEnumerable <XElement> GetObjectRefElements(XElement element, NodeType nodeType, ElementSchema elementSchema)
{
return(element.Properties(nodeType, elementSchema.IsMinified).SelectMany(
element1 => element1.Descendants(elementSchema.SerializedObjectRef)));
}
void ImportSimpleProperties(ITypeInfo typeInfo, XElement element, object theObject, ElementSchema elementSchema)
{
foreach (XElement simpleElement in element.Properties(NodeType.Simple, elementSchema.IsMinified))
{
string propertyName = simpleElement.GetAttributeValue(elementSchema.Name);
var memberInfo = typeInfo.FindMember(propertyName);
if (memberInfo != null)
{
object value = GetValue(simpleElement, memberInfo);
typeInfo.FindMember(propertyName).SetValue(theObject, value);
}
else
{
HandleError(simpleElement, FailReason.PropertyNotFound, elementSchema);
}
}
}
void CreateObjectProperty(ITypeInfo typeInfo, object selectedObject, XElement propertyElement,
IClassInfoGraphNode classInfoGraphNode, XElement root, ElementSchema elementSchema)
{
var memberInfo = typeInfo.FindMember(classInfoGraphNode.Name);
if (memberInfo != null)
{
var theObject = (XPBaseObject)memberInfo.GetValue(selectedObject);
CreateRefElelement(classInfoGraphNode, theObject?.GetType() ?? memberInfo.MemberType, root, theObject, propertyElement, elementSchema);
}
}
private void HandleErrorComplex(XElement objectElement, ITypeInfo typeInfo, Action action, ElementSchema elementSchema)
{
var memberInfo = typeInfo.FindMember(objectElement.Parent.GetAttributeValue(elementSchema.Name));
if (memberInfo != null)
{
action.Invoke();
}
else
{
HandleError(objectElement, FailReason.PropertyNotFound, elementSchema);
}
}
public static IEnumerable <XElement> KeyElements(this IEnumerable <XElement> element, string name, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(element.Descendants(elementSchema.Key).Where(xElement => xElement.GetAttributeValue(elementSchema.Name) == name));
}
public static XElement ObjectProperty(this XElement element, string name, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(element.Descendants(elementSchema.Property).FirstOrDefault(xElement => xElement.GetAttributeValue(elementSchema.Name) == name));
}
CriteriaOperator GetObjectKeyCriteria(ITypeInfo typeInfo, IEnumerable <XElement> xElements, ElementSchema elementSchema, string prefix = "")
{
CriteriaOperator op = CriteriaOperator.Parse("");
foreach (var xElement in xElements)
{
var propertyName = xElement.GetAttributeValue(elementSchema.Name);
var iMemberInfo = typeInfo.FindMember(propertyName);
if (iMemberInfo != null)
{
var memberType = iMemberInfo.MemberTypeInfo;
if (typeof(XPBaseObject).IsAssignableFrom(memberType.Type))
{
op &= GetObjectKeyCriteria(memberType, xElement.Elements().First().Elements(), elementSchema, prefix + propertyName + ".");
}
else if (iMemberInfo.MemberType == typeof(Type))
{
var typeName = (string)GetValue(typeof(string), xElement);
var type = XafTypesInfo.Instance.FindTypeInfo(typeName).Type;
op &= CriteriaOperator.Parse(prefix + propertyName + "=?", type);
}
else
{
op &= CriteriaOperator.Parse(prefix + propertyName + "=?", XpandReflectionHelper.ChangeType(GetValue(iMemberInfo.MemberType, xElement), memberType.Type));
}
}
else
{
HandleError(xElement, FailReason.PropertyNotFound, elementSchema);
}
}
return(op);
}
public static IEnumerable <XElement> SerializedObjectRefs(this IEnumerable <XElement> elements, SerializationStrategy serializationStrategy, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(elements.Where(element => element.GetAttributeValue(elementSchema.Strategy) == serializationStrategy.ToString()));
}
void CreateRefKeyElements(ITypeInfo typeInfo, IEnumerable <IClassInfoGraphNode> serializedClassInfoGraphNodes,
object theObject, XElement serializedObjectRefElement, ElementSchema elementSchema)
{
foreach (var infoGraphNode in serializedClassInfoGraphNodes.Where(node => node.Key))
{
var serializedObjectRefKeyElement = new XElement(elementSchema.Key);
serializedObjectRefKeyElement.Add(new XAttribute(elementSchema.Name, infoGraphNode.Name));
serializedObjectRefKeyElement.Value = typeInfo.FindMember(infoGraphNode.Name).GetValue(theObject) + "";
serializedObjectRefElement.Add(serializedObjectRefKeyElement);
}
}
public static IEnumerable <XElement> SerializedObjectRefs(this XElement element, bool minifyOutput)
{
var elementSchema = ElementSchema.Get(minifyOutput);
return(element.Descendants(elementSchema.SerializedObjectRef));
}
void ImportProperties(ITypeInfo typeInfo, object theObject, XElement element, ElementSchema elementSchema)
{
ImportSimpleProperties(typeInfo, element, theObject, elementSchema);
ImportComplexProperties(element, (value, xElement) =>
typeInfo.FindMember(xElement.Parent.GetAttributeValue(elementSchema.Name)).SetValue(theObject, value),
NodeType.Object, elementSchema);
ImportComplexProperties(element, (baseObject, element1) =>
((IList)typeInfo.FindMember(element1.Parent.GetAttributeValue(elementSchema.Name)).GetValue(theObject)).Add(
baseObject), NodeType.Collection, elementSchema);
}
