public virtual ISourceItem DeserializeItem(ISerializedItem serializedItem, bool ignoreMissingTemplateFields) { Assert.ArgumentNotNull(serializedItem, "serializedItem"); var typed = serializedItem as SitecoreSerializedItem; if (typed == null) { throw new ArgumentException("Serialized item must be a SitecoreSerializedItem", "serializedItem"); } try { var options = new LoadOptions { DisableEvents = true, ForceUpdate = true, UseNewID = false }; return(new SitecoreSourceItem(ItemSynchronization.PasteSyncItem(typed.InnerItem, options, true))); } catch (ParentItemNotFoundException ex) { string error = "Cannot load item from path '{0}'. Probable reason: parent item with ID '{1}' not found.".FormatWith(serializedItem.ProviderId, ex.ParentID); throw new DeserializationException(error, ex); } catch (ParentForMovedItemNotFoundException ex2) { string error = "Item from path '{0}' cannot be moved to appropriate location. Possible reason: parent item with ID '{1}' not found.".FormatWith(serializedItem.ProviderId, ex2.ParentID); throw new DeserializationException(error, ex2); } }
public virtual ISourceItem Deserialize(ISerializedItem serializedItem, bool ignoreMissingTemplateFields) { if (ignoreMissingTemplateFields) { throw new NotSupportedException("The Sitecore serialization engine does not support ignoring missing fields."); } try { var options = new LoadOptions { DisableEvents = true, ForceUpdate = true, UseNewID = false }; return(new SitecoreSourceItem(ItemSynchronization.PasteSyncItem(((SitecoreSerializedItem)serializedItem).InnerItem, options, true))); } catch (ParentItemNotFoundException ex) { string error = "Cannot load item from path '{0}'. Probable reason: parent item with ID '{1}' not found.".FormatWith(serializedItem.ProviderId, ex.ParentID); throw new DeserializationException(error, ex); } catch (ParentForMovedItemNotFoundException ex2) { string error = "Item from path '{0}' cannot be moved to appropriate location. Possible reason: parent item with ID '{1}' not found.".FormatWith(serializedItem.ProviderId, ex2.ParentID); throw new DeserializationException(error, ex2); } }
private static Item CreateNewItem(Item parent, LoadOptions loadOptions, SyncItem syncItem, Sitecore.ItemWebApi.Context context) { Item itm = null; Assert.ArgumentNotNull(parent, "parent"); Assert.ArgumentNotNull(loadOptions, "loadOptions"); Assert.ArgumentNotNull(syncItem, "syncItem"); try { itm = ItemSynchronization.PasteSyncItem(syncItem, loadOptions, true); if (itm != null) { if (Common.Functions.IsMediaItem(context) && context.HttpContext != null && context.HttpContext.Request.Files != null) { MediaItem mediaItem = Common.Functions.UpdateMediaItem(itm, context.HttpContext); if (mediaItem != null) { itm = mediaItem.InnerItem; } } } } catch(Exception ex) { throw ex; } return itm; }
/// <summary> /// This function Serialize Sitecore.Data.Items.Item into string. /// Though here string is been originated from the TextWriter class. /// </summary> /// <param name="itm">Sitecore.Data.Items.Item</param> /// <returns>string representation of Sitecore.Data.Items.Item </returns> public static string SerializeIteminString(Item itm) { string data = null; if (itm == null) { return(data); } using (new SecurityDisabler()) { Stream ss = null; TextWriter tw = null; try { ss = new MemoryStream(); tw = new System.IO.StreamWriter(ss); try { //Here I am using Sitecore Default Item Synchronization though i have method created in this class using which you //you can do yourself also. ItemSynchronization.WriteItem(itm, tw); //Flushing the Memory is essential otherwise you are risking reading empty stream or partial data loss tw.Flush(); ss.Flush(); } catch (System.Exception ex) { Log.WriteError(ex.Message, ex); } //ss.Position = 0; ss.Seek(0, SeekOrigin.Begin); using (StreamReader sr = new StreamReader(ss)) { data = sr.ReadToEnd(); } } catch (Exception ex) { Log.WriteError(ex.Message, ex); } finally { try { if (tw != null) { tw.Dispose(); } if (ss != null) { ss.Close(); ss.Dispose(); } } catch { } } } return(data); }
/// <summary> /// Moves the descendant items of a serialized parent after it has been moved or renamed. /// </summary> /// <param name="oldReference">Reference to the original path pre-move/rename</param> /// <param name="newItem">The newly renamed or moved parent item</param> /// <param name="sourceItem">The source item representing the renamed/moved item. NOTE that the path of this item is incorrect a lot of the time so we ignore it.</param> /// <param name="renaming">True for moving renamed children, false for moving moved children. For renames, the children already have correct new paths; for moves we have to recalculate it.</param> /// <remarks> /// This method basically gets all descendants of the source item that was moved/renamed, generates an appropriate new serialized item for it, and _if the new child item is in the predicate_ we /// serialize it to its new location. Finally, we delete the old children directory if it existed. /// /// Doing it this way allows handling crazy cases like moving trees of items between included and excluded locations - or even moves or renames causing SOME of the children to be ignored. Wild. /// </remarks> protected virtual void MoveDescendants(ISerializedReference oldReference, ISerializedItem newItem, ISourceItem sourceItem, bool renaming) { // remove the extension from the new item's provider ID string newItemReferencePath = SerializationPathUtility.GetReferenceDirectoryPath(newItem); // if the paths were the same, no moving occurs (this can happen when saving templates, which spuriously can report "renamed" when they are not actually any such thing) if (oldReference.ProviderId.Equals(newItemReferencePath, StringComparison.Ordinal)) { return; } // this is for renaming an item that differs only by case from the original. Because NTFS is case-insensitive the 'new parent' exists // already, but it will use the old name. Not quite what we want. So we need to manually rename the folder. if (oldReference.ProviderId.Equals(newItemReferencePath, StringComparison.OrdinalIgnoreCase) && Directory.Exists(oldReference.ProviderId)) { Directory.Move(oldReference.ProviderId, oldReference.ProviderId + "_tempunicorn"); Directory.Move(oldReference.ProviderId + "_tempunicorn", newItemReferencePath); } var descendantItems = GetDescendants(sourceItem).Cast <SitecoreSourceItem>(); // Go through descendant source items and serialize all that are included by the predicate foreach (var descendant in descendantItems) { var syncItem = ItemSynchronization.BuildSyncItem(descendant.InnerItem); // the newPhysicalPath will point to the OLD physical path pre-move (but for renames we actually get the new path already). // For moves, we re-root the path to point to the new parent item's base path to fix that before we write to disk string newItemPath = (renaming) ? descendant.ItemPath : descendant.ItemPath.Replace(oldReference.ItemPath, newItem.ItemPath); var newPhysicalPath = SerializationPathUtility.GetSerializedItemPath(_rootPath, syncItem.DatabaseName, newItemPath); var newSerializedItem = new SitecoreSerializedItem(syncItem, newPhysicalPath, this); if (!_predicate.Includes(newSerializedItem).IsIncluded) { continue; // if the moved child location is outside the predicate, do not re-serialize } UpdateSerializedItem(newSerializedItem); } // remove the old children folder if it exists - as long as the original name was not a case insensitive version of this item if (Directory.Exists(oldReference.ProviderId) && !oldReference.ProviderId.Equals(newItemReferencePath, StringComparison.OrdinalIgnoreCase)) { Directory.Delete(oldReference.ProviderId, true); } }
/// <summary> /// This function Serialize Sitecore.Data.Items.Item into byte array. /// Though here string is been originated from the TextWriter wrapped in Stream class. /// </summary> /// <param name="itm">byte[]</param> /// <returns>string representation of byte[] </returns> public static byte[] SerializeItem(Item itm) { byte[] data = null; if (itm == null) { return(data); } using (new SecurityDisabler()) { Stream ss = null; TextWriter tw = null; try { ss = new MemoryStream(); tw = new System.IO.StreamWriter(ss); try { ItemSynchronization.WriteItem(itm, tw); } catch (System.Exception ex) { Log.WriteError(ex.Message, ex); } data = new byte[ss.Length]; ss.Read(data, 0, data.Length); } catch (Exception ex) { Log.WriteError(ex.Message, ex); } finally { try { if (tw != null) { tw.Dispose(); } if (ss != null) { ss.Close(); ss.Dispose(); } } catch { } } } return(data); }
public void DumpItem(object[] param) { var path = string.Format("{0}//ItemSync//{1}{2}{3}{4}{5}{6}{7}", Settings.SerializationFolder, DateTime.Now.Year, DateTime.Now.Month, DateTime.Now.Day, DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second, DateTime.Now.Millisecond); var searchStringModel = ExtractSearchQuery(param[0].ToString()); var tempItem = Factory.GetDatabase(param[2].ToString()).GetItem(param[1].ToString()); int hitsCount; var listOfItems = tempItem.Search(searchStringModel, out hitsCount).ToList(); if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } foreach (var sitecoreItem in listOfItems) { var item = sitecoreItem.GetItem(); Assert.ArgumentNotNullOrEmpty(path, "path"); Assert.ArgumentNotNull(item, "item"); var itemPath = string.Format("{0}//{1}", path, item.Paths.FullPath); using (new SecurityDisabler()) { if (!Directory.Exists(itemPath)) { Directory.CreateDirectory(itemPath); } using (var file = new StreamWriter(string.Format("{0}.item", itemPath.Replace("//", "\\")), true)) { TextWriter writer = file; try { ItemSynchronization.WriteItem(item, writer); } catch (Exception exception) { Log.Error(exception.Message, item); } finally { writer.Close(); } writer.Close(); } } } }
public virtual void MoveSerializedItem(ISourceItem sourceItem, ISourceItem newParentItem) { Assert.ArgumentNotNull(sourceItem, "sourceItem"); Assert.ArgumentNotNull(newParentItem, "newParentItem"); var sitecoreSource = sourceItem as SitecoreSourceItem; var sitecoreParent = newParentItem as SitecoreSourceItem; if (sitecoreParent == null) { throw new ArgumentException("newParentItem must be a SitecoreSourceItem", "newParentItem"); } if (sitecoreSource == null) { throw new ArgumentException("sourceItem must be a SitecoreSourceItem", "sourceItem"); } var oldRootDirectory = new SitecoreSerializedReference(SerializationPathUtility.GetSerializedReferencePath(_rootPath, sourceItem), this); var oldRootItemPath = new SitecoreSerializedReference(SerializationPathUtility.GetReferenceItemPath(oldRootDirectory), this); var newRootItemPath = newParentItem.ItemPath + "/" + sourceItem.Name; var newRootSerializedPath = SerializationPathUtility.GetSerializedItemPath(_rootPath, newParentItem.DatabaseName, newRootItemPath); var syncItem = ItemSynchronization.BuildSyncItem(sitecoreSource.InnerItem); // update the path and parent IDs to the new location syncItem.ParentID = newParentItem.Id.ToString(); syncItem.ItemPath = newRootItemPath; // if this occurs we're "moving" an item to the same location it started from. Which means we shouldn't do anything. if (oldRootDirectory.ItemPath.Equals(syncItem.ItemPath)) { return; } var serializedNewItem = new SitecoreSerializedItem(syncItem, newRootSerializedPath, this); // write the moved sync item to its new destination UpdateSerializedItem(serializedNewItem); // move any children to the new destination (and fix their paths) MoveDescendants(oldRootDirectory, serializedNewItem, sourceItem, false); // remove the serialized item in the old location DeleteSerializedItem(oldRootItemPath); }
public virtual ISerializedItem SerializeItem(ISourceItem item) { Assert.ArgumentNotNull(item, "item"); var sitecoreSourceItem = item as SitecoreSourceItem; var sitecoreItem = sitecoreSourceItem != null ? sitecoreSourceItem.InnerItem : Factory.GetDatabase(item.DatabaseName).GetItem(item.Id); Assert.IsNotNull(sitecoreItem, "Item to serialize did not exist!"); var serializedPath = SerializationPathUtility.GetSerializedItemPath(_rootPath, item); var serializedItem = new SitecoreSerializedItem(ItemSynchronization.BuildSyncItem(sitecoreItem), serializedPath, this); UpdateSerializedItem(serializedItem); return(serializedItem); }
public override bool CopyItem(ItemDefinition source, ItemDefinition destination, string copyName, ID copyId, CallContext context) { Assert.ArgumentNotNull(source, "source"); Assert.ArgumentNotNull(destination, "destination"); Assert.ArgumentNotNullOrEmpty(copyName, "copyName"); Assert.ArgumentNotNull(copyId, "copyId"); // we use the Database API instead of our own so we can get a source item from any data provider var existingItem = Database.GetItem(source.ID); Assert.IsNotNull(existingItem, "Could not copy {0} because it did not exist!", source.ID); var destinationItem = _database.GetItem(destination.ID); Assert.IsNotNull(destinationItem, "Source item to copy {0} was in the Rhino provider but the destination parent {1} was not. Copying from Rhino to other providers is not supported.", source.Name, destination.Name); SerializedDatabase.CopyItem(ItemSynchronization.BuildSyncItem(existingItem), destination.ID, copyName, copyId); return(true); }
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); } }
public override bool SaveItem(ItemDefinition itemDefinition, ItemChanges changes, CallContext context) { Assert.ArgumentNotNull(itemDefinition, "itemDefinition"); Assert.ArgumentNotNull(changes, "changes"); var existingItem = SerializedDatabase.GetItem(itemDefinition.ID); if (existingItem == null) { return(false); // item was not in this data provider, cede control to the next one } var savedItem = ItemSynchronization.BuildSyncItem(changes.Item); if (changes.Renamed) { SerializedDatabase.SaveAndRenameItem(savedItem, changes.Properties["name"].OriginalValue.ToString()); } else { SerializedDatabase.SaveItem(savedItem); } return(true); }
/// <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); }
protected override string BuildPackage() { var commands = new List <ICommand>(); foreach (var item in Items) { var syncItem = ItemSynchronization.BuildSyncItem(item); var contentDataItem = new ContentDataItem(string.Empty, item.Paths.ParentPath, item.Name, syncItem); var command = new AddItemCommand(contentDataItem); commands.Add(command); } var rootPath = FileUtil.MapPath("/"); foreach (var fileName in Files) { if (FileUtil.IsFolder(fileName)) { foreach (var file in Directory.GetFiles(FileUtil.MapPath(fileName), "*", SearchOption.AllDirectories)) { var fileInfo = new FileInfo(file); if ((fileInfo.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden) { continue; } if ((fileInfo.Attributes & FileAttributes.System) == FileAttributes.System) { continue; } var fileItem = new FileSystemDataItem(rootPath, Path.GetDirectoryName(file), Path.GetFileName(file)); var command = new AddFileCommand(fileItem); commands.Add(command); } } else { var fileItem = new FileSystemDataItem(rootPath, Path.GetDirectoryName(fileName), Path.GetFileName(fileName)); var command = new AddFileCommand(fileItem); commands.Add(command); } } var diff = new DiffInfo(commands) { Author = Author, PostStep = PostStep, Publisher = Publisher, Readme = Readme, Version = Version, Title = PackageName }; var directoryName = Path.GetDirectoryName(FileName) ?? string.Empty; directoryName = directoryName.Replace("\\", "/"); var folderPath = FileUtil.MapPath(directoryName); diff.Serialize(folderPath); var packageFileName = FileUtil.UnmapPath(folderPath, false) + "/" + DiffInfo.OutputFileName; PackageGenerator.GeneratePackage(diff, packageFileName); return(packageFileName); }
/// <summary> /// An item is being checked in. /// </summary> public override void ItemCheckingIn(SPItemEventProperties properties) { base.ItemCheckingIn(properties); ItemSynchronization.SendData(properties.AfterUrl); }