protected SyncItem LoadSyncItem(string path)
{
using (TextReader reader = (TextReader) new StreamReader((Stream)File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
return(SyncItem.ReadItem(new Tokenizer(reader)));
}
}
private List <SyncItem> GetAllItems(DirectoryInfo folder, string db, string[] includePaths)
{
List <SyncItem> result = new List <SyncItem>();
foreach (FileInfo itemFile in folder.GetFiles("*.item", SearchOption.AllDirectories))
{
using (StreamReader sr = new StreamReader(itemFile.FullName))
{
sr.ReadLine();
sr.ReadLine();
sr.ReadLine();
string dbStr = sr.ReadLine().Substring(10);
if (dbStr != db)
{
continue;
}
string pathStr = sr.ReadLine().Substring(6);
if (!includePaths.Any(p => pathStr.StartsWith(p)))
{
continue;
}
}
try
{
result.Add(SyncItem.ReadItem(new Tokenizer(itemFile.OpenText())));
}
catch (Exception ex)
{
throw new Exception(string.Format("Unable to deserialize '{0}'", itemFile.FullName, itemFile.FullName), ex);
}
}
return(result);
}
public static SyncItem GetSyncItem(string path)
{
using (TextReader reader = new StreamReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
return(SyncItem.ReadItem(new Tokenizer(reader)));
}
}
/// <summary>
/// Determines whether [is standard values item] [the specified file name].
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <returns>
/// <c>true</c> if [is standard values item] [the specified file name]; otherwise, <c>false</c>.
/// </returns>
private static bool IsStandardValuesItem(string fileName, out ID itemId)
{
Assert.ArgumentNotNull(fileName, "fileName");
string itemPath;
try
{
using (TextReader textReader = new StreamReader(File.Open(fileName, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
var item = SyncItem.ReadItem(new Tokenizer(textReader));
itemId = ID.Parse(item.ID);
itemPath = item.ItemPath;
}
}
catch
{
itemId = null;
return(false);
}
string[] array = itemPath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (array.Length > 0)
{
if (array.Any(s => s.Equals("templates", StringComparison.InvariantCultureIgnoreCase)))
{
return(array.Last().Equals("__Standard Values"));
}
}
return(false);
}
public SyncItem Read(Stream sourceStream)
{
using (var reader = new StreamReader(sourceStream))
{
return(SyncItem.ReadItem(new Tokenizer(reader), true));
}
}
public TemplatesResolver(
string serializationPath,
string[] includePaths,
string db = "master")
{
Assert.ArgumentNotNullOrEmpty(serializationPath, "serializationPath");
DirectoryInfo serializationFolder = new DirectoryInfo(serializationPath);
Assert.IsTrue(serializationFolder.Exists, string.Format("Path '{0}' does not exist", serializationPath));
List <SyncItem> syncItems = GetAllItems(serializationFolder, db, includePaths);
Templates = syncItems
.Where(s => s.TemplateID == TemplateIDs.Template.ToString())
.Select(t => new TemplateItem(t, syncItems))
.ToList();
Dictionary <string, TemplateItem> templateLookup = Templates.ToDictionary(t => t.SyncItem.ID, t => t);
// resolve inheritance hierarchy
foreach (TemplateItem templateItem in Templates)
{
SyncField baseTemplates = templateItem.SyncItem.SharedFields
.FirstOrDefault(f => f.FieldID == FieldIDs.BaseTemplate.ToString());
if (baseTemplates != null && !string.IsNullOrWhiteSpace(baseTemplates.FieldValue))
{
ID[] baseTemplateIds = ID.ParseArray(baseTemplates.FieldValue);
var baseTemplateIdsInCurrentSet = baseTemplateIds
.Where(b => templateLookup.Keys.Contains(b.ToString()));
templateItem.BaseTemplates.AddRange(baseTemplateIdsInCurrentSet
.Select(b => templateLookup[b.ToString()]));
// resolve base templates outside of resolving set
foreach (ID baseTemplateId in baseTemplateIds
.Where(b => !templateItem.BaseTemplates.Any(bt => bt.SyncItem.ID == b.ToString())))
{
string baseTemplateFilePath = baseTemplateId.FindFilePath(serializationFolder);
if (string.IsNullOrWhiteSpace(baseTemplateFilePath))
{
continue;
}
FileInfo baseTemplateFile = new FileInfo(baseTemplateFilePath);
if (!baseTemplateFile.Exists)
{
continue;
}
SyncItem baseTemplateSyncItem = SyncItem.ReadItem(new Tokenizer(baseTemplateFile.OpenText()));
if (baseTemplateSyncItem == null)
{
continue;
}
if (!templateItem.BaseTemplates.Any(b => b.SyncItem.ID == baseTemplateSyncItem.ID))
{
templateItem.BaseTemplates.Add(new TemplateItem(baseTemplateSyncItem, new List <SyncItem>()));
}
}
}
}
}
/// <summary>
/// Function which Desialize textual item into Sitecore.Data.Serialization.ObjectModel.SyncItem
/// </summary>
/// <param name="data">string:Textual representation of data</param>
/// <param name="options">Custom.ItemWebAPI.Pipelines.Advance.Serialize.Entities:LoadOption which define how to Serialize</param>
/// <returns>Sitecore.Data.Serialization.ObjectModel.SyncItem</returns>
public static SyncItem DeSerializeItem(string data, LoadOptions options)
{
SyncItem result = null;
if (data == null || data.Length == 0)
{
return(result);
}
bool disabledLocally = Sitecore.Data.Serialization.ItemHandler.DisabledLocally;
try
{
using (TextReader textReader = new StringReader(data))
{
_loadOption = getLoadOption(options);
if (_loadOption.DisableEvents)
{
using (new EventDisabler())
{
Sitecore.Data.Serialization.ItemHandler.DisabledLocally = true;
result = ReadItem(new Sitecore.Data.Serialization.ObjectModel.Tokenizer(textReader), false);
}
//Sitecore.Data.Serialization.Manager.
DeserializationFinished(_loadOption.Database.Name);
}
else
{
Sitecore.Data.Serialization.ItemHandler.DisabledLocally = true;
result = SyncItem.ReadItem(new Sitecore.Data.Serialization.ObjectModel.Tokenizer(textReader));
}
}
}
catch (ParentItemNotFoundException ex)
{
SerializeManager.LogLocalizedError("Cannot load item from path '{0}'. Possible reason: parent item with ID '{1}' not found.", new object[]
{
//PathUtils.UnmapItemPath(path, options.Root),
ex.ParentID
});
}
catch (ParentForMovedItemNotFoundException ex2)
{
SerializeManager.LogLocalizedError("Item from path '{0}' cannot be moved to appropriate location. Possible reason: parent item with ID '{1}' not found.", new object[]
{
//PathUtils.UnmapItemPath(path, options.Root),
ex2.ParentID
});
}
catch (Exception ex)
{
SerializeManager.LogLocalizedError(ex.Message, ex);
}
finally
{
Sitecore.Data.Serialization.ItemHandler.DisabledLocally = disabledLocally;
}
return(result);
}
private void InitializeTemplates(List <SyncItem> syncItems, DirectoryInfo serializationFolder)
{
this.Templates = syncItems
.Where(s => s.TemplateID == TemplateIDs.Template.ToString())
.Select(t => new TemplateItem(t, syncItems))
.ToList();
Dictionary <string, TemplateItem> templateLookup = this.Templates.ToDictionary(t => t.SyncItem.ID, t => t);
// resolve inheritance hierarchy
foreach (TemplateItem templateItem in this.Templates)
{
SyncField baseTemplates = templateItem.SyncItem.SharedFields
.FirstOrDefault(f => f.FieldID == FieldIDs.BaseTemplate.ToString());
if (baseTemplates != null && !string.IsNullOrWhiteSpace(baseTemplates.FieldValue))
{
ID[] baseTemplateIds = baseTemplates.FieldValue
.Split(new[] { '|', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)
.Where(ID.IsID)
.Select(ID.Parse)
.ToArray();
var baseTemplateIdsInCurrentSet = baseTemplateIds
.Where(b => templateLookup.Keys.Contains(b.ToString()));
templateItem.BaseTemplates.AddRange(baseTemplateIdsInCurrentSet
.Select(b => templateLookup[b.ToString()]));
// resolve base templates outside of resolving set
if (serializationFolder != null)
{
foreach (ID baseTemplateId in baseTemplateIds
.Where(b => !templateItem.BaseTemplates.Any(bt => bt.SyncItem.ID == b.ToString())))
{
string baseTemplateFilePath = baseTemplateId.FindFilePath(serializationFolder);
if (string.IsNullOrWhiteSpace(baseTemplateFilePath))
{
continue;
}
FileInfo baseTemplateFile = new FileInfo(baseTemplateFilePath);
if (!baseTemplateFile.Exists)
{
continue;
}
SyncItem baseTemplateSyncItem =
SyncItem.ReadItem(new Tokenizer(baseTemplateFile.OpenText()));
if (baseTemplateSyncItem == null)
{
continue;
}
if (!templateItem.BaseTemplates.Any(b => b.SyncItem.ID == baseTemplateSyncItem.ID))
{
templateItem.BaseTemplates.Add(new TemplateItem(baseTemplateSyncItem,
new List <SyncItem>()));
}
}
}
}
}
}
public SyncItem ReadItem(string filePath)
{
using (TextReader reader = (TextReader) new StreamReader((Stream)File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
var tokenizer = new Tokenizer(reader);
var syncItem = SyncItem.ReadItem(tokenizer);
return(syncItem);
}
}
/// <summary>
/// Deserializes an item file that was serialized with normal Sitecore serialization or TDS.
/// </summary>
/// <param name="file">.item file</param>
/// <returns></returns>
internal static SyncItem Deserialize(this FileInfo file)
{
Assert.ArgumentNotNull(file, "file");
Assert.IsTrue(file.Exists, string.Format("File '{0}' can not be found or cannot be accessed", file.FullName));
Assert.IsTrue(".item".Equals(file.Extension, StringComparison.InvariantCultureIgnoreCase), string.Format("File '{0}' is not a .item file", file.FullName));
var item = SyncItem.ReadItem(new Tokenizer(file.OpenText()));
Assert.IsTrue(ID.IsID(item.ID), string.Format("Item id '{0}' is not a valid guid", item.ID));
Assert.IsTrue(ID.IsID(item.TemplateID), string.Format("Item template id '{0}' is not a valid guid", item.TemplateID));
return(item);
}
protected virtual ISerializedItem ReadItemFromDisk(string fullPath)
{
try
{
using (var reader = new StreamReader(fullPath))
{
var syncItem = SyncItem.ReadItem(new Tokenizer(reader), true);
return(new SitecoreSerializedItem(syncItem, fullPath, this));
}
}
catch (Exception ex)
{
throw new Exception("Error loading " + fullPath, ex);
}
}
private SyncItem ReadSerializedVersion(Item item)
{
Assert.IsNotNull(item, "Item cannot be null");
var reference = new ItemReference(item);
var path = PathUtils.GetFilePath(reference.ToString());
if (!File.Exists(path))
{
return(null);
}
using (var file = new StreamReader(path))
{
return(SyncItem.ReadItem(new Tokenizer(file)));
}
}
public static SyncItem Clone(this SyncItem item)
{
using (var ms = new MemoryStream())
{
using (var writer = new StreamWriter(ms))
{
item.Serialize(writer);
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
using (var reader = new StreamReader(ms))
{
return(SyncItem.ReadItem(new Tokenizer(reader)));
}
}
}
}
private SyncItem LoadItem(string path)
{
if (!File.Exists(path))
{
return(null);
}
using (var fileStream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var reader = new StreamReader(fileStream))
{
var item = SyncItem.ReadItem(new Tokenizer(reader), true);
Assert.IsNotNullOrEmpty(item.TemplateID, "{0}: TemplateID was not valid!", path);
return(item);
}
}
}
private void LoadItem(string path)
{
if (!File.Exists(path))
{
return;
}
using (var fileStream = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var reader = new StreamReader(fileStream))
{
var item = SyncItem.ReadItem(new Tokenizer(reader), false);
if (!_innerItems.Exists(i => i.ID.Equals(item.ID)))
{
_innerItems.Add(item);
}
}
}
}
public List <SyncItem> LoadItems()
{
List <SyncItem> items = new List <SyncItem>();
foreach (FileInfo itemFile in StartInfo.GetFiles("*.item", SearchOption.AllDirectories))
{
try
{
items.Add(SyncItem.ReadItem(new Tokenizer(itemFile.OpenText())));
}
catch (Exception exception)
{
Console.WriteLine(string.Format("Unable to read item from file {0}: {1}", itemFile.FullName, exception.Message));
}
}
Console.WriteLine(string.Format("Deserialized {0} items from {1}", items.Count, StartInfo.FullName));
return(items);
}
private void Parse(DirectoryInfo directoryInfo)
{
var fileInfos = directoryInfo.GetFiles("*.item");
foreach (var fileInfo in fileInfos)
{
var streamReader = new StreamReader(fileInfo.FullName);
var syncItem = SyncItem.ReadItem(new Tokenizer(streamReader), true);
var options = new LoadOptions {
DisableEvents = true, ForceUpdate = true, UseNewID = false
};
ItemSynchronization.PasteSyncItem(syncItem, options, true);
}
foreach (var info in directoryInfo.GetDirectories())
{
Parse(info);
}
}
protected override SyncItem GetItem(FileInfo itemFile, Func <IItemData, bool> mustMatch)
{
return(SyncItem.ReadItem(new Tokenizer(itemFile.OpenText())));
}
private void LoadItem(string file)
{
using (var reader = File.OpenText(file))
{
var item = SyncItem.ReadItem(new Tokenizer(reader));
var itemId = new ID(item.ID);
var parentId = new ID(item.ParentID);
var templateId = new ID(item.TemplateID);
var branchId = new ID(item.BranchId);
if (!Items.ContainsKey(itemId))
{
Items[itemId] = new ItemsRow
{
ItemID = itemId,
Name = item.Name,
ParentID = parentId,
BranchID = branchId,
TemplateID = templateId
};
}
Items[itemId].ParentID = parentId;
Items[itemId].TemplateID = templateId;
Items[itemId].BranchID = branchId;
Items[itemId].Name = item.Name;
if (parentId != Data.ID.Null)
{
if (!Items.ContainsKey(parentId))
{
Items[parentId] = new ItemsRow
{
ItemID = parentId,
Name = "(unknown)",
ParentID = Data.ID.Null,
BranchID = Data.ID.Null,
TemplateID = Data.ID.Null
};
}
Items[parentId].Children.Add(itemId);
}
foreach (var field in item.SharedFields)
{
var fieldId = new ID(field.FieldID);
SharedFields[itemId].Add(
new FieldsRow
{
ItemID = itemId,
FieldID = fieldId,
Value = field.FieldValue
});
}
foreach (var version in item.Versions)
{
var versionNumber = MainUtil.GetInt(version.Version, 0);
foreach (var field in version.Fields)
{
var fieldId = new ID(field.FieldID);
VersionedFields[itemId].Add(
new FieldsRow
{
ItemID = itemId,
FieldID = fieldId,
Language = version.Language,
Version = versionNumber,
Value = field.FieldValue
});
}
}
}
}
/// <summary>
/// Loads a specific item from disk
/// </summary>
private Item DoLoadItem(string path, AdvancedLoadOptions options, out ItemLoadResult loadResult)
{
Assert.ArgumentNotNullOrEmpty(path, "path");
Assert.ArgumentNotNull(options, "options");
if (File.Exists(path))
{
using (TextReader fileReader = new StreamReader(File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read)))
{
LogLocalized("Loading item from path {0}.", new object[]
{
PathUtils.UnmapItemPath(path, options.Root)
});
bool disabledLocally = ItemHandler.DisabledLocally;
try
{
ItemHandler.DisabledLocally = true;
Item result = null;
try
{
var serializedItem = SyncItem.ReadItem(new Tokenizer(fileReader));
_itemsProcessed++;
if (_itemsProcessed % 500 == 0 && _itemsProcessed > 1)
{
options.Progress.ReportStatus(string.Format("Processed {0} items", _itemsProcessed), MessageType.Debug);
}
if (options.Preset.Exclude.MatchesTemplate(serializedItem.TemplateName))
{
options.Progress.ReportStatus(string.Format("[SKIPPED] {0}:{1} because the preset excluded its template name, but the item was on disk", serializedItem.DatabaseName, serializedItem.ItemPath), MessageType.Warning);
loadResult = ItemLoadResult.Skipped;
return(null);
}
if (options.Preset.Exclude.MatchesTemplateId(serializedItem.TemplateID))
{
options.Progress.ReportStatus(string.Format("[SKIPPED] {0}:{1} because the preset excluded its template ID, but the item was on disk", serializedItem.DatabaseName, serializedItem.ItemPath), MessageType.Warning);
loadResult = ItemLoadResult.Skipped;
return(null);
}
if (options.Preset.Exclude.MatchesId(serializedItem.ID))
{
options.Progress.ReportStatus(string.Format("[SKIPPED] {0}:{1} because the preset excluded it by ID, but the item was on disk", serializedItem.DatabaseName, serializedItem.ItemPath), MessageType.Warning);
loadResult = ItemLoadResult.Skipped;
return(null);
}
if (options.Preset.Exclude.MatchesPath(path))
{
options.Progress.ReportStatus(string.Format("[SKIPPED] {0}:{1} because the preset excluded it by path, but the item was on disk", serializedItem.DatabaseName, serializedItem.ItemPath), MessageType.Warning);
loadResult = ItemLoadResult.Skipped;
return(null);
}
var newOptions = new LoadOptions(options);
// in some cases we want to force an update for this item only
if (!options.ForceUpdate && ShouldForceUpdate(serializedItem, options.Progress))
{
options.Progress.ReportStatus(string.Format("[FORCED] {0}:{1}", serializedItem.DatabaseName, serializedItem.ItemPath), MessageType.Info);
newOptions.ForceUpdate = true;
}
result = ItemSynchronization.PasteSyncItem(serializedItem, newOptions, true);
loadResult = ItemLoadResult.Success;
}
catch (ParentItemNotFoundException ex)
{
result = null;
loadResult = ItemLoadResult.Error;
string error =
"Cannot load item from path '{0}'. Probable reason: parent item with ID '{1}' not found.".FormatWith(
PathUtils.UnmapItemPath(path, options.Root), ex.ParentID);
options.Progress.ReportStatus(error, MessageType.Error);
LogLocalizedError(error);
}
catch (ParentForMovedItemNotFoundException ex2)
{
result = ex2.Item;
loadResult = ItemLoadResult.Error;
string error =
"Item from path '{0}' cannot be moved to appropriate location. Possible reason: parent item with ID '{1}' not found."
.FormatWith(PathUtils.UnmapItemPath(path, options.Root), ex2.ParentID);
options.Progress.ReportStatus(error, MessageType.Error);
LogLocalizedError(error);
}
return(result);
}
finally
{
ItemHandler.DisabledLocally = disabledLocally;
}
}
}
loadResult = ItemLoadResult.Error;
return(null);
}
