/// <summary>
/// Deserializes an object
/// </summary>
/// <param name="stream">The source stream</param>
/// <param name="instance">The instance to receive the deserialized properties</param>
/// <param name="flags">One or more <see cref="SerializedFlags"/> options</param>
/// <param name="compression">Compression method to use</param>
public static bool Deserialize <T>(Stream stream, T instance, SerializerFlags flags, CompressionImplementation compression)
{
// Check args
Debug.Assert(stream != null, "Input stream is null");
if (stream == null)
{
throw new ArgumentNullException("stream");
}
return(Deserialize <T>(
GetReader(stream, flags, compression),
instance,
flags
));
}
static IPrimitiveReader GetReader(Stream stream, SerializerFlags flags, CompressionImplementation compression)
{
// Decompress source stream if necessary
if ((flags & SerializerFlags.Compress) != 0)
{
byte[] bytes = stream.ToArray();
bytes = Compressor.GetInstance().Decompress(bytes, compression);
MemoryStream ms = new MemoryStream(bytes);
stream = ms;
}
return(SerializerFactory.GetReader(stream));
}
public SyncAttempt <TObject> Deserialize(XElement node, SerializerFlags flags)
{
if (IsEmpty(node))
{
// new behavior when a node is 'empty' that is a marker for a delete or rename
// so we process that action here, no more action file/folders
return(ProcessAction(node, flags));
}
if (!IsValid(node))
{
throw new FormatException($"XML Not valid for type {ItemType}");
}
if (flags.HasFlag(SerializerFlags.Force) || IsCurrent(node) > ChangeType.NoChange)
{
logger.Debug <TObject>("Base: Deserializing");
var result = DeserializeCore(node);
if (result.Success)
{
if (!flags.HasFlag(SerializerFlags.DoNotSave))
{
// save
SaveItem(result.Item);
}
if (flags.HasFlag(SerializerFlags.OnePass))
{
logger.Debug <TObject>("Base: Second Pass");
var secondAttempt = DeserializeSecondPass(result.Item, node, flags);
if (secondAttempt.Success)
{
if (!flags.HasFlag(SerializerFlags.DoNotSave))
{
// save (again)
SaveItem(secondAttempt.Item);
}
}
}
}
return(result);
}
return(SyncAttempt <TObject> .Succeed(node.Name.LocalName, default(TObject), ChangeType.NoChange));
}
protected SyncAttempt <TObject> ProcessAction(XElement node, SerializerFlags flags)
{
if (!IsEmpty(node))
{
throw new ArgumentException("Cannot process actions on a non-empty node");
}
var actionType = node.Attribute("Change").ValueOrDefault <SyncActionType>(SyncActionType.None);
var(key, alias) = FindKeyAndAlias(node);
switch (actionType)
{
case SyncActionType.Delete:
return(ProcessDelete(key, alias, flags));
case SyncActionType.Rename:
return(ProcessRename(key, alias, flags));
default:
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.NoChange));
}
}
protected virtual SyncAttempt <TObject> CanDeserialize(XElement node, SerializerFlags flags) => CanDeserialize(node, new SyncSerializerOptions(flags));
protected virtual SyncAttempt <TObject> ProcessDelete(Guid key, string alias, SerializerFlags flags)
{
logger.Debug(serializerType, "Processing Delete {0} {1}", key, alias);
var item = this.FindItem(key);
if (item == null && !string.IsNullOrWhiteSpace(alias))
{
// we need to build in some awareness of alias matching in the folder
// because if someone deletes something in one place and creates it
// somewhere else the alias will exist, so we don't want to delete
// it from over there - this needs to be done at save time
// (bascially if a create happens) - turn any delete files into renames
// A Tree Based serializer will return null if you ask it to find
// an item soley by alias, so this means we are only deleting by key
// on tree's (e.g media, content)
item = this.FindItem(alias);
}
if (item != null)
{
logger.Debug(serializerType, "Deleting Item : {0}", ItemAlias(item));
DeleteItem(item);
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.Delete));
}
logger.Debug(serializerType, "Delete Item not found");
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.NoChange));
}
public virtual SyncAttempt <TObject> DeserializeSecondPass(TObject item, XElement node, SerializerFlags flags) => DeserializeSecondPass(item, node, new SyncSerializerOptions(flags));
public SyncSerializerOptions(SerializerFlags flags)
{
this.Flags = flags;
}
public override SyncAttempt <IContent> DeserializeSecondPass(IContent item, XElement node, SerializerFlags flags)
{
var attempt = DeserializeProperties(item, node);
if (!attempt.Success)
{
return(SyncAttempt <IContent> .Fail(item.Name, ChangeType.ImportFail, attempt.Exception));
}
// sort order
var sortOrder = node.Element("Info").Element("SortOrder").ValueOrDefault(-1);
HandleSortOrder(item, sortOrder);
var trashed = node.Element("Info").Element("Trashed").ValueOrDefault(false);
HandleTrashedState(item, trashed);
// published status
// this does the last save and publish
var saveAttempt = DoSaveOrPublish(item, node);
if (saveAttempt.Success)
{
// we say no change back, this stops the core second pass function from saving
// this item (which we have just done with DoSaveOrPublish)
return(SyncAttempt <IContent> .Succeed(item.Name, item, ChangeType.NoChange, attempt.Status));
}
return(SyncAttempt <IContent> .Fail(item.Name, item, ChangeType.ImportFail, $"{saveAttempt.Result} {attempt.Status}"));
}
public override SyncAttempt <ITemplate> DeserializeSecondPass(ITemplate item, XElement node, SerializerFlags flags)
{
var master = node.Element("Parent").ValueOrDefault(string.Empty);
if (master != string.Empty && item.MasterTemplateAlias != master)
{
logger.Debug <TemplateSerializer>("Looking for master {0}", master);
var masterItem = fileService.GetTemplate(master);
if (masterItem != null)
{
logger.Debug <TemplateSerializer>("Setting Master {0}", masterItem.Alias);
item.SetMasterTemplate(masterItem);
if (!flags.HasFlag(SerializerFlags.DoNotSave))
{
SaveItem(item);
}
}
}
return(SyncAttempt <ITemplate> .Succeed(item.Name, item, ChangeType.Import));
}
public void Read <T>(T instance, SerializerFlags flags) where T : ICustomSerializable
{
Serializer.Deserialize(stream, instance, flags);
}
/// <summary>
/// Deserializes an object
/// </summary>
/// <param name="stream">The source stream</param>
/// <param name="instance">The instance to receive the deserialized properties</param>
/// <param name="flags">One or more <see cref="SerializedFlags"/> options</param>
public static bool Deserialize <T>(Stream stream, T instance, SerializerFlags flags)
{
return(Deserialize <T>(stream, instance, flags, Compressor.DefaultCompressionImplementation));
}
/// <summary>
/// Deserializes an object from a stream into a pre-created empty object
/// </summary>
/// <typeparam name="T">The type of the object to deserialize</typeparam>
/// <param name="reader">Source stream</param>
/// <param name="instance">An empty instance of the type to deserialize</param>
/// <param name="flags"></param>
/// <returns>Returns true if the object was deserialized</returns>
public static bool Deserialize <T>(IPrimitiveReader reader, T instance, SerializerFlags flags)
{
object oi = instance;
return(Deserialize <T>(reader, ref oi, flags));
}
/// <summary>
/// CanDeserialize based on the flags, used to check the model is good, for this import
/// </summary>
/// <remarks>
/// used primarliy for checking parentage, but also can be used for checking things like create only.
/// </remarks>
protected virtual SyncAttempt <TObject> CanDeserialize(XElement node, SerializerFlags flags)
=> SyncAttempt <TObject> .Succeed("No Check", ChangeType.NoChange);
public virtual SyncAttempt <TObject> DeserializeSecondPass(TObject item, XElement node, SerializerFlags flags)
{
return(SyncAttempt <TObject> .Succeed(nameof(item), item, typeof(TObject), ChangeType.NoChange));
}
public override SyncAttempt <IMedia> DeserializeSecondPass(IMedia item, XElement node, SerializerFlags flags)
{
var propertyAttempt = DeserializeProperties(item, node);
if (!propertyAttempt.Success)
{
return(SyncAttempt <IMedia> .Fail(item.Name, ChangeType.Fail, "Failed to save properties", propertyAttempt.Exception));
}
var info = node.Element("Info");
var sortOrder = info.Element("SortOrder").ValueOrDefault(-1);
HandleSortOrder(item, sortOrder);
var trashed = info.Element("Trashed").ValueOrDefault(false);
HandleTrashedState(item, trashed);
var attempt = mediaService.Save(item);
if (!attempt.Success)
{
return(SyncAttempt <IMedia> .Fail(item.Name, ChangeType.Fail, ""));
}
// we return no-change so we don't trigger the second save
return(SyncAttempt <IMedia> .Succeed(item.Name, item, ChangeType.NoChange, propertyAttempt.Status));
}
public override SyncAttempt <IContentType> DeserializeSecondPass(IContentType item, XElement node, SerializerFlags flags)
{
logger.Debug <ContentTypeSerializer>("Deserialize Second Pass {0}", item.Alias);
DeserializeCompositions(item, node);
DeserializeStructure(item, node);
if (!flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
{
contentTypeService.Save(item);
}
CleanFolder(item, node);
return(SyncAttempt <IContentType> .Succeed(item.Name, item, ChangeType.Import));
}
public T Read <T>(SerializerFlags flags) where T : ICustomSerializable, new()
{
return(Serializer.Deserialize <T>(stream, flags));
}
public override SyncAttempt <IDictionaryItem> Import(string filePath, HandlerSettings config, SerializerFlags flags)
{
if (IsOneWay(config))
{
// only sync dictionary items if they are new
// so if it already exists we don't do the sync
//
// <Handler Alias="dictionaryHandler" Enabled="true">
// <Add Key="OneWay" Value="true" />
// </Handler>
//
var item = GetExistingItem(filePath);
if (item != null)
{
return(SyncAttempt <IDictionaryItem> .Succeed(item.ItemKey, ChangeType.NoChange));
}
}
return(base.Import(filePath, config, flags));
}
/// <summary>
/// second pass we set the default language again (because you can't just set it)
/// </summary>
public override SyncAttempt <ILanguage> DeserializeSecondPass(ILanguage item, XElement node, SerializerFlags flags)
{
logger.Debug <LanguageSerializer>("Language Second Pass {IsoCode}", item.IsoCode);
item.IsDefault = node.Element("IsDefault").ValueOrDefault(false);
var fallbackId = GetFallbackLanguageId(item, node);
if (fallbackId > 0)
{
item.FallbackLanguageId = fallbackId;
}
if (!flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
{
localizationService.Save(item);
}
return(SyncAttempt <ILanguage> .Succeed(item.CultureName, item, ChangeType.Import));
}
protected override SyncAttempt <Form> ProcessRename(Guid key, string alias, SerializerFlags flags) => SyncAttempt <Form> .Succeed(alias, ChangeType.NoChange);
public override SyncAttempt <IContent> DeserializeSecondPass(IContent item, XElement node, SerializerFlags flags)
{
DeserializeProperties(item, node);
// sort order
var sortOrder = node.Element("Info").Element("SortOrder").ValueOrDefault(-1);
if (sortOrder != -1)
{
item.SortOrder = sortOrder;
}
// published status
// this does the last save and publish
if (DoSaveOrPublish(item, node))
{
return(SyncAttempt <IContent> .Succeed(item.Name, ChangeType.Import));
}
return(SyncAttempt <IContent> .Fail(item.Name, ChangeType.ImportFail, ""));
// second pass, is when we do the publish and stuff.
}
public SyncSerializerOptions(SerializerFlags flags, Dictionary <string, string> settings)
: this(settings)
{
this.Flags = flags;
}
public override SyncAttempt <IMediaType> DeserializeSecondPass(IMediaType item, XElement node, SerializerFlags flags)
{
DeserializeCompositions(item, node);
DeserializeStructure(item, node);
if (!flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
{
mediaTypeService.Save(item);
}
return(SyncAttempt <IMediaType> .Succeed(item.Name, item, ChangeType.Import));
}
protected SyncAttempt <TObject> ProcessAction(XElement node, SerializerFlags flags) => ProcessAction(node, new SyncSerializerOptions(flags));
public override SyncAttempt <IMediaType> DeserializeSecondPass(IMediaType item, XElement node, SerializerFlags flags)
{
var contentType = CreateContentType(node);
return(base.DeserializeSecondPass(item, contentType, flags));
}
protected virtual SyncAttempt <TObject> ProcessRename(Guid key, string alias, SerializerFlags flags)
{
logger.Debug(serializerType, "Process Rename (no action)");
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.NoChange));
}
virtual public SyncAttempt <TObject> Import(string filePath, HandlerSettings config, SerializerFlags flags)
{
try
{
syncFileService.EnsureFileExists(filePath);
using (var stream = syncFileService.OpenRead(filePath))
{
var node = XElement.Load(stream);
var attempt = serializer.Deserialize(node, flags);
return(attempt);
}
}
catch (FileNotFoundException notFoundException)
{
return(SyncAttempt <TObject> .Fail(Path.GetFileName(filePath), ChangeType.Fail, $"File not found {notFoundException.Message}"));
}
catch (Exception ex)
{
return(SyncAttempt <TObject> .Fail(Path.GetFileName(filePath), ChangeType.Fail, $"Import Fail: {ex.Message}"));
}
}
public SyncAttempt <TObject> Deserialize(XElement node, SerializerFlags flags) => Deserialize(node, new SyncSerializerOptions(flags));
public override IEnumerable <uSyncAction> Import(string filePath, HandlerSettings config, SerializerFlags flags)
{
if (IsOneWay(config))
{
// only sync dictionary items if they are new
// so if it already exists we don't do the sync
//
// <Handler Alias="dictionaryHandler" Enabled="true">
// <Add Key="OneWay" Value="true" />
// </Handler>
//
var item = GetExistingItem(filePath);
if (item != null)
{
return(uSyncAction.SetAction(true, item.ItemKey, change: ChangeType.NoChange).AsEnumerableOfOne());
}
}
return(base.Import(filePath, config, flags));
}
