private void LoadSettings()
{
BusyText = Properties.Resources.OOFGet_Label;
KUITask
.New((ctx) =>
{
using (ZPushConnection con = new ZPushConnection(_account, ctx.CancellationToken))
{
_settings = con.Execute(new ActiveSync.SettingsOOFGet());
}
})
.OnSuccess(InitSettings, true)
.OnError((e) =>
{
Logger.Instance.Warning(this, "Exception getting OOF state: {0}", e);
if (MessageBox.Show(
Properties.Resources.OOFGet_Failed,
Properties.Resources.OOFGet_Title,
MessageBoxButtons.OKCancel,
MessageBoxIcon.Error
) != DialogResult.OK)
{
DialogResult = DialogResult.Cancel;
}
else
{
// Initialise default settings
_settings = new ActiveSync.SettingsOOF(true);
InitSettings();
}
})
.Start(this)
;
}
private void AddSharedFolderDialog_Shown(object sender, EventArgs args)
{
BusyText = Properties.Resources.SharedFolders_Fetching_Label;
KUITask
.New((ctx) =>
{
// TODO: bind cancellation token to Cancel button
// Fetch current shares
ICollection <SharedFolder> folders = _folders.GetCurrentShares(ctx.CancellationToken);
// Find the initial folder if required
if (_initialSyncId != null)
{
_initialFolder = folders.FirstOrDefault(f => f.SyncId == _initialSyncId);
}
// Group by store and folder id
return(folders.GroupBy(f => f.Store)
.ToDictionary(group => group.Key,
group => group.ToDictionary(folder => folder.BackendId)));
})
.OnSuccess(InitialiseTree, true)
.OnError((e) =>
{
UI.ErrorUtil.HandleErrorNew(typeof(FeatureSharedFolders), "Exception fetching shared folders for account {0}", e,
Properties.Resources.SharedFolders_Fetching_Title,
Properties.Resources.SharedFolders_Fetching_Failure,
_account.DisplayName);
DialogResult = DialogResult.Cancel;
})
.Start(this)
;
}
private void dialogButtons_Apply(object sender, EventArgs e)
{
BusyText = Properties.Resources.SharedFolders_Applying_Label;
KUITask.New((ctx) =>
{
// We reuse the same busy indicationg for all calls. A count is kept to ensure it's removed.
int count = 0;
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
if (storeNode.IsDirty)
{
ctx.AddBusy(1);
++count;
_folders.SetSharesForStore(storeNode.User, storeNode.CurrentShares, ctx.CancellationToken);
}
}
return(count);
})
.OnSuccess((ctx, count) =>
{
// Update UI state
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
if (storeNode.IsDirty)
{
storeNode.ChangesApplied();
}
}
ctx.AddBusy(-count);
// Sync account
_account.Account.SendReceive();
// Show success
ShowCompletion(Properties.Resources.SharedFolders_Applying_Success);
}, true)
.OnError((x) =>
{
ErrorUtil.HandleErrorNew(typeof(FeatureSharedFolders), "Exception applying shared folders for account {0}", x,
Properties.Resources.SharedFolders_Applying_Title,
Properties.Resources.SharedFolders_Applying_Failure,
_account.DisplayName);
})
.Start(this);
}
private void _buttons_Apply(object sender, EventArgs e)
{
BusyText = Properties.Resources.OOFSet_Label;
ActiveSync.SettingsOOF currentSettings = GetSettings();
KUITask
.New((ctx) =>
{
using (ZPushConnection connection = new ZPushConnection(_account, ctx.CancellationToken))
{
// Set the OOF state. This always seems to return ok, so we fetch the settings
// again, to see what happend
connection.Execute(new ActiveSync.SettingsOOFSet(currentSettings));
// Fetch the OOF state
return(connection.Execute(new ActiveSync.SettingsOOFGet()));
}
})
.OnSuccess((appliedSettings) =>
{
// Store them for later use
_feature.StoreOOFSettings(_account, appliedSettings);
// Check what happened
string message;
MessageBoxIcon messageIcon;
if (currentSettings.State == ActiveSync.OOFState.Disabled)
{
// Tried to disable.
if (appliedSettings.State != ActiveSync.OOFState.Disabled)
{
// It's an error if its not actually disabled
message = Properties.Resources.OOFSet_DisableFailed;
messageIcon = MessageBoxIcon.Error;
}
else
{
// All good
message = Properties.Resources.OOFSet_Disabled;
messageIcon = MessageBoxIcon.Information;
}
}
else if (appliedSettings.State == ActiveSync.OOFState.Disabled)
{
// It's an error if the state is set to disabled when we tried to enable
message = Properties.Resources.OOFSet_EnableFailed;
messageIcon = MessageBoxIcon.Error;
}
else
{
// All good
if (appliedSettings.State == ActiveSync.OOFState.EnabledTimeBased)
{
message = string.Format(Properties.Resources.OOFSet_EnabledTimeBased,
appliedSettings.From, appliedSettings.Till);
}
else
{
message = Properties.Resources.OOFSet_Enabled;
}
messageIcon = MessageBoxIcon.Information;
// It's okay if the state is not the same, but it deserves a message
if (appliedSettings.State != currentSettings.State)
{
message = Properties.Resources.OOFSet_DifferentState + message;
messageIcon = MessageBoxIcon.Warning;
}
}
Logger.Instance.Debug(this, "OOF state updated: {0}, {1}", message, messageIcon);
MessageBox.Show(message,
Properties.Resources.OOFSet_Title,
MessageBoxButtons.OK,
messageIcon
);
if (messageIcon == MessageBoxIcon.Information)
{
// All good, close the dialog
_buttons.IsDirty = false;
DialogResult = DialogResult.OK;
}
else
{
// There was a problem, initialise the dialog to what's set.
_settings = appliedSettings;
InitSettings();
CheckDirty();
}
}, true)
.OnError((x) =>
{
ErrorUtil.HandleErrorNew(this, "Exception in OOFSet", x,
Properties.Resources.OOFSet_Title, Properties.Resources.OOFSet_Failed);
})
.Start(this)
;
}
private void dialogButtons_Apply(object sender, EventArgs e)
{
int folderCount = 0;
// Check if all fields are properly set
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
// Check totals
folderCount += storeNode.CurrentShares.Count();
// Check modified folders
if (storeNode.IsDirty)
{
foreach (SharedFolder folder in storeNode.CurrentShares)
{
// Check if the send-as address has been resolved (or entered) correctly
if (folder.FlagSendAsOwner && string.IsNullOrWhiteSpace(folder.SendAsAddress))
{
// Find the tree node
KTreeNode folderNode = storeNode.FindNode(folder);
if (folderNode != null)
{
// See if we can obtain it from a parent
TryInitSendAsAddressParent(folderNode as FolderTreeNode);
if (!string.IsNullOrWhiteSpace(folder.SendAsAddress))
{
continue;
}
// If the node is already selected, explicitly warn about the send-as address
// Otherwise, selecting it will pop up the warning
if (folderNode.IsSelected)
{
TryInitSendAsAddress();
}
else
{
FocusNode(folderNode, false);
}
}
return;
}
}
}
}
// Check total number of folders
if (folderCount >= _feature.MaxFolderCount)
{
MessageBox.Show(ThisAddIn.Instance.Window,
Properties.Resources.SharedFolders_TooManyFolders_Body,
Properties.Resources.SharedFolders_TooManyFolders_Title,
MessageBoxButtons.OK,
MessageBoxIcon.Error
);
// And don't apply anything
return;
}
BusyText = Properties.Resources.SharedFolders_Applying_Label;
KUITask.New((ctx) =>
{
// We reuse the same busy indicationg for all calls. A count is kept to ensure it's removed.
ApplyState state = new ApplyState();
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
// Check modified folders
if (storeNode.IsDirty)
{
ctx.AddBusy(1);
++state.folders;
// Check removed shares
_folders.RemoveSharesForStore(storeNode.User, storeNode.RemovedShares);
// Set shares
_folders.SetSharesForStore(storeNode.User, storeNode.CurrentShares, ctx.CancellationToken);
}
// And modified stores
if (storeNode.IsWholeStoreDirty)
{
state.stores.Add(storeNode);
}
}
return(state);
})
.OnSuccess((ctx, state) =>
{
// Update UI state
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
if (storeNode.IsDirty)
{
storeNode.ChangesApplied();
}
}
ctx.AddBusy(-state.folders);
List <ZPushAccount> syncAdditional = new List <ZPushAccount>();
// Handle stores
if (state.stores.Count > 0)
{
List <StoreTreeNode> add = new List <StoreTreeNode>();
// Remove any unshared store
foreach (StoreTreeNode store in state.stores)
{
if (store.WantShare)
{
// Check if it must be added
if (!store.IsShared)
{
add.Add(store);
}
// Update reminders for existing stores
if (store.ShowReminders != store.ShowRemindersInitial)
{
ZPushAccount storeAccount = store.WholeStoreAccount;
if (storeAccount != null)
{
storeAccount.ShowReminders = store.ShowReminders;
syncAdditional.Add(storeAccount);
// Update UI state
store.ShowRemindersInitial = store.ShowReminders;
WholeStoreShareChanged(store);
}
}
continue;
}
else
{
// Remove it
_feature.RemoveSharedStore(_account, store.User);
store.IsShared = false;
WholeStoreShareChanged(store);
}
}
// Check for any new stores
if (add.Count > 0)
{
bool restart = MessageBox.Show(ThisAddIn.Instance.Window,
Properties.Resources.SharedFolders_WholeStoreRestart_Body,
Properties.Resources.SharedFolders_WholeStoreRestart_Title,
MessageBoxButtons.OKCancel,
MessageBoxIcon.Information
) == DialogResult.OK;
// Reset state. Also do this when restarting, to avoid warning message about unsaved changes
foreach (StoreTreeNode node in state.stores)
{
node.WantShare = node.IsShared;
}
if (!restart)
{
return;
}
// Restart
IRestarter restarter = ThisAddIn.Instance.Restarter();
restarter.CloseWindows = true;
foreach (StoreTreeNode node in state.stores)
{
restarter.OpenShare(_account, node.User, node.ShowReminders);
}
restarter.Restart();
}
// Update UI state
foreach (StoreTreeNode storeNode in _userFolders.Values)
{
storeNode.ChangesApplied();
}
CheckDirty();
}
// Sync accounts
foreach (ZPushAccount account in syncAdditional)
{
_feature.Sync(account);
}
if (state.folders != 0)
{
// Sync account
_feature.Sync(_account);
// Show success
ShowCompletion(Properties.Resources.SharedFolders_Applying_Success);
}
}, true)
.OnError((x) =>
{
ErrorUtil.HandleErrorNew(typeof(FeatureSharedFolders), "Exception applying shared folders for account {0}", x,
Properties.Resources.SharedFolders_Applying_Title,
Properties.Resources.SharedFolders_Applying_Failure,
_account.DisplayName);
})
.Start(this);
}
