private void RegisterFileResourceTypeImpl(string fileResType, params string[] exts) { foreach (string ext in exts) { if (ext.Length > 0) { string lower_ext = ext.ToLower(); IResource fileMapEntry = _store.FindUniqueResource("FileTypeMap", _propExtension, lower_ext); if (fileMapEntry == null) { fileMapEntry = _store.BeginNewResource("FileTypeMap"); } else { fileMapEntry.BeginUpdate(); } try { fileMapEntry.SetProp(_propExtension, lower_ext); fileMapEntry.SetProp(_propResType, fileResType); lock ( _extension2ResTypeMap ) { _extension2ResTypeMap[lower_ext] = fileResType; } } finally { fileMapEntry.EndUpdate(); } } } RegisterFileTypeColumns(fileResType); }
[Test] public void UnreadOnOff() { IResource email = _storage.NewResource("Email"); email.SetProp(_propUnread, true); _folder.AddLink(_propFolder, email); email.BeginUpdate(); email.SetProp(_propUnread, false); email.SetProp(_propUnread, true); email.EndUpdate(); Assert.AreEqual(1, _unreadManager.GetUnreadCount(_folder)); IResource email2 = _storage.NewResource("Email"); _folder.AddLink(_propFolder, email2); email2.BeginUpdate(); email2.SetProp(_propUnread, true); email2.SetProp(_propUnread, false); email2.EndUpdate(); Assert.AreEqual(1, _unreadManager.GetUnreadCount(_folder)); }
private void SetGroupNumbers() { if (!Core.ResourceStore.IsOwnerThread()) { Core.ResourceAP.QueueJob( _priority, "Updating newsgroup structure", new MethodInvoker(SetGroupNumbers)); } else { IResource group = _group.Resource; if (!group.IsDeleted) { group.BeginUpdate(); try { _group.LastArticle = _lastArticle; _group.FirstArticle = _firstArticle; if (_firstArticleCopy >= _group.FirstArticle) { group.SetProp(NntpPlugin._propNoMoreHeaders, true); } } finally { group.EndUpdate(); } } } }
private static void LinkResource(BinaryReader reader, IResource result, int linkId, BeforeDeserializationDelegate beforeCheck) { int linkedResId = reader.ReadInt32(); IResource linked = Core.ResourceStore.TryLoadResource(linkedResId); if (linked != null) { linked.BeginUpdate(); // Caller may need to perform special actions, e.g. to // keep the consistency of link restrictions if (beforeCheck != null) { beforeCheck(result, linked, linkId); } if (Math.Abs(linkId) == Core.ContactManager.Props.LinkBaseContact) { Trace.WriteLine("Deserializer -- adding link between " + result.DisplayName + "/" + result.Id + " and " + linked.DisplayName + "/" + linked.Id); } if (linkId < 0) { linked.AddLink(-linkId, result); } else { result.AddLink(linkId, linked); } linked.EndUpdate(); } }
[Test] public void UnreadAndLink() { IResource email = _storage.BeginNewResource("Email"); email.SetProp(_propUnread, true); email.AddLink(_propFolder, _folder); email.EndUpdate(); Assert.AreEqual(1, _unreadManager.GetUnreadCount(_folder)); IResource email2 = _storage.BeginNewResource("Email"); email2.AddLink(_propFolder, _folder); email2.SetProp(_propUnread, true); email2.EndUpdate(); Assert.AreEqual(2, _unreadManager.GetUnreadCount(_folder)); email.BeginUpdate(); email.SetProp(_propUnread, false); email.DeleteLink(_propFolder, _folder); email.EndUpdate(); Assert.AreEqual(1, _unreadManager.GetUnreadCount(_folder)); email2.Delete(); Assert.AreEqual(0, _unreadManager.GetUnreadCount(_folder)); }
private void CreateFolder(string path) { IResource folder = Core.ResourceStore.FindUniqueResource( FileProxy._folderResourceType, FileProxy._propDirectory, path); if (folder != null) { folder.BeginUpdate(); } else { folder = Core.ResourceStore.BeginNewResource(FileProxy._folderResourceType); } try { Core.WorkspaceManager.AddToActiveWorkspaceRecursive(folder); folder.SetProp(Core.Props.Name, path); folder.SetProp(FileProxy._propDirectory, path); folder.SetProp(FileProxy._propParentFolder, FoldersCollection.Instance.FilesRoot); folder.SetProp(FileProxy._propStatus, _statusBox.SelectedIndex); folder.SetProp(FileProxy._propNew, true); folder.SetProp(FileProxy._propDeleted, false); } finally { folder.EndUpdate(); } }
private static void MoveDirectory(string dest, IResource folder, IResource targetResource) { string source = folder.GetPropText(_propDirectory); Directory.Move(source, dest); folder.BeginUpdate(); try { folder.SetProp(_propDirectory, dest); folder.SetProp(_propParentFolder, targetResource); } finally { folder.EndUpdate(); } foreach (IResource file in folder.GetLinksTo(null, _propParentFolder).ValidResources) { if (file.Type != _folderResourceType) { file.SetProp(_propDirectory, dest); } else { string name = file.GetPropText(_propDirectory).Replace(source, null).Trim('/', '\\'); file.SetProp(_propDirectory, IOTools.Combine(dest, name)); } } }
public override MDState BeginUpdate(ref IResource resMail) { if (resMail != null) { resMail.BeginUpdate(); } return(this); }
private void NewWeblink() { bool newWeblink = false; if (_favorite == null) { _favorite = Core.ResourceStore.BeginNewResource("Weblink"); newWeblink = true; } else { _favorite.BeginUpdate(); } try { string url = _URLBox.Text; _favorite.SetProp(Core.Props.Name, _nameBox.Text); _favorite.SetProp(FavoritesPlugin._propURL, url); int updateFreq = 0; if (_updateCheckBox.Checked) { updateFreq = (int)_hoursBox.Value * 60 * 60; int unitIndex = _unitBox.SelectedIndex; if (unitIndex > 0) // days or weeks { updateFreq *= 24; if (unitIndex > 1) // weeks { updateFreq *= 7; } } } _favorite.SetProp(FavoritesPlugin._propUpdateFreq, updateFreq); if (_parent != null) { _favorite.AddLink(FavoritesPlugin._propParent, _parent); } Core.WorkspaceManager.AddToActiveWorkspace(_favorite); } finally { _favorite.EndUpdate(); } if (newWeblink) { IBookmarkProfile profile = _bookmarkService.GetOwnerProfile(_favorite); string error = null; if (profile != null && profile.CanCreate(_favorite, out error)) { profile.Create(_favorite); } else { Core.UserInterfaceAP.QueueJob(new LineDelegate(DisplayError), error); } BookmarkService.ImmediateQueueWeblink(_favorite, _URLBox.Text); } }
public void BeginUpdate() { _updateCount++; if (_updateCount == 1) { _oldBody = ContactBody; _resource.BeginUpdate(); } }
public static IResource FindOrCreate(FolderDescriptor folderDescriptor, IResource parentFolder) { Guard.NullArgument(folderDescriptor, "folderDescriptor"); IResource MAPIStore = FindOrCreateMAPIStore(folderDescriptor.FolderIDs.StoreId); IResource resFolder = Core.ResourceStore.FindUniqueResource(STR.MAPIFolder, PROP.EntryID, folderDescriptor.FolderIDs.EntryId); if (resFolder != null) { resFolder.BeginUpdate(); } else { resFolder = Core.ResourceStore.BeginNewResource(STR.MAPIFolder); Core.WorkspaceManager.AddToActiveWorkspaceRecursive(resFolder); resFolder.SetProp("EntryID", folderDescriptor.FolderIDs.EntryId); resFolder.SetProp("OwnerStore", MAPIStore); if (OutlookSession.IsDeletedItemsFolder(folderDescriptor.FolderIDs.EntryId)) { resFolder.SetProp(Core.Props.ShowDeletedItems, true); resFolder.SetProp(PROP.DeletedItemsFolder, true); resFolder.SetProp(PROP.DefaultDeletedItems, true); } if (parentFolder != null) { SetIgnored(resFolder, IsIgnored(parentFolder)); } } SetName(resFolder, folderDescriptor.Name); string containerClass = folderDescriptor.ContainerClass; resFolder.SetProp(PROP.PR_STORE_SUPPORT_MASK, folderDescriptor.StoreSupportMask); resFolder.SetProp(PROP.PR_CONTENT_COUNT, folderDescriptor.ContentCount); if (containerClass.Length > 0) { resFolder.SetProp(PROP.ContainerClass, containerClass); } containerClass = resFolder.GetPropText(PROP.ContainerClass); bool visible = (containerClass.Length == 0 || containerClass == FolderType.Mail || containerClass == FolderType.Post || containerClass == FolderType.IMAP || containerClass == FolderType.Dav); resFolder.SetProp(PROP.MAPIVisible, visible); if (parentFolder != null) { SetParent(resFolder, parentFolder); } else { Folder.SetAsRoot(resFolder); } resFolder.EndUpdate(); _resourceTreeManager.SetResourceNodeSort(resFolder, STR.Name); return(resFolder); }
private void ProcessFile() { if (_webLink.IsDeleted) // if favorite resource was deleted then do nothing { return; } FileInfo fileInfo = _reader.fileInfo; Stream readStream = _reader.ReadStream; using ( readStream ) { DateTime lastWriteTime = IOTools.GetLastWriteTime(fileInfo); if (!_webLink.HasProp("LastModified") || lastWriteTime > LastModified() || _webLink.HasProp(Core.Props.LastError)) { bool isShowed = BookmarkService.BookmarkSynchronizationFrequency(_webLink) > 0; IResource formatFile = _webLink.GetLinkProp("Source"); _webLink.BeginUpdate(); if (formatFile != null) { formatFile.BeginUpdate(); } else { string resourceType = Core.FileResourceManager.GetResourceTypeByExtension(fileInfo.Extension); if (resourceType == null) { resourceType = "UnknownFile"; } formatFile = Core.ResourceStore.BeginNewResource(resourceType); _webLink.AddLink("Source", formatFile); } if (_webLink.HasProp(Core.Props.LastError)) { SetLastError(null); } _webLink.SetProp("LastModified", lastWriteTime); formatFile.SetProp(Core.Props.Size, (int)readStream.Length); formatFile.SetProp(FavoritesPlugin._propContent, readStream); if (isShowed) { formatFile.SetProp(Core.Props.Date, lastWriteTime); formatFile.SetProp(FavoritesPlugin._propIsUnread, true); Core.FilterEngine.ExecRules(StandardEvents.ResourceReceived, _webLink); } if (formatFile.Type != "UnknownFile") { Core.TextIndexManager.QueryIndexing(formatFile.Id); } _webLink.EndUpdate(); formatFile.EndUpdate(); } } }
protected override void Execute() { if (_resource != null && _resource.IsDeleted) { return; } if (_deletedItemsId == null && _entryId == null) { return; } if (_resource == null && _deletedItemsId != null) { _resource = Core.ResourceStore.FindUniqueResource(STR.MAPIInfoStore, PROP.DeletedItemsEntryID, _deletedItemsId); } if (_resource == null) { _resource = Core.ResourceStore.BeginNewResource(STR.MAPIInfoStore); } else { _resource.BeginUpdate(); } IStringList propList = _resource.GetStringListProp(PROP.DefaultFolderEntryIDs); propList.Clear(); foreach (string entryId in _defaultFolderEntryIDs) { propList.Add(entryId); } _resource.SetProp(PROP.EntryID, _entryId); _resource.SetProp(PROP.DeletedItemsEntryID, _deletedItemsId); _resource.SetProp(PROP.JunkEmailEntryID, _junkEmailId); _resource.SetProp(PROP.PR_STORE_SUPPORT_MASK, _supportMask); _resource.SetProp(PROP.StoreSupported, _supported); if (!_supported) { _resource.SetProp(PROP.IgnoredFolder, 1); _name += " (Not supported)"; } else if ((_supportMask & STORE_SUPPORT_MASK.STORE_PUBLIC_FOLDERS) != 0) { _resource.SetProp(PROP.IgnoredFolder, 1); } _resource.SetProp(Core.Props.Name, _name); _resource.SetProp(PROP.StoreTypeChecked, _storeTypeChecked); _resource.EndUpdate(); }
private static void AddSpecificParams(IResource rule, string name, Icon icon) { rule.BeginUpdate(); rule.SetProp("IsTrayIconFilter", true); rule.SetProp("DeepName", name); rule.SetProp("IsLiveMode", true); JetMemoryStream mstrm = new JetMemoryStream(2048); icon.Save(mstrm); rule.SetProp("IconBlob", mstrm); rule.DeleteProp(Core.Props.LastError); rule.EndUpdate(); }
public virtual MDState BeginUpdate(ref IResource resMail) { if (resMail == null) { resMail = Core.ResourceStore.BeginNewResource(STR.Email); if (Settings.UseOutlookListeners) { Tracer._Trace("Created email resource ID=" + resMail.Id); } return(this); } resMail.BeginUpdate(); return(MailDescriptor.UpdateState); }
private void Dismiss(IResource task) { if (!task.IsDeleted) { task.BeginUpdate(); try { task.DeleteProp(TasksPlugin._propRemindDate); task.DeleteLinks(TasksPlugin._propRemindWorkspace); } finally { task.EndUpdate(); } } }
private void Snooze(IResource task) { if (!task.IsDeleted) { task.BeginUpdate(); try { DateTime rd = DateTime.Now.Add(_snoozePeriods[_snoozePeriodList.SelectedIndex]); task.SetProp(TasksPlugin._propRemindDate, rd); } finally { task.EndUpdate(); } } }
private static void MoveFile(string source, string dest, string directory, IResource file, IResource targetResource) { File.Move(source, dest); if (!file.IsTransient) { file.BeginUpdate(); try { file.SetProp(_propDirectory, directory); file.SetProp(_propParentFolder, targetResource); } finally { file.EndUpdate(); } } }
[Test] public void OneEventTest() { IResourceList list = Core.ResourceStore.GetAllResourcesLive("Setting"); ChangeListener listener = new ChangeListener(); list.ResourceChanged += new ResourcePropIndexEventHandler(listener.list_ResourceChanged); IResource setting = Core.ResourceStore.BeginNewResource("Setting"); setting.EndUpdate(); setting.BeginUpdate(); IntResourceSetting setting1 = new IntResourceSetting(setting, _SIZE, 30); IntResourceSetting setting2 = new IntResourceSetting(setting, _NUM, 5); setting1.Save(12); setting2.Save(13); setting.EndUpdate(); Assert.AreEqual(1, listener.Count); }
/// <summary> /// Processes drop of something on the task. May either link-as-attachment or link-as-supertask. /// Must be called on the Resource thread. /// </summary> internal static void AddDescendants(IResource task, IResourceList descendants, int linkId) { ArrayList parentTasks = new ArrayList(); task.BeginUpdate(); try { foreach (IResource res in descendants) { // Attached resources may be linked to many tasks, while // tasks may have only one supertask. if (res.Type != "Task") { res.AddLink(linkId, task); } else { // Collect current parents of the tasks in order to // recalculate their stati on completeness and dates IResource parent = res.GetLinkProp(linkId); if (parent != null && parent.Id != TasksPlugin.RootTask.Id) { parentTasks.Add(parent); } res.SetProp(linkId, task); } } } finally { task.EndUpdate(); } if (task.Id != TasksPlugin.RootTask.Id) { parentTasks.Add(task); } TasksPlugin.RecalculateSupertaskParameters(parentTasks); }
/** * performs renaming of a directory updating all its sub-directories */ public void RenameDirectory(IResource folder, string name, string fullname) { if (!Core.ResourceStore.IsOwnerThread()) { _resourceAP.RunUniqueJob("Renaming directory", new RenameDirectoryDelegate(RenameDirectory), folder, name, fullname); } else { folder.BeginUpdate(); try { folder.SetProp(Core.Props.Name, name); folder.SetProp(FileProxy._propDirectory, fullname); } finally { folder.EndUpdate(); } foreach (IResource res in folder.GetLinksTo(null, FileProxy._propParentFolder)) { if (res.Type != FileProxy._folderResourceType) { res.SetProp(FileProxy._propDirectory, fullname); } else { string folderName = res.GetPropText(Core.Props.Name); string folderFullName = IOTools.Combine(fullname, folderName); if (folderFullName.Length > 0) { RenameDirectory(res, folderName, folderFullName); } } } } }
private void SubmitChanges() { if (!_weblink.IsTransient) { _weblink.BeginUpdate(); } try { string annotation = _edtAnnotation.Text; if (annotation.Length == 0) { _weblink.DeleteProp("Annotation"); } else { _weblink.SetProp("Annotation", annotation); } string name = _nameBox.Text; if (name != _weblink.GetPropText(Core.Props.Name)) { _weblink.SetProp(Core.Props.Name, name); IBookmarkService service = (IBookmarkService)Core.PluginLoader.GetPluginService(typeof(IBookmarkService)); IBookmarkProfile profile = service.GetOwnerProfile(_weblink); string error; if (profile != null && profile.CanCreate(_weblink, out error)) { profile.Create(_weblink); } } } finally { _weblink.EndUpdate(); } }
private void DoSave() { lock (this) { if (_resource == null) { _resource = Core.ResourceStore.BeginNewResource(_newResourceType); BusinessObjectCache.Put(this); } else { _resource.BeginUpdate(); } if (_props != null) { foreach (var prop in _props) { _resource.SetProp(prop.Key, prop.Value); } _props = null; } _resource.EndUpdate(); } }
private void RSSParseDelegate() { if (_feed.IsDeleted) { OnParseDone(RSSWorkStatus.FeedDeleted); return; } Stream feedStream = _httpReader.ReadStream; _feed.BeginUpdate(); try { if (HttpStatus == HttpStatusCode.Moved && _httpReader.RedirectUrl != null) { _feed.SetProp(Props.URL, _httpReader.RedirectUrl); } byte[] streamStartBytes = new byte[256]; int cBytes = feedStream.Read(streamStartBytes, 0, 256); string streamStart = Encoding.Default.GetString(streamStartBytes, 0, cBytes); feedStream.Position = 0; Encoding encoding = null; string charset = _httpReader.CharacterSet; if (charset != null) { try { encoding = Encoding.GetEncoding(charset); } catch (Exception) { Trace.WriteLine("Unknown encoding in HTTP for RSS feed: " + charset); encoding = null; } } TraceUrlsUnderSpy(_feed, feedStream, encoding); RSSParser parser = new RSSParser(_feed); try { parser.Parse(feedStream, encoding, _parseItems); } catch (XmlException e) { feedStream.Position = 0; if (_acceptHtmlIfXmlError && ((_httpReader.WebResponse != null && _httpReader.WebResponse.ContentType.StartsWith("text/html")) || HtmlTools.IsHTML(streamStart))) { OnParseDone(RSSWorkStatus.FoundHTML); } else { _lastException = e; OnParseDone(RSSWorkStatus.XMLError); } return; } if (parser.FoundChannel) { if (_parseItems && _httpReader.ETag != null && _httpReader.ETag.Length > 0) { _feed.SetProp(Props.ETag, _httpReader.ETag); } else { _feed.DeleteProp(Props.ETag); } OnParseDone(RSSWorkStatus.Success); } else if (HtmlTools.IsHTML(streamStart)) { OnParseDone(RSSWorkStatus.FoundHTML); } else { OnParseDone(RSSWorkStatus.FoundXML); } } finally { _feed.EndUpdate(); if (RSSParser._nextItem != null) { RSSParser._nextItem.ClearProperties(); } } Core.NetworkAP.QueueJob(_cleanJob); }
/** * IResource article can be null, in that case the new article is created */ public static IResource PlaceArticle(IResource article, IResource folder, IResourceList groups, string from, string subject, string text, string charset, string references, string nntpText, IResourceList attachments) { IResourceStore store = Core.ResourceStore; if (!store.IsOwnerThread()) { IAsyncProcessor resourceProcessor = Core.ResourceAP; article = (IResource)resourceProcessor.RunUniqueJob( new PlaceArticleDelegate(PlaceArticle), article, folder, groups, from, subject, text, charset, references, nntpText, attachments); } else { if (article == null || article.IsDeleted) { article = store.BeginNewResource(NntpPlugin._newsLocalArticle); } else { article.BeginUpdate(); article.DeleteProp(NntpPlugin._propArticleId); } try { article.SetProp(Core.Props.Subject, subject); article.SetProp(Core.Props.Date, DateTime.Now); IContact sender; NewsArticleParser.ParseFrom(article, from, out sender); NewsArticleParser.ParseReferences(article, references); article.SetProp(Core.Props.LongBody, text); article.SetProp(Core.FileResourceManager.PropCharset, charset); article.SetProp(NntpPlugin._propNntpText, nntpText); if (!folder.IsDeleted) { article.SetProp(NntpPlugin._propTo, folder); } if (groups != null) { foreach (IResource group in groups) { if (!group.IsDeleted) { article.AddLink(NntpPlugin._propTo, group); } } } if (attachments != null) { foreach (IResource attachment in attachments) { if (!attachment.IsDeleted) { attachment.AddLink(NntpPlugin._propAttachment, article); string actualResourceType = Core.FileResourceManager.GetResourceTypeByExtension( IOTools.GetExtension(attachment.GetPropText(Core.Props.Name))); if (actualResourceType != null && attachment.Type != actualResourceType) { attachment.ChangeType(actualResourceType); } if (attachment.IsTransient) { attachment.EndUpdate(); } } } } Core.WorkspaceManager.AddToActiveWorkspace(article); } finally { article.EndUpdate(); Core.TextIndexManager.QueryIndexing(article.Id); } } return(article); }
/** * finds or creates resource for a file * for the UnknowFile type creates transient resources */ public IResource FindOrCreateFile(FileInfo fileInfo, bool createTransient) { string resourceType; bool indexIt = false; DateTime lastWriteTime = IOTools.GetLastWriteTime(fileInfo); string extension = IOTools.GetExtension(fileInfo); int size = (int)IOTools.GetLength(fileInfo); string name = IOTools.GetName(fileInfo); IResource file = FindFile(fileInfo); if (file != null) { if (!Core.ResourceStore.IsOwnerThread()) { return((IResource)_resourceAP.RunUniqueJob(_cUpdatingFileJob, _findOrCreateFileDelegate, fileInfo, createTransient)); } file.BeginUpdate(); if (file.Type == FileProxy._unknownFileResourceType && (resourceType = _ftm.GetResourceTypeByExtension(extension)) != null) { file.ChangeType(resourceType); indexIt = true; } if (name != file.GetPropText(Core.Props.Name)) { file.SetProp(Core.Props.Name, name); indexIt = true; } if (lastWriteTime != file.GetDateProp(Core.Props.Date)) { file.SetProp(Core.Props.Date, lastWriteTime); indexIt = true; } indexIt = indexIt || (!file.IsTransient && !file.HasProp("InTextIndex")); file.SetProp(FileProxy._propSize, size); string filetype = FileSystemTypes.GetFileType(extension); file.SetProp(FileProxy._propFileType, filetype ?? "Unknown"); } else { string directoryName = IOTools.GetDirectoryName(fileInfo); IResource folder = FindOrCreateDirectory(directoryName); if (folder == null) { return(null); } resourceType = _ftm.GetResourceTypeByExtension(extension); /** * look through pending file deletions */ IResourceList deletedFiles = Core.ResourceStore.FindResourcesWithProp(resourceType, FileProxy._propDeletedFile); deletedFiles = deletedFiles.Intersect( Core.ResourceStore.FindResources(null, FileProxy._propSize, size), true); deletedFiles = deletedFiles.Intersect( Core.ResourceStore.FindResources(null, Core.Props.Name, name), true); if (deletedFiles.Count > 0) { file = deletedFiles[0]; if (!file.IsTransient) { if (!Core.ResourceStore.IsOwnerThread()) { return((IResource)_resourceAP.RunUniqueJob( _cUpdatingFileJob, _findOrCreateFileDelegate, fileInfo, createTransient)); } file.BeginUpdate(); } } if (file == null) { if (resourceType != null && !createTransient) { if (!Core.ResourceStore.IsOwnerThread()) { return((IResource)_resourceAP.RunUniqueJob( _cUpdatingFileJob, _findOrCreateFileDelegate, fileInfo, createTransient)); } file = Core.ResourceStore.BeginNewResource(resourceType); indexIt = true; } else { if (!createTransient) { return(null); } if (resourceType == null) { resourceType = FileProxy._unknownFileResourceType; } file = Core.ResourceStore.NewResourceTransient(resourceType); } } file.SetProp(FileProxy._propParentFolder, folder); file.SetProp(FileProxy._propDirectory, directoryName); file.SetProp(Core.Props.Name, name); file.SetProp(Core.Props.Date, lastWriteTime); file.SetProp(FileProxy._propSize, size); string filetype = FileSystemTypes.GetFileType(extension); file.SetProp(FileProxy._propFileType, filetype ?? "Unknown"); } file.SetProp(FileProxy._propDeletedFile, false); if (!file.IsTransient) { file.EndUpdate(); if (indexIt) { Core.TextIndexManager.QueryIndexing(file.Id); } } return(file); }
private void ProcessWebLink() { Stream readStream = _reader.ReadStream; if (readStream == null || _webLink.IsDeleted) // if favorite resource was deleted then do nothing { return; } int propContent = FavoritesPlugin._propContent; HttpWebResponse response = _reader.WebResponse; // check whether http stream differs from earlier saved one bool differs = true; /////////////////////////////////////////////////////////////////////////////// /// the following if statement is a workaround over invalid processing by /// HttpReader the Not-Modified-Since header. .NET 1.1 was throwing the /// exception if content not modified, .NET 1.1 SP1 just returns empty stream /////////////////////////////////////////////////////////////////////////////// if (readStream.Length == 0 && !_webLink.HasProp(Core.Props.LastError)) { return; } IResource formatFile = _webLink.GetLinkProp("Source"); if (formatFile != null && formatFile.HasProp(propContent)) { Stream savedStream = formatFile.GetBlobProp(propContent); using ( savedStream ) { if (savedStream.Length == readStream.Length) { differs = false; for (int i = 0; i < readStream.Length; ++i) { if (( byte )savedStream.ReadByte() != ( byte )readStream.ReadByte()) { readStream.Position = 0; differs = true; break; } } } } } if (differs) { DateTime lastModified = GetLastModified(response); bool isShowed = BookmarkService.BookmarkSynchronizationFrequency(_webLink) > 0; // content changed, so set properties and proceed with indexing string resourceType = "UnknownFile"; if (!String.IsNullOrEmpty(response.ContentType)) { resourceType = (Core.FileResourceManager as FileResourceManager).GetResourceTypeByContentType(response.ContentType); if (resourceType == null) { resourceType = "UnknownFile"; } } _webLink.BeginUpdate(); if (formatFile != null) { formatFile.BeginUpdate(); if (resourceType != "UnknownFile" && formatFile.Type != resourceType) { formatFile.ChangeType(resourceType); } } else { formatFile = Core.ResourceStore.BeginNewResource(resourceType); _webLink.AddLink("Source", formatFile); } if (_webLink.HasProp(Core.Props.LastError)) { SetLastError(null); } _webLink.SetProp("LastModified", lastModified); string redirectedUrl = _reader.RedirectUrl; if (redirectedUrl != null && redirectedUrl.Length > 0) { _webLink.SetProp(FavoritesPlugin._propURL, redirectedUrl); } if (_reader.ETag.Length > 0) { _webLink.SetProp(FavoritesPlugin._propETag, _reader.ETag); } // try to get charset from content-type or from content itself string charset = _reader.CharacterSet; if (charset != null) { _webLink.SetProp(Core.FileResourceManager.PropCharset, charset); } formatFile.SetProp(Core.Props.Size, (int)readStream.Length); formatFile.SetProp(propContent, readStream); if (isShowed) { formatFile.SetProp(Core.Props.Date, lastModified); formatFile.SetProp(FavoritesPlugin._propIsUnread, true); Core.FilterEngine.ExecRules(StandardEvents.ResourceReceived, _webLink); } if (formatFile.Type != "UnknownFile") { Core.TextIndexManager.QueryIndexing(formatFile.Id); } _webLink.EndUpdate(); formatFile.EndUpdate(); } }
private void RepairLinkRestriction(IResource lr, IResource resource) { IResourceStore store = MyPalStorage.Storage; string toResourceType = lr.GetStringProp("toResourceType"); string resName = !String.IsNullOrEmpty(resource.DisplayName) ? resource.DisplayName : "<empty>"; int linkType = lr.GetIntProp("LinkType"); int minCount = lr.GetIntProp("MinCount"); int maxCount = lr.GetIntProp("MaxCount"); string linkTypeName = (string)_propTypeMap [linkType]; IResourceList links; int linkTypeReverse; if (store.PropTypes [linkType].HasFlag(PropTypeFlags.DirectedLink)) { links = resource.GetLinksFrom(null, linkType); linkTypeReverse = -linkType; } else { links = resource.GetLinksOfType(null, linkType); linkTypeReverse = linkType; } /** * check destination resource types */ if (toResourceType != null) { foreach (IResource link in links) { if (link.Type != toResourceType) { ReportError("Restricted link found: resource ID=" + resource.Id + " [" + resName + "] link [" + linkTypeName + "] destination resource type=[" + link.Type + "]"); if (_fixErrors) { if (store.GetMinLinkCountRestriction(resource.Type, linkType) > resource.GetLinkCount(linkType) && store.GetMinLinkCountRestriction(link.Type, linkTypeReverse) > link.GetLinkCount(linkTypeReverse)) { resource.DeleteLink(linkType, link); ShowProgress("Link deleted"); ++_fixCount; } else { ShowProgress("Can not delete link due to min/max restrictions: {0}/{1} in store vs {2}/{3} in resource", store.GetMinLinkCountRestriction(resource.Type, linkType).ToString(), store.GetMinLinkCountRestriction(link.Type, linkTypeReverse).ToString(), resource.GetLinkCount(linkType).ToString(), link.GetLinkCount(linkTypeReverse).ToString()); // NB: rough hack. To be deleted after the problem is identified // in the source code. if (resource.Type == "ContactName") { resource.Delete(); } } } } } } /** * check counts */ if (links.Count < minCount) { ReportError(String.Format("Not enough links of type {3} for resource '{2}' {0} minimum, {1} found", minCount, links.Count, resource, linkTypeName)); if (_fixErrors && IsSafeToDeleteResource(resource)) { resource.Delete(); ++_fixCount; } } if (maxCount >= 0 && links.Count > maxCount) { ReportError(String.Format("Too many links of type {3} for resource '{2}': {0} maximum, {1} found", maxCount, links.Count, resource, linkTypeName)); if (_fixErrors) { int linkCount = links.Count; resource.BeginUpdate(); for (int i = links.Count - 1; i >= 0 && linkCount > maxCount; i--) { IResource target = links [i]; // make sure we don't corrupt the DB by deleting the link if (target.GetLinksOfType(null, linkTypeReverse).Count > store.GetMinLinkCountRestriction(target.Type, linkTypeReverse)) { ShowProgress("Deleting link to resource " + links [i]); resource.DeleteLink(linkType, links[i]); linkCount--; } } resource.EndUpdate(); ++_fixCount; } } }
private void ImportGroup(XmlElement root, IResource rootGroup, ImportUtils.FeedUpdateData defaultUpdatePeriod, bool addToWorkspace) { // Import all groups XmlNodeList l = root.SelectNodes("RssFeedsCategory"); if (l != null) { foreach (XmlElement group in l) { string name = group.GetAttribute("name"); if (name == null) { name = "Unknown group"; } IResource iGroup = _plugin.FindOrCreateGroup(name, rootGroup); ImportGroup(group, iGroup, defaultUpdatePeriod, addToWorkspace); } } // Import all elements IResource feedRes = null; l = root.SelectNodes("RssFeed"); if (l != null) { foreach (XmlElement feed in l) { string s = feed.GetAttribute("url"); if (s == null) { continue; } // May be, we are already subscribed? if (Core.ResourceStore.FindUniqueResource("RSSFeed", "URL", s) != null) { continue; } FeedInfo info = new FeedInfo(); info.url = s; // Ok, now we should create feed feedRes = Core.ResourceStore.NewResource("RSSFeed"); feedRes.BeginUpdate(); feedRes.SetProp("URL", s); ImportUtils.Attrib2Prop(feed, "name", feedRes, Core.Props.Name, Props.OriginalName); ImportUtils.Attrib2Prop(feed, "etag", feedRes, Props.ETag); ImportUtils.Attrib2Prop(feed, "authUserName", feedRes, Props.HttpUserName); s = feed.GetAttribute("authPassword"); if (s != null) { string sharpReaderPassword = "******"; MD5CryptoServiceProvider MD5 = new MD5CryptoServiceProvider(); TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider(); DES.Key = MD5.ComputeHash(Encoding.ASCII.GetBytes(sharpReaderPassword)); DES.Mode = CipherMode.ECB; byte[] DESed = Convert.FromBase64String(s); byte[] DeDESed = DES.CreateDecryptor().TransformFinalBlock(DESed, 0, DESed.Length); // Huuray! feedRes.SetProp(Props.HttpPassword, Encoding.Unicode.GetString(DeDESed)); } s = feed.GetAttribute("lastRefresh"); if (s != null) { DateTime dt = DateTime.Parse(s); feedRes.SetProp(Props.LastUpdateTime, dt); } // Peridoically ImportUtils.FeedUpdateData upd; s = feed.GetAttribute("refreshMinutes"); if (s != null) { upd = ImportUtils.ConvertUpdatePeriod(s, 1); } else { upd = defaultUpdatePeriod; } feedRes.SetProp(Props.UpdatePeriod, upd.period); feedRes.SetProp(Props.UpdateFrequency, upd.freq); // Cached? info.cacheFile = GetCacheNameByURL(info.url); // Feed is ready feedRes.AddLink(Core.Props.Parent, rootGroup); feedRes.EndUpdate(); info.feed = feedRes; _importedFeeds.Add(info); if (addToWorkspace) { Core.WorkspaceManager.AddToActiveWorkspace(feedRes); } } } }
/// <summary> /// Import subscription /// </summary> public void DoImport(IResource importRoot, bool addToWorkspace) { IResource feedRes = null; importRoot = _plugin.FindOrCreateGroup("RssBandit subscriptions", importRoot); // We will add info about imported feeds here _importedFeeds = new ArrayList(); ImportUtils.UpdateProgress(0, _progressMessage); // Start to import feeds structure XmlDocument feedlist = new XmlDocument(); try { feedlist.Load(_subscriptionPath); } catch (Exception ex) { Trace.WriteLine("RssBandit subscrption load failed: '" + ex.Message + "'"); RemoveFeedsAndGroupsAction.DeleteFeedGroup(importRoot); ImportUtils.ReportError("RSS Bandit Subscription Import", "Import of RSS Bandit subscription failed:\n" + ex.Message); return; } ImportUtils.FeedUpdateData defaultUpdatePeriod; XmlAttribute period = feedlist.SelectSingleNode("/feeds/@refresh-rate") as XmlAttribute; if (period != null) { defaultUpdatePeriod = ImportUtils.ConvertUpdatePeriod(period.Value, 60000); } else { defaultUpdatePeriod = ImportUtils.ConvertUpdatePeriod("", 60000); } XmlNodeList feeds = feedlist.GetElementsByTagName("feed"); int totalFeeds = Math.Max(feeds.Count, 1); int processedFeeds = 0; ImportUtils.UpdateProgress(processedFeeds / totalFeeds, _progressMessage); foreach (XmlElement feed in feeds) { string s = ImportUtils.GetUniqueChildText(feed, "link"); if (s == null) { continue; } // May be, we are already subscribed? if (Core.ResourceStore.FindUniqueResource("RSSFeed", "URL", s) != null) { continue; } FeedInfo info = new FeedInfo(); info.url = s; IResource group = AddCategory(importRoot, feed.GetAttribute("category")); // Ok, now we should create feed feedRes = Core.ResourceStore.NewResource("RSSFeed"); feedRes.BeginUpdate(); feedRes.SetProp("URL", s); s = ImportUtils.GetUniqueChildText(feed, "title"); ImportUtils.Child2Prop(feed, "title", feedRes, Core.Props.Name, Props.OriginalName); ImportUtils.Child2Prop(feed, "etag", feedRes, Props.ETag); s = ImportUtils.GetUniqueChildText(feed, "last-retrieved"); if (s != null) { DateTime dt = DateTime.Parse(s); feedRes.SetProp("LastUpdateTime", dt); } // Peridoically ImportUtils.FeedUpdateData upd; s = ImportUtils.GetUniqueChildText(feed, "refresh-rate"); if (s != null) { upd = ImportUtils.ConvertUpdatePeriod(s, 60000); } else { upd = defaultUpdatePeriod; } feedRes.SetProp("UpdatePeriod", upd.period); feedRes.SetProp("UpdateFrequency", upd.freq); // Cached? s = ImportUtils.GetUniqueChildText(feed, "cacheurl"); if (s != null) { info.cacheFile = s; } else { info.cacheFile = null; } // Login & Password ImportUtils.Child2Prop(feed, "auth-user", feedRes, Props.HttpUserName); s = ImportUtils.GetUniqueChildText(feed, "auth-password"); if (s != null) { feedRes.SetProp(Props.HttpPassword, DecryptPassword(s)); } // Enclosures ImportUtils.Child2Prop(feed, "enclosure-folder", feedRes, Props.EnclosurePath); // Try to load "read" list XmlElement read = ImportUtils.GetUniqueChild(feed, "stories-recently-viewed"); if (read != null) { ArrayList list = new ArrayList(); foreach (XmlElement story in read.GetElementsByTagName("story")) { list.Add(story.InnerText); } if (list.Count > 0) { info.readItems = list; } else { info.readItems = null; } } // Feed is ready feedRes.AddLink(Core.Props.Parent, group); feedRes.EndUpdate(); info.feed = feedRes; _importedFeeds.Add(info); if (addToWorkspace) { Core.WorkspaceManager.AddToActiveWorkspace(feedRes); } processedFeeds += 100; ImportUtils.UpdateProgress(processedFeeds / totalFeeds, _progressMessage); } return; }