public void Delete(string name)
{
ResourceTypeItem item = (ResourceTypeItem)this [name];
IResourceList resList = _storage.GetAllResources(name);
resList.DeleteAll();
_resourceTypeCache [item.Id] = null;
_resourceTypeNameCache.Remove(name);
ICountedResultSet rs = _resourceTypeTable.CreateModifiableResultSet(0, item.Id);
try
{
_storage.SafeDeleteRecord(rs [0], "ResourceTypes.Delete");
}
finally
{
rs.Dispose();
}
IResource resourceTypeRes = _storage.FindUniqueResource("ResourceType", "Name", name);
Debug.Assert(resourceTypeRes != null);
resourceTypeRes.Delete();
}
private static void DeleteICQConversations()
{
try
{
ObjectStore.DeleteSection("ICQDbImportTableRecordNumbers");
IResourceStore store = Core.ResourceStore;
IResourceList contacts = store.FindResourcesWithProp("Contact", _propICQAcct);
IResourceList conversations =
store.GetAllResources(_icqConversationResName);
if (conversations.Count > 0)
{
conversations.DeleteAll();
}
IResourceList icqAccounts =
store.GetAllResources(_icqAccountResName);
if (icqAccounts.Count > 0)
{
icqAccounts.DeleteAll();
}
Trace.WriteLine("All ICQConversation resources successfully deleted", "ICQ.Plugin");
Core.ContactManager.DeleteUnusedContacts(contacts);
Trace.WriteLine("All unused contacts successfully deleted", "ICQ.Plugin");
}
catch (StorageException)
{
Trace.WriteLine("No ICQconversation resources found", "ICQ.Plugin");
}
}
private static int ConfirmImportRecursive(IResource res)
{
int count = 0;
foreach (IResource child in res.GetLinksTo(null, Core.Props.Parent))
{
if (child.Type == "RSSFeedGroup")
{
int childCount = ConfirmImportRecursive(child);
if (childCount == 0)
{
child.Delete();
}
count += childCount;
}
else if (child.GetIntProp(Props.Transient) == 1)
{
IResourceList items = child.GetLinksOfType("RSSItem", Props.RSSItem);
items.DeleteAll();
child.Delete();
}
else
{
if (RSSPlugin.GetInstance() != null)
{
RSSPlugin.GetInstance().QueueFeedUpdate(child);
}
count++;
}
}
return(count);
}
public static void InitViewsConstructors()
{
IResourceList regIniters = Core.ResourceStore.GetAllResources(FilterManagerProps.RegisteredInitializer);
regIniters.DeleteAll();
InvokeViewsConstructors();
}
private static void RegisterCustomConditions()
{
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry;
#region Core.FilterRegistry.Std.ResourceIsCategorized Cleaning
// Fix previous version of this condition (it was implemented as
// predicate-type).
IResourceList old = Core.ResourceStore.FindResources(FilterManagerProps.ConditionResName, "Name", Core.FilterRegistry.Std.ResourceIsCategorizedName);
old = old.Intersect(Core.ResourceStore.FindResources(FilterManagerProps.ConditionResName, "ConditionType", "predicate"), true);
old.DeleteAll();
#endregion Core.FilterRegistry.Std.ResourceIsCategorized Cleaning
fMgr.RegisterCustomCondition(fMgr.Std.ResourceIsCategorizedName, fMgr.Std.ResourceIsCategorizedNameDeep,
null, new ResourceIsCategorized());
res = fMgr.RegisterCustomCondition(fMgr.Std.ResourceHasEmptyContentName, fMgr.Std.ResourceHasEmptyContentNameDeep,
null, new ResourceHasEmptyContent());
fMgr.MarkConditionOnlyForRule(res);
res = fMgr.CreateStandardCondition(FilterManagerStandards.DummyConditionName, FilterManagerStandards.DummyConditionName,
null, "Id", ConditionOp.Gt, "0");
res.SetProp("Invisible", true);
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.InTheCategoryAndSubcategoriesXName, fMgr.Std.InTheCategoryAndSubcategoriesXNameDeep,
null, new MatchCategoryAndSubcategories(), ConditionOp.In, "Category", "Category");
fMgr.AssociateConditionWithGroup(res, "Category Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.FromToCCContactXName, fMgr.Std.FromToCCContactXNameDeep,
null, new CorrespondenceOfContact(), ConditionOp.In, "Contact", "Category");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.FromToContactXName, fMgr.Std.FromToContactXNameDeep,
null, new FromToOfContact(), ConditionOp.In, "Contact", "Category");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.ResourceContainsTextXName, fMgr.Std.ResourceContainsTextXNameDeep,
null, new ResourceContainsText(), ConditionOp.Eq, "Subject");
fMgr.AssociateConditionWithGroup(res, "Text Query Conditions");
fMgr.MarkConditionOnlyForRule(res);
res = fMgr.CreateCustomConditionTemplate(fMgr.Std.MessageIsInThreadOfXName, fMgr.Std.MessageIsInThreadOfXNameDeep,
null, new MessageIsInThreadOf(), ConditionOp.In, "Email", "Category");
res.SetProp("Invisible", true);
// Interversion consistency. In old build this condition was
// registered in other plugin(s). Since they now refer to Std,
// we have to register it again.
res = fMgr.CreateConditionTemplate(fMgr.Std.FromContactXName, fMgr.Std.FromContactXNameDeep, null, ConditionOp.In, "Contact", "From");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
// Upgrade for old versions.
res = fMgr.CreateConditionTemplate(fMgr.Std.DeletedInTheTimeSpanXName, fMgr.Std.DeletedInTheTimeSpanXNameDeep, null, ConditionOp.Eq, "DelDate");
fMgr.AssociateConditionWithGroup(res, "Temporal Conditions");
}
private static void CloneRulesToCompositeResType()
{
IResourceList list = Core.ResourceStore.FindResources(FilterManagerProps.ViewResName, "IsTrayIconFilter", true);
foreach (IResource res in list)
{
string name = res.GetStringProp(Core.Props.Name);
if (Core.TrayIconManager.FindRule(name) == null)
{
try
{
Core.TrayIconManager.CloneRule(res, name);
}
catch (Exception)
{
// We may fail to convert old or broken rules for which
// proper transition has not been made. Just ignore them.
}
}
}
list.DeleteAll();
list = Core.ResourceStore.FindResources(FilterManagerProps.ViewResName, "IsFormattingFilter", true);
foreach (IResource res in list)
{
string name = res.GetStringProp(Core.Props.Name);
if (Core.FormattingRuleManager.FindRule(name) == null)
{
try
{
Core.FormattingRuleManager.CloneRule(res, name);
}
catch (Exception)
{
// We may fail to convert old or broken rules for which
// proper transition has not been made. Just ignore them.
}
}
}
list.DeleteAll();
}
private static void RemoveInvalidAttachmentResources()
{
if (OutlookProcessor.SyncVersion < 11)
{
IResourceList attachments = RS.FindResourcesWithProp(null, PROP.AttachmentIndex);
IResourceList resList1 = RS.FindResourcesWithProp(null, PROP.Attachment);
IResourceList resList2 = RS.FindResourcesWithProp(null, PROP.InternalAttachment);
attachments = attachments.Minus(resList1);
attachments = attachments.Minus(resList2);
attachments.DeleteAll();
}
}
/**
* process pending deletions of file resources
*/
internal static void ProcessPendingFileDeletions()
{
if (!Core.ResourceStore.IsOwnerThread())
{
Core.ResourceAP.RunUniqueJob(new MethodInvoker(ProcessPendingFileDeletions));
}
else
{
IResourceList deletedFiles =
Core.ResourceStore.FindResourcesWithProp(null, FileProxy._propDeletedFile);
deletedFiles.DeleteAll();
}
}
void IViewsConstructor.RegisterViewsEachRun()
{
IResource res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", TasksViewsConstructor.TaskReminderDatedName);
if (res != null)
{
res.SetProp("DeepName", TasksViewsConstructor.TaskReminderDatedDeep);
}
// Some conditions were created inproperly
IResourceList list = Core.ResourceStore.FindResources(FilterManagerProps.ConditionTemplateResName, "DeepName", TasksViewsConstructor.TaskOfPriorityName);
list.DeleteAll();
}
private static void DeleteResourcesOfType(string type, string message)
{
int percent = 0;
IResourceList list = Core.ResourceStore.GetAllResources(type);
for (int i = 0; i < list.Count; i++)
{
IResourceList attachs = list[i].GetLinksOfType(null, "Attachment");
attachs.DeleteAll();
list[i].Delete();
if ((i * 100 / list.Count) != percent)
{
percent = i * 100 / list.Count;
Core.ProgressWindow.UpdateProgress(percent, message, String.Empty);
}
}
}
private static void RecreateOptionsImpl()
{
IResourceList list = Core.ResourceStore.GetAllResources("DebugOption");
list.DeleteAll();
IResource option = Core.ResourceStore.NewResource("DebugOption");
option.SetProp(BoolDebugSetting, true);
option.SetProp(IntDebugSetting, 10);
option.SetProp(StringDebugSetting, "1");
option.SetProp(IntComboDebugSetting, -1);
option.SetProp(IntRadioDebugSetting, 7);
option = Core.ResourceStore.NewResource("DebugOption");
option.SetProp(BoolDebugSetting, false);
option.SetProp(IntDebugSetting, 20);
option.SetProp(StringDebugSetting, "2");
option.SetProp(IntComboDebugSetting, 1);
option.SetProp(IntRadioDebugSetting, 8);
}
public void RegisterViewsFirstRun()
{
IResourceList list = Core.ResourceStore.FindResources(FilterManagerProps.ConditionTemplateResName, "Name", RSSViewsConstructor.PostInCategoryName);
IResource one = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "DeepName", RSSViewsConstructor.PostInCategoryName);
if (one != null)
{
list = list.Minus(one.ToResourceList());
list.DeleteAll();
one.SetProp("DeepName", RSSViewsConstructor.PostInCategoryDeep);
}
else
{
IFilterRegistry mgr = Core.FilterRegistry;
IResource res = mgr.CreateConditionTemplate(RSSViewsConstructor.PostInCategoryName, RSSViewsConstructor.PostInCategoryDeep,
new string[] { "RSSItem" }, ConditionOp.Eq, "RSSCategory");
mgr.AssociateConditionWithGroup(res, RSSViewsConstructor.RSSConditionsGroup);
}
}
internal static void DoConfirmImport(IResource previewRoot, IResource importRoot)
{
foreach (IResource res in previewRoot.GetLinksTo(null, Core.Props.Parent))
{
if (res.Type == "RSSFeedGroup")
{
int count = ConfirmImportRecursive(res);
if (count == 0)
{
res.Delete();
continue;
}
if (RelinkExistingGroup(res, importRoot))
{
continue;
}
Core.WorkspaceManager.AddToActiveWorkspaceRecursive(res);
}
if (res.Type == "RSSFeed" && res.GetIntProp(Props.Transient) == 1)
{
// Delete all items
IResourceList items = res.GetLinksOfType("RSSItem", Props.RSSItem);
items.DeleteAll();
res.Delete();
}
else
{
res.DeleteProp(Props.Transient);
res.SetProp(Core.Props.Parent, importRoot);
if (res.Type == "RSSFeed")
{
Core.WorkspaceManager.AddToActiveWorkspace(res);
if (RSSPlugin.GetInstance() != null)
{
RSSPlugin.GetInstance().QueueFeedUpdate(res);
}
}
}
}
previewRoot.Delete();
}
public static void ForceDelete(IResource mail)
{
if (mail.Id == -1)
{
return;
}
Trace.WriteLine("Deleting email resource ID=" + mail.Id);
IResourceList resAttachments = mail.GetLinksOfType(null, PROP.Attachment);
resAttachments.DeleteAll();
IResourceList resInternalAttachments = mail.GetLinksOfType(null, PROP.InternalAttachment);
resInternalAttachments.DeleteAll();
IResourceList contactsFrom = mail.GetLinksOfType("Contact", "From");
IResourceList contactsTo = mail.GetLinksOfType("Contact", "To");
mail.Delete();
Core.ContactManager.DeleteUnusedContacts(contactsFrom);
Core.ContactManager.DeleteUnusedContacts(contactsTo);
}
// Config: two contacts, 2 mails, 0 contact names (both contacts have a single
// accounts, no sender names), 3 accounts.
// Configuration: (main,account1,null) <-From-< email1 >-To-> (extra,account3,null)
// (main,account2,null) <-To-< email2 >-From-> (extra,account3,null)
// Action: unlink the contact and account1;
// Expected: new contact created, new contact name (it has the name of
// account), email1's link From points to the new Contact and
// the ContactName:
// (new,account1,"From: account1") <-From-< email1 >-To-> (extra,account3,null)
// (main,account2,null) <-To-< email2 >-From-> (extra,account3,null)
[Test] public void UnlinkContactAndAccountTestWithoutContactNames()
{
IResourceList contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(0, contacts.Count);
IContact main = _contactManager.FindOrCreateContact("account1", "Michael Gerasimov");
contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(1, contacts.Count);
IContact extra = _contactManager.FindOrCreateContact("account2", "FirstName LastName");
contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(2, contacts.Count);
IResource account1 = main.Resource.GetLinkProp("EmailAcct");
IResource account2 = extra.Resource.GetLinkProp("EmailAcct");
IResource account3 = Core.ContactManager.FindOrCreateEmailAccount("account3");
IResource email1 = _storage.NewResource("email");
email1.SetProp("Subject", "Subject1");
Core.ContactManager.LinkContactToResource(_contactManager.Props.LinkFrom, main.Resource, email1, account1, "aFrom");
Core.ContactManager.LinkContactToResource(_contactManager.Props.LinkTo, extra.Resource, email1, account3, "aTo");
contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(2, contacts.Count);
IResource email2 = _storage.NewResource("email");
email2.SetProp("Subject", "Subject2");
Core.ContactManager.LinkContactToResource(_contactManager.Props.LinkTo, main.Resource, email2, account2, "bTo");
Core.ContactManager.LinkContactToResource(_contactManager.Props.LinkFrom, extra.Resource, email2, account3, "bFrom");
contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(2, contacts.Count);
IResourceList names = account3.GetLinksOfType("ContactName", Core.ContactManager.Props.LinkEmailAcct);
Assert.AreEqual(names.Count, 2);
// emulate the case when there is no ContactName linked to the e-account
names = account1.GetLinksOfType("ContactName", Core.ContactManager.Props.LinkEmailAcct);
Assert.AreEqual(names.Count, 1);
names.DeleteAll();
//-----------------------------------------------------------------
_contactManager.HardRemoveAccountFromContact(main.Resource, account1);
//-----------------------------------------------------------------
contacts = _storage.GetAllResources("Contact");
Assert.AreEqual(3, contacts.Count);
// DO NOT! expect newly created contact name.
IResourceList contactNames = _storage.GetAllResources("ContactName");
Assert.AreEqual(3, contactNames.Count);
IResourceList newContacts = account1.GetLinksOfType("Contact", _contactManager.Props.LinkEmailAcct);
Assert.AreEqual(1, newContacts.Count);
IResource newContact = newContacts[0];
Assert.AreEqual("From: account1", newContact.GetStringProp("LastName"));
Assert.AreEqual(1, newContact.GetLinksOfType("email", _contactManager.Props.LinkFrom).Count);
Assert.AreEqual(0, newContact.GetLinksOfType("email", _contactManager.Props.LinkTo).Count);
Assert.AreEqual(0, main.Resource.GetLinksOfType("email", _contactManager.Props.LinkFrom).Count);
Assert.AreEqual(1, main.Resource.GetLinksOfType("email", _contactManager.Props.LinkTo).Count);
}
private void UpgradeConditions()
{
IResource res;
IFilterRegistry fMgr = Core.FilterRegistry; // alias
IResourceStore Store = Core.ResourceStore; // alias
#region Condition Renaming
#region From Correspondent
IResource newRes = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", Core.FilterRegistry.Std.FromContactXName);
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", "From %Correspondent(s)%");
if (res != null)
{
if (newRes != null)
{
newRes.Delete();
}
res.SetProp("Name", Core.FilterRegistry.Std.FromContactXName);
res.SetProp("DeepName", Core.FilterRegistry.Std.FromContactXNameDeep);
res.SetProp("_DisplayName", Core.FilterRegistry.Std.FromContactXName.Replace("%", ""));
}
#endregion From Correspondent
#region To Correspondent
newRes = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", Core.FilterRegistry.Std.ToContactXName);
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", "Sent to %Correspondent(s)%");
if (res != null)
{
Trace.WriteLine("ViewsInitializer -- [Sent to Correspondent] has been found.");
if (newRes != null)
{
Trace.WriteLine("ViewsInitializer -- Occasional [To Contact] has been found.");
newRes.Delete();
}
res.SetProp("Name", Core.FilterRegistry.Std.ToContactXName);
res.SetProp("DeepName", Core.FilterRegistry.Std.ToContactXNameDeep);
res.SetProp("_DisplayName", Core.FilterRegistry.Std.ToContactXName.Replace("%", ""));
}
else
if (newRes == null)
{
res = fMgr.CreateConditionTemplate(fMgr.Std.ToContactXName, fMgr.Std.ToContactXNameDeep, null, ConditionOp.In, "Contact", "To");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
}
#endregion To Correspondent
#region CC Correspondent
newRes = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", Core.FilterRegistry.Std.CCContactXName);
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionTemplateResName, "Name", "Copied (CC) to %Correspondent(s)%");
if (res != null)
{
if (newRes != null)
{
newRes.Delete();
}
res.SetProp("Name", Core.FilterRegistry.Std.CCContactXName);
res.SetProp("DeepName", Core.FilterRegistry.Std.CCContactXNameDeep);
res.SetProp("_DisplayName", Core.FilterRegistry.Std.CCContactXName.Replace("%", ""));
}
if (newRes == null)
{
res = fMgr.CreateConditionTemplate(fMgr.Std.CCContactXName, fMgr.Std.CCContactXNameDeep, null, ConditionOp.In, "Contact", "CC");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
}
#endregion CC Correspondent
#region From %Contact%
fMgr.Std.FromContactX.SetProp("_DisplayName", fMgr.Std.FromContactXName.Replace("%", ""));
#endregion From %Contact%
#region Mark Message as Y
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", "Mark message as read");
if (res != null)
{
IResource occ = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", fMgr.Std.MarkResourceAsReadActionName);
if (occ != null)
{
occ.Delete();
}
res.SetProp("Name", fMgr.Std.MarkResourceAsReadActionName);
res.SetProp("DeepName", fMgr.Std.MarkResourceAsReadActionNameDeep);
}
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", "Mark message as unread");
if (res != null)
{
IResource occ = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", fMgr.Std.MarkResourceAsUnreadActionName);
if (occ != null)
{
occ.Delete();
}
res.SetProp("Name", fMgr.Std.MarkResourceAsUnreadActionName);
res.SetProp("DeepName", fMgr.Std.MarkResourceAsUnreadActionNameDeep);
}
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", "Mark message as important");
if (res != null)
{
IResource occ = Core.ResourceStore.FindUniqueResource(FilterManagerProps.RuleActionResName, "Name", fMgr.Std.MarkResourceAsImportantActionName);
if (occ != null)
{
occ.Delete();
}
res.SetProp("Name", fMgr.Std.MarkResourceAsImportantActionName);
res.SetProp("DeepName", fMgr.Std.MarkResourceAsImportantActionNameDeep);
}
#endregion Mark Message as Y
#endregion Condition Renaming
#region Views/Conditions which occasionally have been rotten in previous versions
res = fMgr.CreateConditionTemplate(fMgr.Std.FromContactXName, fMgr.Std.FromContactXNameDeep, null, ConditionOp.In, "Contact", "From");
fMgr.AssociateConditionWithGroup(res, "Address and Contact Conditions");
res = fMgr.CreateConditionTemplate(fMgr.Std.SubjectContainsTextXName, fMgr.Std.SubjectContainsTextXNameDeep, null, ConditionOp.Has, "Subject");
fMgr.AssociateConditionWithGroup(res, "Text Query Conditions");
#endregion
#region Remove obsolete conditions and templates
IResourceList list = Store.FindResources(FilterManagerProps.ConditionTemplateResName, "Name", "Contact has posted a message of type %Type%");
list.DeleteAll();
list = Store.FindResources(FilterManagerProps.ConditionResName, "Name", "Reply in my thread");
list.DeleteAll();
#endregion Remove obsolete conditions and templates
#region Relink conditions to new group
fMgr.AssociateConditionWithGroup(fMgr.Std.ToContactX, "Address and Contact Conditions");
fMgr.AssociateConditionWithGroup(fMgr.Std.CCContactX, "Address and Contact Conditions");
res = Core.ResourceStore.FindUniqueResource(FilterManagerProps.ConditionGroupResName, "Name", "Address Conditions");
if (res != null)
{
res.Delete();
}
#endregion Relink conditions to new group
}