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); }