public SyncItem BuildSyncItem(IItemData item) { var syncItem = new SyncItem { ID = item.Id.ToString("B"), DatabaseName = item.DatabaseName, ParentID = item.ParentId.ToString("B"), Name = item.Name, BranchId = item.BranchId.ToString("B"), TemplateID = item.TemplateId.ToString("B"), ItemPath = item.Path }; //syncItem.TemplateName = item.TemplateName; foreach (var field in item.SharedFields) //TODO: ItemSynchronization.BuildSyncItem sorts the fields and versions first, should we ? { syncItem.AddSharedField(field.FieldId.ToString("B"), null/*name*/, null/*key?*/, field.Value, true); } foreach (var version in item.Versions) { var syncVersion = syncItem.AddVersion(version.Language.ToString(), version.VersionNumber.ToString(), version.VersionNumber.ToString() /*revisionid needed?*/); if (syncVersion != null) { foreach (var field in version.Fields) { syncVersion.AddField(field.FieldId.ToString("B"), null/*name*/,null /*key?*/, field.Value, true); } } } return syncItem; }
public virtual void Serialize(SyncItem item, Stream outputStream) { using (var writer = new StreamWriter(outputStream)) { item.Serialize(writer); } }
private IList<FieldDesynchronization> GetFieldSyncStatus(Item item, SyncItem serializedItem) { var desyncs = new List<FieldDesynchronization>(); var serializedVersion = serializedItem.Versions.FirstOrDefault(x => x.Version == item.Version.Number.ToString(CultureInfo.InvariantCulture) && x.Language == item.Language.Name); if (serializedVersion == null) { desyncs.Add(new FieldDesynchronization("Version", item.Version.Number.ToString(CultureInfo.InvariantCulture), "Did not exist")); return desyncs; } item.Fields.ReadAll(); foreach (Field field in item.Fields) { // find the field in the serialized item in either versioned or shared fields var serializedField = serializedVersion.Fields.FirstOrDefault(x => x.FieldID == field.ID.ToString()) ?? serializedItem.SharedFields.FirstOrDefault(x => x.FieldID == field.ID.ToString()); // we ignore if the field doesn't exist in the serialized item. This is because if you added a field to a template, // that does not immediately re-serialize all items based on that template so it's likely innocuous - we're not overwriting anything. if (serializedField == null) continue; if (!serializedField.FieldValue.Equals(field.Value, StringComparison.Ordinal)) { desyncs.Add(new FieldDesynchronization(serializedField.FieldName, field.Value, serializedField.FieldValue)); } } return desyncs; }
public TemplateSection(SyncItem sectionItem, List<SyncItem> syncItems) : base(sectionItem) { Fields = syncItems .Where(s => s.TemplateID == TemplateIDs.TemplateField.ToString() && s.ParentID == sectionItem.ID) .Select(s => new TemplateField(s)) .ToList(); }
private static void WriteResultsToFile(Stream stream, SyncItem syncItem) { TruncateFile(stream); using (TextWriter writer = new StreamWriter(stream)) { syncItem.Serialize(writer); } }
public TemplateItem(SyncItem templateItem, List<SyncItem> syncItems) : base(templateItem) { BaseTemplates = new List<TemplateItem>(); Sections = syncItems .Where(s => s.TemplateID == TemplateIDs.TemplateSection.ToString() && s.ParentID == templateItem.ID) .Select(s => new TemplateSection(s, syncItems)) .ToList(); }
public SyncItem UpdateStatistics(SyncItem syncItem) { SyncVersion versionToUpdate = GetVersionToUpdate(syncItem); int index = syncItem.Versions.IndexOf(versionToUpdate); SyncVersion syncVersion = syncItem.Versions[index]; syncVersion.SetFieldValue(StatisticsTemplateFields.Updated, DateUtil.IsoNowWithTicks); syncVersion.SetFieldValue(StatisticsTemplateFields.UpdatedBy, _config.CurrentUser); return syncItem; }
internal DsDbItem(string serializationFolderName, SyncItem syncItem, FileInfo file, bool includeDescendants, bool deserializeLinkedTemplate = true) : base(syncItem.Name, ID.Parse(syncItem.ID), ID.Parse(syncItem.TemplateID)) { this.SerializationFolderName = serializationFolderName; this.SyncItem = syncItem; this.File = file; this.IncludeDescendants = includeDescendants; this.DeserializeLinkedTemplate = deserializeLinkedTemplate; }
public static void SaveSyncItem(SyncItem item, string path) { using (var fileStream = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.None)) { using (var writer = new StreamWriter(fileStream)) { item.Serialize(writer); } } }
/// <summary> /// Checks if a preset includes a given serialized item /// </summary> protected FilterResult Includes(IncludeEntry entry, SyncItem item) { // check for db match if (item.DatabaseName != entry.Database) return new FilterResult(false); // check for path match if (!item.ItemPath.StartsWith(entry.Path, StringComparison.OrdinalIgnoreCase)) return new FilterResult(false); // check excludes return ExcludeMatches(entry, item.ItemPath, ID.Parse(item.ID), ID.Parse(item.TemplateID), item.TemplateName); }
public DependencyStatus GetDependencyStatus(SyncItem syncItem) { DependencyStatus status = DependencyStatus.Expired; if (_dependenciesStatus.Contains(syncItem)) { status = (DependencyStatus)_dependenciesStatus[syncItem]; } return(status); }
string ApplyTargetPathTemplate(SyncItem syncItem) { if (string.IsNullOrEmpty(syncItem.Target)) { return syncItem.Parts.Path; } return syncItem.Target .Replace("{{src.root}}", SrcRoot) .Replace("{{solution.name}}", SolutionName); }
internal DsDbTemplate(string serializationFolderName, SyncItem syncItem, FileInfo file) : base(syncItem.Name, ID.Parse(syncItem.ID)) { Assert.IsTrue( syncItem.TemplateID == TemplateIDs.Template.ToString(), string.Format("File '{0}' is a correct item file, but does not represent a template; use DsDbItem instead to deserialize this", file.FullName)); this.SerializationFolderName = serializationFolderName; this.SyncItem = syncItem; this.File = file; }
public SerializationFile DownloadFileFromSerializationItem(string itemPath) { SyncItem syncItem = SyncItemProvider.GetSyncItem(itemPath); string blobValue = syncItem.SharedValues[FileTemplateFields.Blob.FieldId]; string extension = syncItem.SharedValues[FileTemplateFields.Extension.FieldId]; byte[] fromBase64String = System.Convert.FromBase64String(blobValue); return(new SerializationFile(syncItem.Name, extension, fromBase64String)); }
/// <summary> /// Sets the upload retry counter. /// </summary> /// <param name="item">Path of the local file.</param> /// <param name="counter">Counter.</param> /// <param name="type"></param> public void SetOperationRetryCounter(SyncItem item, long counter, OperationType type) { Dictionary <string, object> parameters = new Dictionary <string, object>(); switch (type) { case OperationType.DOWNLOAD: goto case OperationType.DELETE; case OperationType.DELETE: parameters.Add("date", DateTime.Now.ToFileTimeUtc()); break; default: parameters.Add("date", File.GetLastWriteTimeUtc(item.LocalPath)); break; } parameters.Add("path", item.RemoteRelativePath); parameters.Add("counter", (counter >= 0) ? counter : 0); string uploadCounter = "(SELECT CASE WHEN lastLocalModificationDate=@date THEN uploadCounter ELSE '' END FROM failedoperations WHERE path=@path)"; string downloadCounter = "(SELECT CASE WHEN lastLocalModificationDate=@date THEN downloadCounter ELSE '' END FROM failedoperations WHERE path=@path)"; string changeCounter = "(SELECT CASE WHEN lastLocalModificationDate=@date THEN changeCounter ELSE '' END FROM failedoperations WHERE path=@path)"; string deleteCounter = "(SELECT CASE WHEN lastLocalModificationDate=@date THEN deleteCounter ELSE '' END FROM failedoperations WHERE path=@path)"; switch (type) { case OperationType.UPLOAD: uploadCounter = "@counter"; break; case OperationType.DOWNLOAD: downloadCounter = "@counter"; break; case OperationType.CHANGE: changeCounter = "@counter"; break; case OperationType.DELETE: deleteCounter = "@counter"; break; } string command = String.Format(@"INSERT OR REPLACE INTO failedoperations (path, lastLocalModificationDate, uploadCounter, downloadCounter, changeCounter, deleteCounter, uploadMessage, downloadMessage, changeMessage, deleteCounter) VALUES( @path, @date, {0},{1},{2},{3}, (SELECT CASE WHEN lastLocalModificationDate=@date THEN uploadMessage ELSE '' END FROM failedoperations WHERE path=@path ), (SELECT CASE WHEN lastLocalModificationDate=@date THEN downloadMessage ELSE '' END FROM failedoperations WHERE path=@path), (SELECT CASE WHEN lastLocalModificationDate=@date THEN changeMessage ELSE '' END FROM failedoperations WHERE path=@path), (SELECT CASE WHEN lastLocalModificationDate=@date THEN deleteMessage ELSE '' END FROM failedoperations WHERE path=@path) )", uploadCounter, downloadCounter, changeCounter, deleteCounter); ExecuteSQLAction(command, parameters); }
/// <summary> /// Deserializes all .item files below the item's children folder and all deeper directories. /// Also traverses shortened paths. /// </summary> /// <param name="itemFile"></param> /// <param name="syncItem"></param> /// <param name="serializationFolder"></param> /// <param name="maxDepth"></param> /// <returns></returns> #pragma warning disable 618 internal static List <SyncItem> DeserializeAll(this FileInfo itemFile, SyncItem syncItem, DirectoryInfo serializationFolder, int maxDepth) #pragma warning restore 618 { if (maxDepth <= 0) { #pragma warning disable 618 return(new List <SyncItem>()); #pragma warning restore 618 } Assert.ArgumentNotNull(itemFile, "itemFile"); #pragma warning disable 618 var result = new List <SyncItem>(); #pragma warning restore 618 // Find descendants in direct subfolder if (itemFile.Directory != null) { var childItemsFolder = new DirectoryInfo(itemFile.Directory.FullName + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(itemFile.Name)); if (childItemsFolder.Exists) { foreach (var childItemFile in childItemsFolder.GetFiles("*.item", SearchOption.AllDirectories)) { var childSyncItem = childItemFile.Deserialize(); result.AddRange(childItemFile.DeserializeAll(childSyncItem, serializationFolder, maxDepth - 1)); result.Add(childSyncItem); } } } // Find descendants in shortened paths var linkFiles = ShortenedPathsDictionary.GetLocationsFromLinkFiles(serializationFolder); if (!linkFiles.ContainsKey(syncItem.ItemPath)) { return(result); } var truePath = new DirectoryInfo(linkFiles[syncItem.ItemPath]); if (!truePath.Exists) { return(result); } foreach (var childItemFile in truePath.GetFiles("*.item", SearchOption.AllDirectories)) { var childSyncItem = childItemFile.Deserialize(); result.AddRange(childItemFile.DeserializeAll(childSyncItem, serializationFolder, maxDepth - 1)); result.Add(childSyncItem); } return(result); }
/// <summary> /// Remove a file from the database. /// </summary> public void RemoveFile(SyncItem item) { Dictionary <string, object> parameters = new Dictionary <string, object>(); parameters.Add("path", item.RemoteRelativePath); ExecuteSQLAction("DELETE FROM files WHERE path=@path", parameters); parameters = new Dictionary <string, object>(); parameters.Add("path", item.RemoteRelativePath); ExecuteSQLAction("DELETE FROM downloads WHERE path=@path", parameters); }
public List <SyncItem> LoadItems() { var items = new List <SyncItem>(); using (new SecurityDisabler()) { using (new ProxyDisabler()) { var reader = new ZipReader(PackagePath, Encoding.UTF8); ZipEntry entry = reader.GetEntry("package.zip"); using (var stream = new MemoryStream()) { StreamUtil.Copy(entry.GetStream(), stream, 0x4000); reader = new ZipReader(stream); foreach (ZipEntry zipEntry in reader.Entries) { var entryData = new ZipEntryData(zipEntry); try { if (entryData.Key.EndsWith("/xml")) { string xml = new StreamReader(entryData.GetStream().Stream, Encoding.UTF8).ReadToEnd(); if (!string.IsNullOrWhiteSpace(xml)) { XmlDocument document = XmlUtil.LoadXml(xml); if (document != null) { SyncItem loadedItem = LoadItem(document); if (loadedItem != null) { items.Add(loadedItem); } } } } } catch (Exception) { Console.WriteLine("Unable to load xml from file {0}", entryData.Key); } } } } } Console.WriteLine("Read {0} items from package {1}", items.Count, PackagePath); return(items); }
//-------------------------------------------------------------------------------- /// <summary> /// Adds a single sync item to the listview /// </summary> /// <param name="item"></param> private void AddSyncItem(SyncItem item) { ListViewItem lvi = new ListViewItem(item.Name); lvi.SubItems.Add(item.SyncToPath); lvi.SubItems.Add(item.SyncFromPath); lvi.SubItems.Add(item.SyncSubfolders.ToString()); lvi.SubItems.Add(item.BackupBeforeSync.ToString()); lvi.SubItems.Add(item.DeleteAfterSync.ToString()); lvi.Tag = item; this.listViewSyncItems.Items.Add(lvi); }
public void SaveAndRenameItem(SyncItem renamedItem, string oldName) { var oldRootPath = renamedItem.ItemPath.Substring(0, renamedItem.ItemPath.LastIndexOf('/') + 1) + oldName; var newRootPath = renamedItem.ItemPath; var descendantItems = _index.GetDescendants(renamedItem.GetSitecoreId()); // write the moved sync item to its new destination SaveItem(renamedItem); MoveDescendants(oldRootPath, newRootPath, renamedItem.DatabaseName, descendantItems); }
protected virtual string GetUrlFormat(SyncItem item) { if (!String.IsNullOrEmpty(item.UrlFormat)) { return(item.UrlFormat); } if (String.IsNullOrEmpty(defaultUrlFormat)) { throw new ConfigurationException(String.Format("无法为IP为{0}设置URL-FORMAT", item.IPAddress)); } return(defaultUrlFormat); }
/// <summary> /// Calculate the SHA1 checksum of a syncitem. /// Code from http://stackoverflow.com/a/1993919/226958 /// </summary> /// <param name="item">sync item</param> public static string Checksum(SyncItem item) { using (var fs = new FileStream(item.LocalPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (var bs = new BufferedStream(fs)) { using (var sha1 = new SHA1Managed()) { byte[] hash = sha1.ComputeHash(bs); return(ChecksumToString(hash)); } } }
/// <summary> /// Creates a new version for a content item in a particular language. /// </summary> /// <param name="itemDefinition">Used to identify the particular item</param> /// <param name="baseVersion">The version to copy off of</param> /// <param name="context"></param> /// <returns></returns> public override int AddVersion(ItemDefinition itemDefinition, VersionUri baseVersion, CallContext context) { if (!ItemsById.ContainsKey(itemDefinition.ID)) { return(-1); } SyncItem current = ItemsById[itemDefinition.ID]; int num = -1; Language baseVersionLanguage = baseVersion.Language; if (Language.Invariant.Equals(baseVersionLanguage)) { baseVersionLanguage = LanguageManager.DefaultLanguage; } if (baseVersion.Version != null && baseVersion.Version.Number > 0) { // copy version SyncVersion matchingVersion = (current.Versions ?? new List <SyncVersion>()) .OrderByDescending(vr => int.Parse(vr.Version)) .FirstOrDefault(vr => vr.Language.Equals(baseVersionLanguage.Name)); int?maxVersionNumber = matchingVersion != null?int.Parse(matchingVersion.Version) : null as int?; num = maxVersionNumber.HasValue && maxVersionNumber > 0 ? maxVersionNumber.Value + 1 : -1; if (num > 0) { SyncVersion newVersion = current.AddVersion(matchingVersion.Language, num.ToString(), matchingVersion.Revision); IList <SyncField> currentFieldValues = matchingVersion.Fields; foreach (SyncField fieldValue in currentFieldValues) { newVersion.AddField(fieldValue.FieldID, fieldValue.FieldName, fieldValue.FieldKey, fieldValue.FieldValue, true); } } } if (num == -1) { num = 1; // add blank version current.AddVersion(baseVersionLanguage.Name, num.ToString(), Guid.NewGuid().ToString()); } return(num); }
private string GetErrorValue(SaveArgs args) { var results = new Dictionary <Item, IList <FieldDesynchronization> >(); try { foreach (var item in args.Items) { Item existingItem = Client.ContentDatabase.GetItem(item.ID); SyncItem serializedVersion = ReadSerializedVersion(existingItem); // not having an existing serialized version means no possibility of conflict here if (serializedVersion == null) { continue; } var fieldIssues = GetFieldSyncStatus(existingItem, serializedVersion); if (fieldIssues.Count == 0) { continue; } results.Add(existingItem, fieldIssues); } // no problems if (results.Count == 0) { return(null); } var sb = new StringBuilder(); sb.Append("CRITICAL:\n"); sb.Append( "Item state conflicted with existing serialized value. Chances are you need to sync your database with the filesystem. The following fields had problems:\n"); foreach (var item in results) { sb.AppendFormat("\n{0}: {1}", item.Key.DisplayName, string.Join(", ", item.Value.Select(x => x.FieldName))); } sb.Append("\n\nDo you want to overwrite anyway? You may cause someone else to lose committed work by doing this."); return(sb.ToString()); } catch (Exception ex) { Log.Error("Exception occurred while performing serialization conflict check!", ex, this); return("Exception occurred: " + ex.Message); // this will cause a few retries } }
private void CreateAdvanceItem(RequestArgs args) { Assert.ArgumentNotNull(args, "args"); Item[] scope = args.Scope; Assert.IsNotNull(scope, "The scope is null."); Item[] scope2 = (scope.Length > 0) ? new Item[] { scope.First <Item>() } : new Item[0]; if (scope2 != null && scope2.Length > 0) { Mindtree.ItemWebApi.Pipelines.Advance.Serialize.Entities.LoadOptions loadOptions = null; SyncItem syncItem = null; try { if (args.Context.HttpContext != null && args.Context.HttpContext.Request != null && args.Context.HttpContext.Request.Form != null) { string _enkey = string.Empty; if (args.Context.HttpContext.Request.Form[Settings.enKey] != null) { _enkey = args.Context.HttpContext.Request.Form[Settings.enKey]; } if (args.Context.HttpContext.Request.Form[Settings.loadOptions] != null) { string data = args.Context.HttpContext.Request.Form[Settings.loadOptions]; loadOptions = Mindtree.ItemWebApi.Pipelines.Advance.Serialize.SerializeManager.DeSerializeLoadOptions(StringCipher.Decrypt(data, _enkey)); } if (args.Context.HttpContext.Request.Form[Settings.syncItem] != null) { string dataSyncItem = args.Context.HttpContext.Request.Form[Settings.syncItem]; syncItem = Mindtree.ItemWebApi.Pipelines.Advance.Serialize.SerializeManager.DeSerializeItem(StringCipher.Decrypt(dataSyncItem, _enkey), loadOptions); } } } catch (Exception) { } //args.Context.HttpContext.Request.Params[""] Mindtree.ItemWebApi.Pipelines.Advance.Create.CreateArgs createArgs = new Mindtree.ItemWebApi.Pipelines.Advance.Create.CreateArgs(scope2, Mindtree.ItemWebApi.Pipelines.Advance.Serialize.SerializeManager._loadOption, syncItem) { Scope = scope2 }; CorePipeline.Run("itemWebApiCreateAdvance", createArgs); args.Result = createArgs.Result; } else { throw new BadRequestException("Parent Item doesn't Exist"); } }
/// <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); }
public static SyncVersion GetVersion(this SyncItem item, VersionUri uri) { string versionString = uri.Version.Number.ToString(CultureInfo.InvariantCulture); var language = uri.Language; if (language.Equals(Language.Invariant)) { language = LanguageManager.DefaultLanguage; } return(item.Versions.FirstOrDefault(x => x.Language.Equals(language.Name, StringComparison.OrdinalIgnoreCase) && x.Version == versionString)); }
public static ID GetSitecoreParentId(this SyncItem item) { Assert.ArgumentNotNull(item, "item"); ID result; if (!ID.TryParse(item.ParentID, out result)) { throw new ArgumentOutOfRangeException("item", "SyncItem did not have a parseable ParentID!"); } return(result); }
/// <summary> /// Remove a dependencia. /// </summary> /// <param name="key">Chave.</param> /// <param name="dependency">Instancia da dependencia.</param> public void RemoveDependency(object key, CacheSyncDependency dependency) { if (_context.IsDbSyncCoordinator) { if (dependency != null) { try { SyncItem item = new SyncItem(key, dependency.Key, dependency.CacheId); lock (_dependenciesStatus.SyncRoot) { if (_dependenciesKeyMap.Contains(item)) { ArrayList list = _dependenciesKeyMap[item] as ArrayList; if (list != null) { list.Remove(key); if (list.Count > 0) { return; } } _dependenciesKeyMap.Remove(item); } if (_dependenciesStatus.Contains(item)) { _dependenciesStatus.Remove(item); } else { return; } } ISyncCache cache = _synCaches[item.CacheId] as ISyncCache; ISyncCacheEventsListener eventListener = _listeners[item.CacheId] as ISyncCacheEventsListener; if ((cache != null) && (eventListener != null)) { cache.UnRegisterSyncKeyNotifications((string)item.Key, eventListener); } } catch (Exception exception) { this.Logger.Error(("CacheSyncManager:" + exception.ToString()).GetFormatter()); } } } else { _inactiveDependencies.Remove(key); } }
public static SyncItem AttachMediaFile(this SyncItem syncItem, FileInfo fileInfo) { byte[] bytes = FileUtils.ReadFile(fileInfo.FullName); var blobValue = System.Convert.ToBase64String(bytes, Base64FormattingOptions.InsertLineBreaks); string extension = fileInfo.Extension.TrimStart('.'); string mimeType = MediaTypeResolver.Instance.ResolveMimeType(extension); syncItem.SetFieldValue(FileTemplateFields.Blob, blobValue); syncItem.SetFieldValue(FileTemplateFields.Size, bytes.Length.ToString()); syncItem.SetFieldValue(FileTemplateFields.Extension, extension); syncItem.SetFieldValue(FileTemplateFields.MimeType, mimeType); syncItem.SetFieldValue(FileTemplateFields.Icon, SitecoreUtils.GenerateIconValue(syncItem.ID)); return(syncItem); }
private SyncVersion GetVersionToUpdate(SyncItem syncItem) { SyncVersion versionToUpdate = syncItem.Versions.FirstOrDefault(v => _config.DefaultVersion.Equals(v)); if (versionToUpdate != null) { versionToUpdate = syncItem.Versions.FirstOrDefault(v => v.Language == _config.DefaultVersion.Language); if (versionToUpdate != null) { versionToUpdate = syncItem.Versions.FirstOrDefault(); } } return(versionToUpdate); }
public FilterResult Includes(SyncItem item) { var result = new FilterResult(true); FilterResult priorityResult = null; foreach (var entry in _preset) { result = Includes(entry, item); if (result.IsIncluded) return result; // it's definitely included if anything includes it if (!string.IsNullOrEmpty(result.Justification)) priorityResult = result; // a justification means this is probably a more 'important' fail than others } return priorityResult ?? result; // return the last failure }
public void Insert(SyncItem item) { Queue <SyncItem> itemQueue; lock (m_Queue) { if (!m_Queue.TryGetValue(item.LastModified, out itemQueue)) { itemQueue = new Queue <SyncItem>(); m_Queue[item.LastModified] = itemQueue; } itemQueue.Enqueue(item); m_Count++; } }
/// <summary> /// Define a situação para o item. /// </summary> /// <param name="syncItem">Instancia do item de sincronização.</param> /// <param name="status">Nova situação.</param> /// <returns></returns> private bool SetItemStatus(SyncItem syncItem, DependencyStatus status) { bool flag = false; lock (_dependenciesStatus.SyncRoot) { if (_dependenciesStatus.ContainsKey(syncItem)) { _dependenciesStatus[syncItem] = status; flag = true; } } return(flag); }
private SyncItem ReadItem(Tokenizer reader) { while ((reader.Line != null) && (reader.Line.Length == 0)) { reader.NextLine(); } if ((reader.Line == null) || (reader.Line != ItemLine)) { throw new Exception("Format error: serialized stream does not start with ----item----"); } var item = new SyncItem(); var dictionary = SerializationUtils.ReadHeaders(reader); item.ID = dictionary["id"]; item.ItemPath = dictionary["path"]; try { item.DatabaseName = dictionary["database"]; item.ParentID = dictionary["parent"]; item.Name = dictionary["name"]; item.BranchId = dictionary["master"]; item.TemplateID = dictionary["template"]; item.TemplateName = dictionary["templatekey"]; reader.NextLine(); while (reader.Line == FieldLine) { var field = ReadField(reader); if (field != null) { item.SharedFields.Add(field); } } while (reader.Line == VersionLine) { var version = ReadVersion(reader); if (version != null) { item.Versions.Add(version); } } return item; } catch (Exception exception) { throw new Exception("Error reading item: " + item.ItemPath, exception); } }
private async void Load_Click(object sender, RoutedEventArgs e) { FolderPicker folderPicker = new FolderPicker(); folderPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; folderPicker.FileTypeFilter.Add("*"); List <SyncItem> tempList = new List <SyncItem>(); StorageFolder folder = await folderPicker.PickSingleFolderAsync(); if (folder != null) { OutputTextBlock.Text = "Picked folder: " + folder.Name; IReadOnlyList <IStorageItem> itemsInFolder = await folder.GetItemsAsync(); foreach (IStorageItem item in itemsInFolder) { SyncItem temp = new SyncItem(); temp.Path = item.Path; temp.Name = item.Name; if (item.IsOfType(StorageItemTypes.Folder)) { temp.IsFolder = true; } else { temp.IsFolder = false; } tempList.Add(temp); } OutputTextBlock.Text = "Operation Success."; if ((string)(sender as Button).Content == "Load Local") { LocalStatusBox.Text = folder.Path + "\t loaded"; MainViewModel.Instance.LocalSyncItems = tempList; MainViewModel.Instance.Local = folder; } else { RemoteStatusBox.Text = folder.Path + "\t loaded"; MainViewModel.Instance.RemoteSyncItems = tempList; MainViewModel.Instance.Remote = folder; } } else { OutputTextBlock.Text = "Operation cancelled."; } await MainViewModel.WriteToFile(tempList, folder); //Will Enable Later when History and tracking is implemented }
//-------------------------------------------------------------------------------- /// <summary> /// Validates the various textbox fields. /// </summary> /// <returns></returns> private bool DataIsValid() { bool valid = true; Control invalidCtrl = null; string errorTxt = ""; // The name cannot be a duplicate of names that already exist in the sync // item collection if (NameIsDuplicate() && m_adding) { invalidCtrl = this.textBoxName; errorTxt = "The specified sync item name already exists."; } // The SyncFrom path must exist else if (!Directory.Exists(this.textBoxSyncFrom.Text)) { invalidCtrl = this.textBoxSyncFrom; errorTxt = (string.IsNullOrEmpty(this.textBoxSyncFrom.Text)) ? "The 'Sync From' folder was not specified" : "The specified 'Sync From' folder does not exist."; } // The SyncTO path must exist else if (!Directory.Exists(this.textBoxSyncTo.Text)) { invalidCtrl = this.textBoxSyncTo; errorTxt = (string.IsNullOrEmpty(this.textBoxSyncTo.Text)) ? "The 'Sync To' folder was not specified" : "The specified 'Sync To' folder does not exist."; } // If backups are to be performed, the backup path must exist else if (this.checkBoxBackupBeforeSync.Checked && !Directory.Exists(this.textBoxBackupFolder.Text)) { invalidCtrl = this.textBoxBackupFolder; errorTxt = (string.IsNullOrEmpty(this.textBoxBackupFolder.Text)) ? "The 'Backup' folder was not specified" : "The specified 'Backup' folder does not exist."; } // If we have invalid data if (invalidCtrl != null) { // show a message and focus the errant control. MessageBox.Show(errorTxt); invalidCtrl.Focus(); valid = false; } else { // otherwise, if we're adding, create a syncitem object if (m_adding) { SyncItem = new SyncItem(); } } return(valid); }
private SyncItem CreateDummyData() { var dummy = new SyncItem { Id = DateTime.Now.Ticks, FileKey = Guid.NewGuid().ToString(), CloudAssetId = Guid.NewGuid().ToString(), CloudCreated = DateTime.Now, CloudLastUpdated = DateTime.Now, IsDeleted = false, Size = 1024 }; return(dummy); }
public void Sync(SyncItem syncItem, UInt32 timestamp) { UpdateToTargetState(); UpdateView(); targetX = syncItem.values[FieldType.POSITION_X]; targetZ = syncItem.values[FieldType.POSITION_Z]; targetDirection = syncItem.values[FieldType.DIRECTION]; targetState = (int)syncItem.values[FieldType.STATE]; idleTime = syncItem.values[FieldType.IDLE_TIME]; }
//-------------------------------------------------------------------------------- public FormMain() { InitializeComponent(); //m_toFiles = new FileInfoList(); //m_toFiles.GetFiles(Globals.SyncToFolder, true); SyncItem item = new SyncItem(@"d:\asyncfrom\", @"d:\asyncto\"); item.Name = "Test Sync"; item.FileInfoEvent += new FileInfoHandler(item_FileInfoEvent); m_syncItems.Add(item); m_updateThread = new Thread(new ThreadStart(UpdateThread)); m_updateThread.IsBackground = true; }
/// <summary> /// Checks whether the database contains a given folder item. /// </summary> public bool ContainsFolder(SyncItem item) { Dictionary <string, object> parameters = new Dictionary <string, object>(); if (item is RemotePathSyncItem) { parameters.Add("path", item.RemoteRelativePath); return(null != ExecuteSQLFunction("SELECT serverSideModificationDate FROM folders WHERE path=@path", parameters)); } else { parameters.Add("localPath", item.LocalRelativePath); return(null != ExecuteSQLFunction("SELECT serverSideModificationDate FROM folders WHERE localPath=@localPath", parameters)); } }
public bool RunProcess(bool flag, SyncItem SyncParent, string fileName, string sourceName, string targetName, FileInfoEx item, string[] fileState, int fileStateValue) { bool isFound = flag; string[] extensionList = SyncParent.Pattern.Split(','); foreach (var extension in extensionList) { if (extension.ToLower() == item.FileInfoObj.Extension.ToLower()) { isFound = false; break; } } return(isFound); }
/// <summary> /// Gets the syncitem. /// </summary> /// <returns></returns> protected override SyncItem GetItem() { if (this._item != null) { return(this._item); } var itemData = GetItemData(); if (itemData == null) { return(null); } return(_item = BuildSyncItem(itemData)); }
/// <summary> /// Deserializes all .item files below the item's children folder and all deeper directories. /// Also traverses shortened paths. /// </summary> /// <param name="itemFile"></param> /// <param name="syncItem"></param> /// <param name="serializationFolder"></param> /// <param name="maxDepth"></param> /// <returns></returns> internal static List<SyncItem> DeserializeAll(this FileInfo itemFile, SyncItem syncItem, DirectoryInfo serializationFolder, int maxDepth) { if (maxDepth <= 0) { return new List<SyncItem>(); } Assert.ArgumentNotNull(itemFile, "itemFile"); var result = new List<SyncItem>(); // Find descendants in direct subfolder if (itemFile.Directory != null) { var childItemsFolder = new DirectoryInfo(itemFile.Directory.FullName + Path.DirectorySeparatorChar + Path.GetFileNameWithoutExtension(itemFile.Name)); if (childItemsFolder.Exists) { foreach (var childItemFile in childItemsFolder.GetFiles("*.item", SearchOption.AllDirectories)) { var childSyncItem = childItemFile.Deserialize(); result.AddRange(childItemFile.DeserializeAll(childSyncItem, serializationFolder, maxDepth - 1)); result.Add(childSyncItem); } } } // Find descendants in shortened paths var linkFiles = ShortenedPathsDictionary.GetLocationsFromLinkFiles(serializationFolder); if (!linkFiles.ContainsKey(syncItem.ItemPath)) { return result; } var truePath = new DirectoryInfo(linkFiles[syncItem.ItemPath]); if (!truePath.Exists) { return result; } foreach (var childItemFile in truePath.GetFiles("*.item", SearchOption.AllDirectories)) { var childSyncItem = childItemFile.Deserialize(); result.AddRange(childItemFile.DeserializeAll(childSyncItem, serializationFolder, maxDepth - 1)); result.Add(childSyncItem); } return result; }
public void CreateItem(SyncItem syncItem) { var newPath = PathUtils.GetFilePath(new ItemReference(syncItem.DatabaseName, syncItem.ItemPath).ToString()); var parentPath = Path.GetDirectoryName(newPath); Directory.CreateDirectory(parentPath); using (var fileStream = File.Open(newPath, FileMode.CreateNew, FileAccess.Write, FileShare.Write)) { using (var writer = new StreamWriter(fileStream)) { syncItem.Serialize(writer); } } _innerItems.Add(syncItem); }
public bool CreateItem(Guid id, string name, Guid templateId, Guid parentId) { var parent = _database.GetItem(new ID(parentId).ToString()); var template = _database.GetItem(new ID(templateId).ToString()); string newItemFullPath = parent.ItemPath + "/" + name; var syncItem = new SyncItem(); syncItem.ID = new ID(id).ToString(); syncItem.Name = name; syncItem.TemplateID = new ID(templateId).ToString(); syncItem.TemplateName = template.Name; syncItem.ParentID = new ID(parentId).ToString(); syncItem.DatabaseName = "master"; // ugly syncItem.ItemPath = newItemFullPath; syncItem.MasterID = ID.Null.ToString(); _database.CreateItem(syncItem); return true; }
public void SaveItem(SyncItem syncItem) { Assert.ArgumentNotNull(syncItem, "syncItem"); var newPath = GetPhysicalSyncItemPath(syncItem); var parentPath = Path.GetDirectoryName(newPath); if (parentPath != null) Directory.CreateDirectory(parentPath); using (new WatcherDisabler(_watcher)) { using (var fileStream = File.Open(newPath, FileMode.Create, FileAccess.Write, FileShare.Write)) { using (var writer = new StreamWriter(fileStream)) { syncItem.Serialize(writer); } } } _index.UpdateIndexes(syncItem); }
public void UpdateIndexes(SyncItem item) { lock (_innerItemsLock) { for (int i = 0; i < _innerItems.Count; i++) { if (_innerItems[i].ID == item.ID) { _innerItems[i] = item; ResetCacheIndexes(); return; } } _innerItems.Add(item); } // TODO: could possibly find the item in the other indices and change them instead of nuking the whole index ResetCacheIndexes(); }
protected override SyncItem GetItem() { return _item = base.GetItem(); }
public override bool CreateItem(ID itemId, string itemName, ID templateId, ItemDefinition parent, CallContext context) { Assert.ArgumentNotNull(itemId, "itemId"); Assert.ArgumentNotNullOrEmpty(itemName, "itemName"); Assert.ArgumentNotNull(templateId, "templateId"); Assert.ArgumentNotNull(parent, "parent"); Assert.ArgumentNotNull(context, "context"); var existingItem = SerializedDatabase.GetItem(itemId); if (existingItem != null) { Log.Warn("Rhino tried to create item " + itemId + " but it already existed! Not creating it again.", this); return false; } // NOTE how we use the Database to get the parent - this allows us to resolve the parent regardless of the data provider it resides in var parentItem = Database.GetItem(parent.ID); Assert.IsNotNull(parentItem, "Parent item {0} did not exist!", parent.ID); var template = TemplateManager.GetTemplate(templateId, context.DataManager.Database); Assert.IsNotNull(template, "The template ID {0} could not be found in {1}!", templateId, context.DataManager.Database.Name); string newItemFullPath = string.Concat(parentItem.Paths.FullPath, "/", itemName); var syncItem = new SyncItem { ID = itemId.ToString(), Name = itemName, TemplateID = templateId.ToString(), TemplateName = template.Name, ParentID = parent.ID.ToString(), DatabaseName = context.DataManager.Database.Name, ItemPath = newItemFullPath, MasterID = ID.Null.ToString() }; SerializedDatabase.SaveItem(syncItem); return true; }
public QuickContentDataItem(string rootPath, string relatedPath, string name, SyncItem syncItem) : base(rootPath, relatedPath, name, syncItem) { }
/// <summary> /// Checks to see if we should force an item to be written from the serialized version. /// This changes the rules slightly from the default deserializer by forcing if the dates are /// different instead of only if they are newer on disk. /// </summary> private bool ShouldForceUpdate(SyncItem syncItem, IProgressStatus progress) { Database db = Factory.GetDatabase(syncItem.DatabaseName); Assert.IsNotNull(db, "Database was null"); Item target = db.GetItem(syncItem.ID); if (target == null) return true; // target item doesn't exist - must force // see if the modified date is different in any version (because disk is master, ANY changes we want to force overwrite) return syncItem.Versions.Any(version => { Item targetVersion = target.Database.GetItem(target.ID, Language.Parse(version.Language), Sitecore.Data.Version.Parse(version.Version)); var serializedModified = version.Values[FieldIDs.Updated.ToString()]; var itemModified = targetVersion[FieldIDs.Updated.ToString()]; if (!string.IsNullOrEmpty(serializedModified)) { var result = string.Compare(serializedModified, itemModified, StringComparison.InvariantCulture) != 0; if (result) progress.ReportStatus( string.Format("{0} ({1} #{2}): Disk modified {3}, Item modified {4}", syncItem.ItemPath, version.Language, version.Version, serializedModified, itemModified), MessageType.Debug); return result; } // ocasionally a version will not have a modified date, only a revision so we compare those as a backup var serializedRevision = version.Values[FieldIDs.Revision.ToString()]; var itemRevision = targetVersion.Statistics.Revision; if (!string.IsNullOrEmpty(serializedRevision)) { var result = string.Compare(serializedRevision, itemRevision, StringComparison.InvariantCulture) != 0; if (result) progress.ReportStatus( string.Format("{0} ({1} #{2}): Disk revision {3}, Item revision {4}", syncItem.ItemPath, version.Language, version.Version, serializedRevision, itemRevision), MessageType.Debug); return result; } // if we get here we have no valid updated or revision to compare. Let's ignore the item as if it was a real item it'd have one of these. if(!syncItem.ItemPath.StartsWith("/sitecore/templates/System") && !syncItem.ItemPath.StartsWith("/sitecore/templates/Sitecore Client")) // this occurs a lot in stock system templates - we ignore warnings for those as it's expected. progress.ReportStatus(string.Format("{0} ({1} #{2}): Serialized version had no modified or revision field to check for update.", syncItem.ItemPath, version.Language, version.Version), MessageType.Warning); return false; }); }
/// <summary> /// Adds an item to the in-memory set of items. /// </summary> /// <param name="syncItem"></param> protected void AddItem(SyncItem syncItem) { ID itemId = ParseId(syncItem.ID); if (!ItemsById.ContainsKey(itemId)) { ItemsById.Add(itemId, syncItem); ItemsByParentId.Add(new KeyValuePair<ID, SyncItem>(ParseId(syncItem.ParentID), syncItem)); } }
/// <summary> /// Create a new item as a child of another item. /// Note that this does not create any versions or field values. /// </summary> /// <param name="itemID">The item ID (not the parent's)</param> /// <param name="itemName">The name of the new item</param> /// <param name="templateID">The ID of the content item that represents its template</param> /// <param name="parent">The parent item's definition</param> /// <param name="context"></param> /// <returns></returns> public override bool CreateItem(ID itemID, string itemName, ID templateID, ItemDefinition parent, CallContext context) { if (ItemsById.ContainsKey(itemID)) { // item already exists return false; } if (parent != null) { if (! ItemsById.ContainsKey(parent.ID)) { // parent item does not exist in this provider return false; } } SyncItem newItem = new SyncItem() { ID = GetIdAsString(itemID), Name = itemName, TemplateID = GetIdAsString(templateID), ParentID = GetIdAsString(parent != null ? parent.ID : new ID(Guid.Empty)), ItemPath = parent == null ? string.Format("/{0}", itemName) : string.Format("{0}/{1}", GetItemPath(parent.ID), itemName), BranchId = GetIdAsString(new ID(Guid.Empty)), DatabaseName = Database.Name }; AddItem(newItem); AddVersion(new ItemDefinition(itemID, itemName, templateID, new ID(Guid.Empty)), new VersionUri(Language.Invariant, null), context); return true; }
public TemplateField(SyncItem fieldItem) : base(fieldItem) { FieldTypeName = GetSharedFieldValue("Type", "(unknown)"); FieldTitle = GetFieldValue("Title"); }
public void DeleteRemoteDocument(IDocument document, SyncItem syncItem) { string message0 = "CmisSync Warning: You have deleted file " + syncItem.LocalPath + "\nCmisSync will now delete it from the server. If you actually did not delete this file, please report a bug at [email protected]"; Logger.Info(message0); //Utils.NotifyUser(message0); if (document.IsVersionSeriesCheckedOut != null && (bool)document.IsVersionSeriesCheckedOut) { string message = String.Format("File {0} is checked out on the server by another user: {1}", syncItem.LocalPath, document.CheckinComment); Logger.Info(message); Utils.NotifyUser(message); } else { // File has been recently removed locally, so remove it from server too. activityListener.ActivityStarted(); Logger.Info("Removing locally deleted file on server: " + syncItem.RemotePath); document.DeleteAllVersions(); // Remove it from database. database.RemoveFile(syncItem); activityListener.ActivityStopped(); } }
/// <summary> /// Delete the folder from the remote server. /// </summary> public void DeleteRemoteFolder(IFolder folder, SyncItem syncItem, string upperFolderPath) { try { Logger.Debug("Removing remote folder tree: " + folder.Path); IList<string> failedIDs = folder.DeleteTree(true, null, true); if (failedIDs == null || failedIDs.Count != 0) { Logger.Error("Failed to completely delete remote folder " + folder.Path); // TODO Should we retry? Maybe at least once, as a manual recursion instead of a DeleteTree. } // Delete the folder from database. database.RemoveFolder(syncItem); } catch (CmisPermissionDeniedException e) { // TODO: Add resource string message = String.Format("フォルダ {0} に対して削除やリネームする権限がないため、サーバからこのフォルダを復元します(フォルダに含まれるファイル数が多い場合、復元に時間がかかります)。", syncItem.LocalPath); Utils.NotifyUser(message); // We don't have the permission to delete this folder. Warn and recreate it. /* Utils.NotifyUser("You don't have the necessary permissions to delete folder " + folder.Path + "\nIf you feel you should be able to delete it, please contact your server administrator"); */ database.RemoveFolder(syncItem); DownloadDirectory(folder, syncItem.RemotePath, syncItem.LocalPath); } }
public SyncItemWrapper(SyncItem item) { _item = item; }
public void DeleteRemoteDocument(IDocument remoteDocument, SyncItem syncItem) { string message0 = "CmisSync Warning: You have deleted file " + syncItem.LocalPath + "\nCmisSync will now delete it from the server. If you actually did not delete this file, please report a bug at [email protected]"; Logger.Info(message0); //Utils.NotifyUser(message0); if (remoteDocument.IsVersionSeriesCheckedOut != null && (bool)remoteDocument.IsVersionSeriesCheckedOut && remoteDocument.VersionSeriesCheckedOutBy != null && !remoteDocument.VersionSeriesCheckedOutBy.Equals(repoInfo.User)) { string message = String.Format("Restoring file \"{0}\" because it is checked out on the server by another user: {1}", syncItem.LocalPath, remoteDocument.VersionSeriesCheckedOutBy); Logger.Info(message); Utils.NotifyUser(message); // Restore the deleted file activityListener.ActivityStarted(); DownloadFile(remoteDocument, syncItem.RemotePath, Path.GetDirectoryName(syncItem.LocalPath)); activityListener.ActivityStopped(); } else { // File has been recently removed locally, so remove it from server too. activityListener.ActivityStarted(); Logger.Info("Removing locally deleted file on server: " + syncItem.RemotePath); remoteDocument.DeleteAllVersions(); // Remove it from database. database.RemoveFile(syncItem); activityListener.ActivityStopped(); } }