internal override SyncAttempt <XElement> SerializeCore(IContent item)
{
LogHelper.Debug <ContentSerializer>("Serialize Core: {0}", () => item.Name);
var ContentTypeAlias = item.ContentType.Alias;
var attempt = base.SerializeBase(item, ContentTypeAlias);
if (!attempt.Success)
{
return(attempt);
}
var node = attempt.Item;
// content specifics..
node.Add(new XAttribute("parentGUID", item.Level > 1 ? item.Parent().Key : new Guid("00000000-0000-0000-0000-000000000000")));
node.Add(new XAttribute("nodeTypeAlias", item.ContentType.Alias));
node.Add(new XAttribute("templateAlias", item.Template == null ? "" : item.Template.Alias));
node.Add(new XAttribute("sortOrder", item.SortOrder));
node.Add(new XAttribute("published", item.Published));
LogHelper.Debug <ContentSerializer>("Returning Node");
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(IContent), ChangeType.Export));
}
protected override SyncAttempt <IContent> DeserializeCore(XElement node, SyncSerializerOptions options)
{
var attempt = FindOrCreate(node);
if (!attempt.Success)
{
throw attempt.Exception;
}
var item = attempt.Result;
var details = new List <uSyncChange>();
var name = node.Name.LocalName;
if (name != string.Empty)
{
details.AddUpdate("Name", item.Name, name);
item.Name = name;
}
item.Blueprint = true;
details.AddRange(DeserializeBase(item, node, options));
// contentService.SaveBlueprint(item);
return(SyncAttempt <IContent> .Succeed(item.Name, item, ChangeType.Import, details));
}
public override SyncAttempt <IContentType> DesearlizeSecondPass(IContentType item, XElement node)
{
DeserializeStructure((IContentTypeBase)item, node);
_contentTypeService.Save(item);
return(SyncAttempt <IContentType> .Succeed(item.Name, item, ChangeType.Import));
}
public override SyncAttempt <IMedia> DeserializeSecondPass(IMedia item, XElement node, SyncSerializerOptions options)
{
var propertyAttempt = DeserializeProperties(item, node, options);
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, ""));
}
// setting the saved flag on the attempt to true, stops base classes from saving the item.
return(SyncAttempt <IMedia> .Succeed(item.Name, item, ChangeType.NoChange, propertyAttempt.Status, true,
propertyAttempt.Result));
}
protected override SyncAttempt <FormDataSource> DeserializeCore(XElement node, SyncSerializerOptions options)
{
var item = FindItem(node.GetAlias());
if (item == null)
{
item = new FormDataSource();
item.Id = node.GetKey();
}
var info = node.Element("Info");
if (info != null)
{
item.Name = info.Element("Name").ValueOrDefault(node.GetAlias());
item.FormDataSourceTypeId = info.Element("FormDataSourceTypeId").ValueOrDefault(Guid.Empty);
}
var settings = node.Element("Settings").ValueOrDefault(string.Empty);
if (!string.IsNullOrWhiteSpace(settings))
{
item.Settings = JsonConvert.DeserializeObject <Dictionary <string, string> >(settings);
}
// SaveItem(item);
return(SyncAttempt <FormDataSource> .Succeed(item.Name, item, ChangeType.Import));
}
protected override SyncAttempt <XElement> SerializeCore(IMemberType item, SyncSerializerOptions options)
{
var node = SerializeBase(item);
var info = SerializeInfo(item);
var parent = item.ContentTypeComposition.FirstOrDefault(x => x.Id == item.ParentId);
if (parent != null)
{
info.Add(new XElement("Parent", parent.Alias,
new XAttribute("Key", parent.Key)));
}
else if (item.Level != 1)
{
// in a folder
var folderNode = GetFolderNode(memberTypeService.GetContainers(item));
if (folderNode != null)
{
info.Add(folderNode);
}
}
info.Add(SerializeCompostions((ContentTypeCompositionBase)item));
node.Add(info);
node.Add(SerializeProperties(item));
node.Add(SerializeStructure(item));
node.Add(SerializeTabs(item));
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(IMediaType), ChangeType.Export));
}
public override SyncAttempt <IMedia> DesearlizeSecondPass(IMedia item, XElement node)
{
base.DeserializeMappedIds(item, node);
PublishOrSave(item, true, true);
return(SyncAttempt <IMedia> .Succeed(item.Name, ChangeType.Import));
}
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));
}
///////////////////////
protected override SyncAttempt <XElement> SerializeCore(IDataType item)
{
var node = InitializeBaseNode(item, item.Name, item.Level);
var info = new XElement("Info",
new XElement("Name", item.Name),
new XElement("EditorAlias", item.EditorAlias),
new XElement("DatabaseType", item.DatabaseType));
// new XElement("SortOrder", item.SortOrder));
if (item.Level != 1)
{
var folderNode = this.GetFolderNode(dataTypeService.GetContainers(item));
if (folderNode != null)
{
info.Add(folderNode);
}
}
node.Add(info);
var config = SerializeConfiguration(item);
if (config != null)
{
node.Add(config);
}
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(IDataType), ChangeType.Export));
}
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}"));
}
protected override SyncAttempt <IDataType> DeserializeCore(XElement node, SyncSerializerOptions options)
{
var info = node.Element("Info");
var name = info.Element("Name").ValueOrDefault(string.Empty);
var key = node.GetKey();
var attempt = FindOrCreate(node);
if (!attempt.Success)
{
throw attempt.Exception;
}
var details = new List <uSyncChange>();
var item = attempt.Result;
// basic
if (item.Name != name)
{
details.AddUpdate("Name", item.Name, name, "Name");
item.Name = name;
}
if (item.Key != key)
{
details.AddUpdate("Key", item.Key, key, "Key");
item.Key = key;
}
var editorAlias = info.Element("EditorAlias").ValueOrDefault(string.Empty);
if (editorAlias != item.EditorAlias)
{
// change the editor type.....
var newEditor = Current.DataEditors.FirstOrDefault(x => x.Alias.InvariantEquals(editorAlias));
if (newEditor != null)
{
details.AddUpdate("EditorAlias", item.EditorAlias, editorAlias, "EditorAlias");
item.Editor = newEditor;
}
}
// removing sort order - as its not used on datatypes,
// and can change based on minor things (so gives false out of sync results)
// item.SortOrder = info.Element("SortOrder").ValueOrDefault(0);
var dbType = info.Element("DatabaseType").ValueOrDefault(ValueStorageType.Nvarchar);
if (item.DatabaseType != dbType)
{
details.AddUpdate("DatabaseType", item.DatabaseType, dbType, "DatabaseType");
item.DatabaseType = dbType;
}
// config
details.AddRange(DeserializeConfiguration(item, node));
details.AddNotNull(SetFolderFromElement(item, info.Element("Folder")));
return(SyncAttempt <IDataType> .Succeed(item.Name, item, ChangeType.Import, details));
}
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));
}
protected override SyncAttempt <XElement> SerializeCore(IDictionaryItem item)
{
var node = InitializeBaseNode(item, item.ItemKey, GetLevel(item));
var info = new XElement("Info");
if (item.ParentId.HasValue)
{
var parent = FindItem(item.ParentId.Value);
if (parent != null)
{
info.Add(new XElement("Parent", parent.ItemKey));
}
}
var translationsNode = new XElement("Translations");
foreach (var translation in item.Translations)
{
translationsNode.Add(new XElement("Translation", translation.Value,
new XAttribute("Language", translation.Language.IsoCode)));
}
node.Add(info);
node.Add(translationsNode);
return(SyncAttempt <XElement> .Succeed(
item.ItemKey, node, typeof(IDictionaryItem), ChangeType.Export));
}
/// <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, SyncSerializerOptions options)
{
logger.Debug<LanguageSerializer>("Language Second Pass {IsoCode}", item.IsoCode);
var details = new List<uSyncChange>();
var isDefault = node.Element("IsDefault").ValueOrDefault(false);
if (item.IsDefault != isDefault)
{
details.AddUpdate("IsDefault", item.IsDefault, isDefault);
item.IsDefault = isDefault;
}
var fallbackId = GetFallbackLanguageId(item, node);
if (fallbackId > 0 && item.FallbackLanguageId != fallbackId)
{
details.AddUpdate("FallbackId", item.FallbackLanguageId, fallbackId);
item.FallbackLanguageId = fallbackId;
}
if (!options.Flags.HasFlag(SerializerFlags.DoNotSave) && item.IsDirty())
localizationService.Save(item);
return SyncAttempt<ILanguage>.Succeed(item.CultureName, item, ChangeType.Import, details);
}
protected override SyncAttempt <IContent> DeserializeCore(XElement node)
{
var item = FindOrCreate(node);
if (item.Trashed)
{
// TODO: Where has changed trashed state gone?
}
var name = node.Name.LocalName;
if (name != string.Empty)
{
item.Name = name;
}
item.Blueprint = true;
DeserializeBase(item, node);
// contentService.SaveBlueprint(item);
return(SyncAttempt <IContent> .Succeed(
item.Name,
item,
ChangeType.Import,
""));
}
protected override SyncAttempt <IMediaType> DeserializeCore(XElement node)
{
if (!IsValid(node))
{
throw new ArgumentException("Invalid XML Format");
}
var item = FindOrCreate(node);
DeserializeBase(item, node);
DeserializeTabs(item, node);
// mediaTypeService.Save(item);
DeserializeProperties(item, node);
CleanTabs(item, node);
// mediaTypeService.Save(item);
return(SyncAttempt <IMediaType> .Succeed(
item.Name,
item,
ChangeType.Import,
""));
}
internal SyncAttempt <XElement> SerializeBase(IContentBase item, string contentTypeAlias)
{
var node = new XElement(contentTypeAlias);
node.Add(new XAttribute("guid", item.Key.ToString().ToLower()));
node.Add(new XAttribute("id", item.Id));
node.Add(new XAttribute("nodeName", item.Name));
node.Add(new XAttribute("isDoc", ""));
node.Add(new XAttribute("updated", item.UpdateDate));
foreach (var prop in item.Properties.Where(p => p != null))
{
XElement propNode = null;
try
{
propNode = prop.ToXml();
}
catch
{
propNode = new XElement(prop.Alias, prop.Value);
}
string xml = "";
xml = GetExportIds(prop.PropertyType, propNode);
var updatedNode = XElement.Parse(
string.Format("<{0}>{1}</{0}>", propNode.Name.ToString(), xml), LoadOptions.PreserveWhitespace);
node.Add(updatedNode);
}
return(SyncAttempt <XElement> .Succeed(item.Name, node, item.GetType(), ChangeType.Export));
}
protected override SyncAttempt <IContentType> DeserializeCore(XElement node, SyncSerializerOptions options)
{
var attempt = FindOrCreate(node);
if (!attempt.Success)
{
throw attempt.Exception;
}
var item = attempt.Result;
var details = new List <uSyncChange>();
details.AddRange(DeserializeBase(item, node));
details.AddRange(DeserializeTabs(item, node));
details.AddRange(DeserializeProperties(item, node, options));
// content type only property stuff.
details.AddRange(DeserializeContentTypeProperties(item, node));
// clean tabs
details.AddRange(CleanTabs(item, node, options));
// templates
details.AddRange(DeserializeTemplates(item, node));
// contentTypeService.Save(item);
return(SyncAttempt <IContentType> .Succeed(item.Name, item, ChangeType.Import, details));
}
internal override SyncAttempt <XElement> SerializeCore(IMedia item)
{
var mediaTypeAlias = item.ContentType.Alias;
var attempt = base.SerializeBase(item, mediaTypeAlias);
if (!attempt.Success)
{
return(attempt);
}
var node = attempt.Item;
node.Add(new XAttribute("parentGUID", item.Level > 1 ? item.Parent().Key : new Guid("00000000-0000-0000-0000-000000000000")));
node.Add(new XAttribute("nodeTypeAlias", item.ContentType.Alias));
node.Add(new XAttribute("path", item.Path));
// if we are not moving the media then we just write the umbracoFile settings as we see them
//
if (!uSyncCoreContext.Instance.Configuration.Settings.MoveMedia)
{
// this is done in SerializeBase ?
}
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(IMedia), ChangeType.Export));
}
protected override SyncAttempt <IContentType> DeserializeCore(XElement node)
{
var item = FindOrCreate(node);
DeserializeBase(item, node);
DeserializeTabs(item, node);
DeserializeProperties(item, node);
// content type only property stuff.
DeserializeContentTypeProperties(item, node);
// clean tabs
CleanTabs(item, node);
// templates
DeserializeTemplates(item, node);
// contentTypeService.Save(item);
return(SyncAttempt <IContentType> .Succeed(
item.Name,
item,
ChangeType.Import,
""));
}
public override SyncAttempt <ITemplate> DeserializeSecondPass(ITemplate item, XElement node, SyncSerializerOptions options)
{
var details = new List <uSyncChange>();
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 && item.MasterTemplateAlias != master)
{
details.AddUpdate("Parent", item.MasterTemplateAlias, master);
logger.Debug <TemplateSerializer>("Setting Master {0}", masterItem.Alias);
item.SetMasterTemplate(masterItem);
if (!options.Flags.HasFlag(SerializerFlags.DoNotSave))
{
SaveItem(item);
}
}
}
return(SyncAttempt <ITemplate> .Succeed(item.Name, item, ChangeType.Import, details));
}
/// <summary>
/// Process the action in teh 'empty' XML node
/// </summary>
/// <param name="node">XML to process</param>
/// <param name="flags">Serializer flags to control options</param>
/// <returns>Sync attempt detailing changes</returns>
protected SyncAttempt <TObject> ProcessAction(XElement node, SyncSerializerOptions options)
{
if (!IsEmpty(node))
{
throw new ArgumentException("Cannot process actions on a non-empty node");
}
var actionType = node.Attribute("Change").ValueOrDefault <SyncActionType>(SyncActionType.None);
logger.Debug(serializerType, "Empty Node : Processing Action {0}", actionType);
var(key, alias) = FindKeyAndAlias(node);
switch (actionType)
{
case SyncActionType.Delete:
return(ProcessDelete(key, alias, options.Flags));
case SyncActionType.Rename:
return(ProcessRename(key, alias, options.Flags));
case SyncActionType.Clean:
// we return a 'clean' success, but this is then picked up
// in the handler, as something to clean, so the handler does it.
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.Clean));
default:
return(SyncAttempt <TObject> .Succeed(alias, ChangeType.NoChange));
}
}
/// <inheritdoc/>
protected override IEnumerable <uSyncAction> DeleteMissingItems(int parentId, IEnumerable <Guid> keys, bool reportOnly)
{
var items = GetChildItems(parentId).ToList();
logger.LogDebug("DeleteMissingItems: {parentId} Checking {itemCount} items for {keyCount} keys", parentId, items.Count, keys.Count());
var actions = new List <uSyncAction>();
foreach (var item in items.Where(x => !keys.Contains(x.Key)))
{
var name = String.Empty;
if (item is IEntitySlim slim)
{
name = slim.Name;
}
if (string.IsNullOrEmpty(name) || !reportOnly)
{
var actualItem = GetFromService(item.Key);
name = GetItemName(actualItem);
// actually do the delete if we are really not reporting
if (!reportOnly)
{
DeleteViaService(actualItem);
}
}
// for reporting - we use the entity name,
// this stops an extra lookup - which we may not need later
actions.Add(
uSyncActionHelper <TObject> .SetAction(SyncAttempt <TObject> .Succeed(name, ChangeType.Delete), string.Empty, item.Key, this.Alias));
}
return(actions);
}
protected override SyncAttempt <IMediaType> DeserializeCore(XElement node, SyncSerializerOptions options)
{
if (!IsValid(node))
{
throw new ArgumentException("Invalid XML Format");
}
var details = new List <uSyncChange>();
var attempt = FindOrCreate(node);
if (!attempt.Success)
{
throw attempt.Exception;
}
var item = attempt.Result;
details.AddRange(DeserializeBase(item, node));
details.AddRange(DeserializeTabs(item, node));
// mediaTypeService.Save(item);
details.AddRange(DeserializeProperties(item, node));
CleanTabs(item, node);
return(SyncAttempt <IMediaType> .Succeed(item.Name, item, ChangeType.Import, details));
}
protected override SyncAttempt <IDataType> DeserializeCore(XElement node)
{
var info = node.Element("Info");
var name = info.Element("Name").ValueOrDefault(string.Empty);
var key = node.GetKey();
var item = FindOrCreate(node);
if (item == null)
{
throw new ArgumentException($"Cannot find underling datatype for {name}");
}
// basic
if (item.Name != name)
{
item.Name = name;
}
if (item.Key != key)
{
item.Key = key;
}
var editorAlias = info.Element("EditorAlias").ValueOrDefault(string.Empty);
if (editorAlias != item.EditorAlias)
{
// change the editor type.....
var newEditor = Current.DataEditors.FirstOrDefault(x => x.Alias.InvariantEquals(editorAlias));
if (newEditor != null)
{
item.Editor = newEditor;
}
}
// removing sort order - as its not used on datatypes,
// and can change based on minor things (so gives false out of sync results)
// item.SortOrder = info.Element("SortOrder").ValueOrDefault(0);
var dbType = info.Element("DatabaseType").ValueOrDefault(ValueStorageType.Nvarchar);
if (item.DatabaseType != dbType)
{
item.DatabaseType = dbType;
}
// config
DeserializeConfiguration(item, node);
SetFolderFromElement(item, info.Element("Folder"));
// save is responsiblity of caller
// dataTypeService.Save(item);
return(SyncAttempt <IDataType> .Succeed(item.Name, item, ChangeType.Import));
}
internal override SyncAttempt <IMemberType> DeserializeCore(XElement node)
{
if (node == null | node.Element("Info") == null || node.Element("Info").Element("Alias") == null)
{
throw new ArgumentException("Invalid xml");
}
var info = node.Element("Info");
IMemberType item = null;
var key = info.Element("Key").ValueOrDefault(Guid.Empty);
if (key != Guid.Empty)
{
item = _memberTypeService.Get(key);
}
var name = info.Element("Name").ValueOrDefault(string.Empty);
var alias = info.Element("Alias").ValueOrDefault(string.Empty);
var parentId = -1;
var parentAlias = info.Element("Master").ValueOrDefault(string.Empty);
if (parentAlias != null)
{
var parent = _memberTypeService.Get(parentAlias);
if (parent != null)
{
parentId = parent.Id;
}
}
if (item == null)
{
item = new MemberType(parentId)
{
Alias = alias,
Name = name
};
}
if (item.Key != key)
{
item.Key = key;
}
DeserializeBase(item, info);
DeserializeProperties(item, node);
DeserializeTabSortOrder(item, node);
_memberTypeService.Save(item);
return(SyncAttempt <IMemberType> .Succeed(item.Name, item, ChangeType.Import));
}
protected override SyncAttempt <XElement> SerializeCore(ITemplate item, SyncSerializerOptions options)
{
var node = this.InitializeBaseNode(item, item.Alias, this.CalculateLevel(item));
node.Add(new XElement("Name", item.Name));
node.Add(new XElement("Parent", item.MasterTemplateAlias));
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(ITemplate), ChangeType.Export));
}
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)
{
// pre-deserilzation check.
var check = CanDeserialize(node, flags);
if (!check.Success)
{
return(check);
}
logger.Debug(serializerType, "Base: Deserializing {0}", ItemType);
var result = DeserializeCore(node);
if (result.Success)
{
logger.Debug(serializerType, "Base: Deserialize Core Success {0}", ItemType);
if (!flags.HasFlag(SerializerFlags.DoNotSave))
{
logger.Debug(serializerType, "Base: Serializer Saving (No DoNotSaveFlag) {0}", result.Item.Id);
// save
SaveItem(result.Item);
}
if (flags.HasFlag(SerializerFlags.OnePass))
{
logger.Debug(serializerType, "Base: Processing item in one pass {0}", result.Item.Id);
var secondAttempt = DeserializeSecondPass(result.Item, node, flags);
logger.Debug(serializerType, "Base: Second Pass Result {0} {1}", result.Item.Id, secondAttempt.Success);
// if its the second pass, we return the results of that pass
return(secondAttempt);
}
}
return(result);
}
return(SyncAttempt <TObject> .Succeed(node.GetAlias(), default(TObject), ChangeType.NoChange));
}
protected override SyncAttempt <IDictionaryItem> DeserializeCore(XElement node, SyncSerializerOptions options)
{
var item = FindItem(node);
var info = node.Element("Info");
var alias = node.GetAlias();
var details = new List <uSyncChange>();
Guid?parentKey = null;
var parentItemKey = info.Element("Parent").ValueOrDefault(string.Empty);
if (parentItemKey != string.Empty)
{
var parent = localizationService.GetDictionaryItemByKey(parentItemKey);
if (parent != null)
{
parentKey = parent.Key;
}
}
var key = node.GetKey();
if (item == null)
{
item = new DictionaryItem(parentKey, alias);
item.Key = key;
}
else
{
item.ParentId = parentKey;
}
if (item.ItemKey != alias)
{
details.AddUpdate("ItemKey", item.ItemKey, alias);
item.ItemKey = alias;
}
if (item.Key != key)
{
details.AddUpdate("Key", item.Key, key);
item.Key = key;
}
// key only translationm, would not add the translation values.
if (!options.GetSetting("KeysOnly", false))
{
details.AddRange(DeserializeTranslations(item, node));
}
// this.SaveItem(item);
return(SyncAttempt <IDictionaryItem> .Succeed(item.ItemKey, item, ChangeType.Import, details));
}
internal override SyncAttempt <XElement> SerializeCore(ITemplate item)
{
var node = new XElement(Constants.Packaging.TemplateNodeName,
new XElement("Name", item.Name),
new XElement("Key", item.Key),
new XElement("Alias", item.Alias),
new XElement("Master", item.MasterTemplateAlias));
return(SyncAttempt <XElement> .Succeed(item.Name, node, typeof(ITemplate), ChangeType.Export));
}
