626 lines
23 KiB
C#
626 lines
23 KiB
C#
/// Copyright 2016 Kopano b.v.
|
|
///
|
|
/// This program is free software: you can redistribute it and/or modify
|
|
/// it under the terms of the GNU Affero General Public License, version 3,
|
|
/// as published by the Free Software Foundation.
|
|
///
|
|
/// This program is distributed in the hope that it will be useful,
|
|
/// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
/// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
|
|
/// GNU Affero General Public License for more details.
|
|
///
|
|
/// You should have received a copy of the GNU Affero General Public License
|
|
/// along with this program.If not, see<http://www.gnu.org/licenses/>.
|
|
///
|
|
/// Consult LICENSE file for details
|
|
|
|
using Microsoft.Office.Interop.Outlook;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using Acacia.Stubs;
|
|
using Acacia.Stubs.OutlookWrappers;
|
|
using System.Threading;
|
|
using System.Collections.Concurrent;
|
|
using Acacia.ZPush;
|
|
using Acacia.Utils;
|
|
using System.ComponentModel;
|
|
using System.Windows.Forms;
|
|
using Acacia.UI;
|
|
using static Acacia.DebugOptions;
|
|
|
|
namespace Acacia.Features.GAB
|
|
{
|
|
[AcaciaOption("Provides a Global Address Book for Z-Push accounts.")]
|
|
public class FeatureGAB : Feature
|
|
{
|
|
private readonly Dictionary<string, GABHandler> _gabsByDomainName = new Dictionary<string, GABHandler>();
|
|
private readonly HashSet<string> _gabFolders = new HashSet<string>();
|
|
private readonly HashSet<string> _domains = new HashSet<string>();
|
|
private ZPushLocalStore _store;
|
|
private int _processing;
|
|
|
|
public FeatureGAB()
|
|
{
|
|
}
|
|
|
|
public static GABHandler FindGABForAccount(ZPushAccount account)
|
|
{
|
|
FeatureGAB gab = ThisAddIn.Instance.GetFeature<FeatureGAB>();
|
|
if (gab != null)
|
|
{
|
|
foreach (GABHandler handler in gab.GABHandlers)
|
|
{
|
|
if (account == handler.ActiveAccount)
|
|
{
|
|
return handler;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public override void Startup()
|
|
{
|
|
MailEvents.BeforeDelete += SuppressEventHandler_Delete;
|
|
MailEvents.Write += SuppressEventHandler_Modify;
|
|
Watcher.AccountDiscovered += AccountDiscovered;
|
|
Watcher.AccountRemoved += AccountRemoved;
|
|
Watcher.AccountsScanned += AccountsScanned;
|
|
}
|
|
|
|
#region Settings
|
|
|
|
public override FeatureSettings GetSettings()
|
|
{
|
|
return new GABSettings(this);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Debug options
|
|
|
|
[AcaciaOption("Disables the processing of the folder containing the GAB synchronization queue. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool ProcessFolder
|
|
{
|
|
get { return GetOption(OPTION_PROCESS_FOLDER); }
|
|
set { SetOption(OPTION_PROCESS_FOLDER, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_PROCESS_FOLDER = new BoolOption("ProcessFolder", true);
|
|
|
|
[AcaciaOption("Disables the processing of items in the GAB synchronization queue. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool ProcessItems
|
|
{
|
|
get { return GetOption(OPTION_PROCESS_ITEMS); }
|
|
set { SetOption(OPTION_PROCESS_ITEMS, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_PROCESS_ITEMS = new BoolOption("ProcessItems", true);
|
|
|
|
[AcaciaOption("Disables the second stage of processing of items in the GAB synchronization queue. " +
|
|
"This should only be disabled for debug purposes")]
|
|
public bool ProcessItems2
|
|
{
|
|
get { return GetOption(OPTION_PROCESS_ITEMS_2); }
|
|
set { SetOption(OPTION_PROCESS_ITEMS_2, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_PROCESS_ITEMS_2 = new BoolOption("ProcessItems2", true);
|
|
|
|
[AcaciaOption("Disables the processing of messages containing GAB contacts. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool ProcessMessage
|
|
{
|
|
get { return GetOption(OPTION_PROCESS_MESSAGE); }
|
|
set { SetOption(OPTION_PROCESS_MESSAGE, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_PROCESS_MESSAGE = new BoolOption("ProcessMessage", true);
|
|
|
|
[AcaciaOption("If disabled, contacts are not created from incoming GAB messages. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool CreateContacts
|
|
{
|
|
get { return GetOption(OPTION_CREATE_CONTACTS); }
|
|
set { SetOption(OPTION_CREATE_CONTACTS, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_CREATE_CONTACTS = new BoolOption("CreateContacts", true);
|
|
|
|
[AcaciaOption("If disabled, groups are not created from incoming GAB messages. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool CreateGroups
|
|
{
|
|
get { return GetOption(OPTION_CREATE_GROUPS); }
|
|
set { SetOption(OPTION_CREATE_GROUPS, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_CREATE_GROUPS = new BoolOption("CreateGroups", true);
|
|
|
|
[AcaciaOption("If disabled, group members are not parsed from incoming GAB messages. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool GroupMembers
|
|
{
|
|
get { return GetOption(OPTION_GROUP_MEMBERS); }
|
|
set { SetOption(OPTION_GROUP_MEMBERS, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_GROUP_MEMBERS = new BoolOption("GroupMembers", true);
|
|
|
|
[AcaciaOption("If disabled, group members are not added to groups created from GAB messages. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool GroupMembersAdd
|
|
{
|
|
get { return GetOption(OPTION_GROUP_MEMBERS_ADD); }
|
|
set { SetOption(OPTION_GROUP_MEMBERS_ADD, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_GROUP_MEMBERS_ADD = new BoolOption("GroupMembersAdd", true);
|
|
|
|
[AcaciaOption("If disabled, groups that are members of other groups are not added to the parent group. " +
|
|
"This should only be disabled for debug purposes.")]
|
|
public bool NestedGroups
|
|
{
|
|
get { return GetOption(OPTION_NESTED_GROUPS); }
|
|
set { SetOption(OPTION_NESTED_GROUPS, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_NESTED_GROUPS = new BoolOption("NestedGroups", true);
|
|
|
|
[AcaciaOption("If this option is enabled, the GAB checks for unused local folders and removes them. " +
|
|
"If disabled, the unused local folders are left alone. The only reason GAB folders " +
|
|
"can become unused is if an account is removed, or if the GAB is removed from the server.")]
|
|
public bool CheckUnused
|
|
{
|
|
get { return GetOption(OPTION_CHECK_UNUSED); }
|
|
set { SetOption(OPTION_CHECK_UNUSED, value); }
|
|
}
|
|
private static readonly BoolOption OPTION_CHECK_UNUSED = new BoolOption("CheckUnused", true);
|
|
|
|
#endregion
|
|
|
|
#region Modification suppression
|
|
|
|
internal void BeginProcessing()
|
|
{
|
|
++_processing;
|
|
}
|
|
|
|
internal void EndProcessing()
|
|
{
|
|
--_processing;
|
|
}
|
|
|
|
private void SuppressEventHandler_Delete(IItem item, ref bool cancel)
|
|
{
|
|
SuppressEventHandler(item, false, ref cancel);
|
|
}
|
|
|
|
private void SuppressEventHandler_Modify(IItem item, ref bool cancel)
|
|
{
|
|
SuppressEventHandler(item, true, ref cancel);
|
|
}
|
|
|
|
private void SuppressEventHandler(IItem item, bool findInspector, ref bool cancel)
|
|
{
|
|
// Allow events from processing
|
|
if (_processing == 0)
|
|
{
|
|
// Check parent folder is a GAB contacts folder
|
|
if (_gabFolders.Contains(item.ParentEntryId) && IsGABItem(item))
|
|
{
|
|
DoSuppressEvent(findInspector ? item : null, ref cancel);
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsGABItem(IItem item)
|
|
{
|
|
// For some reason, Outlook creates a meeting request in the GAB folder. Modifying that should be allowed
|
|
return item is IContactItem || item is IDistributionList;
|
|
}
|
|
|
|
private void SuppressMoveEventHandler(IFolder src, IItem item, IFolder target, ref bool cancel)
|
|
{
|
|
// Allow events from processing
|
|
if (_processing == 0)
|
|
{
|
|
// Always disallow moves from out of the folder
|
|
DoSuppressEvent(null, ref cancel);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <param name="item">If specified, the function will attempt to find an inspector for the item and close it.</param>
|
|
/// <param name="cancel"></param>
|
|
private void DoSuppressEvent(IItem item, ref bool cancel)
|
|
{
|
|
if (item != null)
|
|
{
|
|
foreach (Inspector inspector in App.Inspectors)
|
|
{
|
|
if (item.EntryId == inspector.CurrentItem.EntryID)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
MessageBox.Show(StringUtil.GetResourceString("GABEvent_Body"),
|
|
StringUtil.GetResourceString("GABEvent_Title"),
|
|
MessageBoxButtons.OK,
|
|
MessageBoxIcon.Warning
|
|
);
|
|
cancel = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Resync
|
|
|
|
internal void FullResync()
|
|
{
|
|
try
|
|
{
|
|
Logger.Instance.Trace(this, "FullResync begin: {0}", _processing);
|
|
BeginProcessing();
|
|
|
|
// Delete any contacts folders in the local store
|
|
using (ZPushLocalStore store = ZPushLocalStore.GetInstance(App))
|
|
{
|
|
if (store != null)
|
|
{
|
|
using (IFolder root = store.RootFolder)
|
|
{
|
|
foreach (IFolder folder in root.GetSubFolders<IFolder>())
|
|
{
|
|
// TODO: let enumerator handle this
|
|
using (folder)
|
|
{
|
|
try
|
|
{
|
|
if (IsGABContactsFolder(folder))
|
|
{
|
|
Logger.Instance.Debug(this, "FullResync: Deleting contacts folder: {0}", folder.Name);
|
|
folder.Delete();
|
|
}
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Logger.Instance.Error(this, "FullResync: Exception deleting contacts folder: {0}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do the resync
|
|
foreach (GABHandler gab in _gabsByDomainName.Values)
|
|
{
|
|
Logger.Instance.Debug(this, "FullResync: Starting resync: {0}", gab.DisplayName);
|
|
Tasks.Task(this, "FullResync", () => gab.FullResync());
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
EndProcessing();
|
|
Logger.Instance.Trace(this, "FullResync done: {0}", _processing);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Contacts folders
|
|
|
|
[Browsable(false)]
|
|
public IEnumerable<GABHandler> GABHandlers
|
|
{
|
|
get
|
|
{
|
|
return _gabsByDomainName.Values;
|
|
}
|
|
}
|
|
|
|
private IAddressBook FindGABForDomain(IFolder root, string domain)
|
|
{
|
|
// Scan all subfolders for the GAB
|
|
foreach (IAddressBook subfolder in root.GetSubFolders<IAddressBook>())
|
|
{
|
|
try
|
|
{
|
|
if (subfolder.DefaultMessageClass == OutlookConstants.MESSAGE_CLASS_CONTACTS)
|
|
{
|
|
GABInfo gabInfo = GABInfo.Get(subfolder);
|
|
if (gabInfo != null && gabInfo.IsForDomain(domain))
|
|
{
|
|
Logger.Instance.Debug(this, "Found existing GAB: {0}", gabInfo);
|
|
return subfolder;
|
|
}
|
|
}
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Logger.Instance.Warning(this, "Exception scanning GABs: {0}", e);
|
|
}
|
|
Logger.Instance.Debug(this, "Skipping GAB folder: {0}", subfolder.Name);
|
|
subfolder.Dispose();
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private IAddressBook CreateGABContacts(string domainName)
|
|
{
|
|
if (_store != null)
|
|
{
|
|
_store.Dispose();
|
|
_store = null;
|
|
}
|
|
_store = ZPushLocalStore.GetInstance(App);
|
|
if (_store == null)
|
|
return null;
|
|
|
|
// Try to find the existing GAB
|
|
using (IFolder root = _store.RootFolder)
|
|
{
|
|
IAddressBook gab = FindGABForDomain(root, domainName);
|
|
if (gab == null)
|
|
{
|
|
Logger.Instance.Debug(this, "Creating new GAB folder for {0}", domainName);
|
|
string name = string.Format(Properties.Resources.GAB_FolderFormat, domainName);
|
|
gab = root.CreateFolder<IAddressBook>(name);
|
|
}
|
|
else
|
|
{
|
|
Logger.Instance.Debug(this, "Found existing GAB folder for {0}", domainName);
|
|
}
|
|
|
|
// The local folders are hidden, unhide tha GAB folder
|
|
gab.AttrHidden = false;
|
|
|
|
// Update admin
|
|
_gabFolders.Add(gab.EntryId);
|
|
GABInfo gabInfo = GABInfo.Get(gab, domainName);
|
|
gabInfo.Store(gab);
|
|
|
|
// Hook BeforeMove event to prevent modifications
|
|
// TODO: use ZPushWatcher for this?
|
|
gab.BeforeItemMove += SuppressMoveEventHandler;
|
|
|
|
return gab;
|
|
}
|
|
}
|
|
|
|
private void DisposeGABContacts(IAddressBook gab)
|
|
{
|
|
// Unhook the event to prevent the gab lingering in memory
|
|
gab.BeforeItemMove -= SuppressMoveEventHandler;
|
|
}
|
|
|
|
public static GABInfo GetGABContactsFolderInfo(IFolder folder)
|
|
{
|
|
if (folder.DefaultMessageClass != OutlookConstants.MESSAGE_CLASS_CONTACTS)
|
|
return null;
|
|
|
|
return GABInfo.Get(folder);
|
|
}
|
|
|
|
public static bool IsGABContactsFolder(IFolder folder)
|
|
{
|
|
return GetGABContactsFolderInfo(folder) != null;
|
|
}
|
|
|
|
private void AccountDiscovered(ZPushAccount zpush)
|
|
{
|
|
Logger.Instance.Info(this, "Account discovered: {0}", zpush.DisplayName);
|
|
_domains.Add(zpush.DomainName);
|
|
|
|
zpush.ConfirmedChanged += (z) =>
|
|
{
|
|
if (zpush.Confirmed == ZPushAccount.ConfirmationType.IsZPush &&
|
|
!string.IsNullOrEmpty(zpush.GABFolder))
|
|
{
|
|
// Set up the Z-Push channel listener
|
|
ZPushChannel channel = ZPushChannels.Get(this, zpush, zpush.GABFolder);
|
|
channel.Available += ZPushChannelAvailable;
|
|
channel.Start();
|
|
}
|
|
};
|
|
}
|
|
|
|
private void AccountRemoved(ZPushAccount account)
|
|
{
|
|
try
|
|
{
|
|
foreach (GABHandler gab in _gabsByDomainName.Values)
|
|
{
|
|
gab.RemoveAccount(account);
|
|
}
|
|
CheckGABRemoved();
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Logger.Instance.Error(this, "Exception in AccountRemoved: {0}", e);
|
|
}
|
|
}
|
|
|
|
private void AccountsScanned()
|
|
{
|
|
try
|
|
{
|
|
Logger.Instance.Debug(this, "Accounts scanned");
|
|
CheckGABUnused();
|
|
CheckGABRemoved();
|
|
}
|
|
catch(System.Exception e)
|
|
{
|
|
Logger.Instance.Error(this, "Exception in AccountsScanned: {0}", e);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks and removes any GAB folders that are not registered to accounts. This
|
|
/// happens if an account is removed while Outlook is closed.
|
|
/// </summary>
|
|
private void CheckGABUnused()
|
|
{
|
|
if (!CheckUnused)
|
|
return;
|
|
|
|
if (_store != null)
|
|
{
|
|
_store.Dispose();
|
|
_store = null;
|
|
}
|
|
_store = ZPushLocalStore.GetInstance(App);
|
|
if (_store == null)
|
|
return;
|
|
|
|
bool deletedSomething = false;
|
|
using (IFolder root = _store.RootFolder)
|
|
{
|
|
foreach (IFolder subfolder in root.GetSubFolders<IFolder>())
|
|
{
|
|
using (subfolder)
|
|
{
|
|
// Remove any contacts folder that is not registered for GAB
|
|
GABInfo info = GetGABContactsFolderInfo(subfolder);
|
|
if (info != null && !_domains.Contains(info.Domain))
|
|
{
|
|
Logger.Instance.Info(this, "Unused GAB folder: {0} - {1}", subfolder.EntryId, subfolder.Name);
|
|
try
|
|
{
|
|
deletedSomething = true;
|
|
subfolder.Delete();
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Logger.Instance.Error(this, "Error removing GAB folder: {0}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (deletedSomething)
|
|
EmptyDeletedItems();
|
|
}
|
|
|
|
private void CheckGABRemoved()
|
|
{
|
|
Logger.Instance.Debug(this, "CheckGABRemoved");
|
|
|
|
// Find any GABs that no longer have accounts
|
|
List<KeyValuePair<string, GABHandler>> remove = new List<KeyValuePair<string, GABHandler>>();
|
|
foreach(KeyValuePair<string, GABHandler> entry in _gabsByDomainName)
|
|
{
|
|
Logger.Instance.Debug(this, "CheckGABRemoved: {0} - {1}", entry.Key, entry.Value.HasAccounts);
|
|
if (!entry.Value.HasAccounts)
|
|
{
|
|
remove.Add(entry);
|
|
}
|
|
}
|
|
|
|
// Remove any
|
|
if (remove.Count != 0)
|
|
{
|
|
foreach (KeyValuePair<string, GABHandler> entry in remove)
|
|
{
|
|
try
|
|
{
|
|
Logger.Instance.Info(this, "Removing GAB: {0}", entry.Key);
|
|
_gabsByDomainName.Remove(entry.Key);
|
|
entry.Value.Remove();
|
|
}
|
|
catch (System.Exception e)
|
|
{
|
|
Logger.Instance.Error(this, "Exception removing GAB: {0}: {1}", entry.Key, e);
|
|
}
|
|
}
|
|
|
|
EmptyDeletedItems();
|
|
}
|
|
}
|
|
|
|
private void RegisterGABAccount(ZPushAccount account, IFolder folder)
|
|
{
|
|
// Determine the domain name
|
|
string domain = account.DomainName;
|
|
|
|
// Could already be registered if there are multiple accounts on the same domain
|
|
GABHandler gab;
|
|
if (!_gabsByDomainName.TryGetValue(domain, out gab))
|
|
{
|
|
// Create the handler
|
|
gab = new GABHandler(this, (f) => CreateGABContacts(domain), (f) => DisposeGABContacts(f));
|
|
_gabsByDomainName.Add(domain, gab);
|
|
}
|
|
else
|
|
{
|
|
Logger.Instance.Debug(this, "GAB handler already registered: {0} on {1}", folder, folder.StoreDisplayName);
|
|
}
|
|
|
|
// Register the account with the GAB
|
|
gab.AddAccount(account, folder);
|
|
|
|
// The folder has become available, check the GAB messages
|
|
DoProcess(account, gab, null);
|
|
|
|
// And watch for any new messages
|
|
Watcher.WatchItems<IZPushItem>(folder, (item) => DoProcess(account, gab, item), false);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Processing
|
|
|
|
private void ZPushChannelAvailable(IFolder folder)
|
|
{
|
|
using (IStore store = folder.Store)
|
|
{
|
|
Logger.Instance.Debug(this, "Z-Push channel available: {0} on {1}", folder, store.DisplayName);
|
|
|
|
ZPushAccount account = Watcher.Accounts.GetAccount(folder);
|
|
if (account != null)
|
|
{
|
|
account.LinkedGABFolder(folder);
|
|
RegisterGABAccount(account, folder);
|
|
}
|
|
else
|
|
{
|
|
Logger.Instance.Warning(this, "Z-Push channel account not found: {0} on {1}", folder, store.DisplayName);
|
|
}
|
|
Logger.Instance.Debug(this, "Z-Push channel available done");
|
|
}
|
|
}
|
|
|
|
private void DoProcess(ZPushAccount account, GABHandler gab, IZPushItem item)
|
|
{
|
|
// Multiple accounts - and therefore multiple folders - may use the same GAB.
|
|
// One process the items from the first associated account
|
|
if (account != gab.ActiveAccount)
|
|
{
|
|
Logger.Instance.Trace(this, "Ignoring GAB message: {0} - {1}", account, item);
|
|
return;
|
|
}
|
|
|
|
++_processing;
|
|
Logger.Instance.Trace(this, "Processing GAB message: {0} - {1}", account, _processing);
|
|
try
|
|
{
|
|
gab.Process(item);
|
|
EmptyDeletedItems();
|
|
}
|
|
finally
|
|
{
|
|
Logger.Instance.Trace(this, "Processed GAB message: {0} - {1}", account, _processing);
|
|
--_processing;
|
|
}
|
|
}
|
|
|
|
private void EmptyDeletedItems()
|
|
{
|
|
if (_store != null)
|
|
_store.EmptyDeletedItems();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |