public ProcessResult ProcessRequest(IPolicyClientProgressDialog progress, bool showProgress, bool enableDynamicDiscovery)
{
Logger.LogDebug("Workshare.Policy.ClientManager.RequestManager.ProcessRequest()");
if (m_request == null)
{
m_processResult = ProcessResult.NO_VIOLATIONS;
return m_processResult;
}
if (!AllowActionForLargeAttachments(m_profileLocation))
{
return m_processResult;
}
// copy over large attachments, if any
CopyLargeAttachments();
bool progressCreatedLocally = false;
try
{
bool hasAttachments = HasSignificantAttachments();
if (enableDynamicDiscovery && !hasAttachments)
{
showProgress = false;
}
ShowProgress = showProgress;
m_encryptionUi = m_uiManager.CreateContentEncryptionUi();
m_enableDynamicDiscovery = enableDynamicDiscovery;
m_skipDiscovery = false;
DialogResult dialogResult;
if (m_enableDynamicDiscovery && !this.SendAndProtect && hasAttachments)
{
dialogResult = LoadDynamicDiscoveryDialog(false);
}
else
{
m_policyClientProgressDialog = progress;
dialogResult = LoadStaticDiscoveryDialog(ref progressCreatedLocally, false);
}
if (dialogResult == DialogResult.None && m_processResult != ProcessResult.UNDEFINED)
{
return m_processResult;
}
while (m_policyClientDialog.AbortActions)
{
m_policyClientDialog.AbortActions = false;
m_policyClientDialog.ContentPanelStyle = ContentPanelStyleEnum.PolicySummary;
dialogResult = m_policyClientDialog.ShowDialog(new ParentWindow(m_uiManager.ParentHwnd));
}
m_processResult = ProcessRequestErrors(dialogResult);
}
catch (Exception ex)
{
Logger.LogError(ex);
StringBuilder sb = new StringBuilder(Resources.CRITICAL_EXCEPTION);
sb.Append(' ');
sb.Append(Resources.CONTACT_SYSTEM_ADMIN);
m_errors.Add(sb.ToString());
m_exceptions.Add(ex);
m_processResult = ProcessResult.EXCEPTION;
}
finally
{
m_engineThread = null;
StartOfficeApplicationTimeout();
if (m_policyClientDialog != null)
{
m_policyClientDialog.ProcessResponseActions -= responseDialog_ProcessResponseActions;
m_policyClientDialog.PreviewResponseAction -= policyClientDialog_PreviewResponseAction;
}
// If we're creating this locally, we need to make sure Dispose is called on it
// See comment at top for further information
if (progressCreatedLocally)
{
m_policyClientProgressDialog.Refresh();
m_policyClientProgressDialog.Close();
IDisposable disp = m_policyClientProgressDialog;
if (disp != null)
{
disp.Dispose();
}
}
}
if (m_uiManager != null)
{
m_processResult = m_uiManager.HandleInvalidProcessResult(m_processResult, Errors, Exceptions);
}
return m_processResult;
}
public ProcessResult ProcessRequestForProtectSimple(bool displayProgress, bool isCorporateAccount)
{
try
{
ShowProgress = displayProgress;
m_bUpdateProcessResult = true;
m_encryptionUi = m_uiManager.CreateContentEncryptionUi();
m_bUseServerProfiles = isCorporateAccount && !OptionApi.GetBool("UseClientProfiles");
var psd = new NewProtectSimpleDialog(m_bUseServerProfiles)
{
MRUProfile = GetClientProfileMru(),
ShowInTaskbar = false
};
m_policyClientProgressDialog = psd;
m_policyClientProgressDialog.ShouldShowProgress = displayProgress;
psd.ProtectSimpleProfiles = this.ProtectSimpleProfiles;
if (psd.ShouldShowTheDialog)
{
psd.OnProcessProfile += OnProtectSimpleProcessProfile;
if (IsSendForReview && IsLotusNotesMailClient)
{
Logger.LogInfo("Detected Lotus Notes - Showing window as Always on Top");
psd.Topmost = true;
}
else
{
new System.Windows.Interop.WindowInteropHelper(psd).Owner = m_uiManager.ParentHwnd;
}
bool? dr = psd.ShowDialog();
if (m_bUpdateProcessResult)
{
m_processResult = ProcessRequestErrors(dr, psd.DialogResultEx);
if (m_processResult == ClientManager.ProcessResult.PROCESSED)
{
UpdateClientProfileMru(psd.MRUProfile);
}
}
}
else
{
m_processResult = ProcessResult.NO_ACTIONS;
}
}
catch (Exception ex)
{
if (m_policyClientProgressDialog != null)
{
// m_policyClientProgressDialog in this case is pointing to Protect Simple Dialog, psd assigned above.
// If an exception is thrown while the dialog is still on the screen, sometimes the dialog does not get
// dismissed properly. Thats why we need to call close here.
m_policyClientProgressDialog.Close();
}
Logger.LogError(ex);
StringBuilder sb = new StringBuilder(Resources.CRITICAL_EXCEPTION);
sb.Append(' ');
sb.Append(Resources.CONTACT_SYSTEM_ADMIN);
m_errors.Add(sb.ToString());
m_exceptions.Add(ex);
m_processResult = ProcessResult.EXCEPTION;
}
finally
{
StartOfficeApplicationTimeout();
if (m_uiManager != null)
{
m_processResult = m_uiManager.HandleInvalidProcessResult(m_processResult, Errors, Exceptions);
}
ResetPolicyCache();
if (m_encryptionUi != null)
{
m_encryptionUi.OnShowDialog -= new ShowDialogEvent(m_encryptionUi_OnShowDialog);
}
}
return m_processResult;
}
private void ShowAdvancedOptions(object protectSimpleDlg)
{
NewProtectSimpleDialog psd = protectSimpleDlg as NewProtectSimpleDialog;
if (psd == null)
{
return;
}
MethodInfo startMethod = m_policyClientProgressDialog.GetType().GetMethod("Start");
if (startMethod != null)
{
startMethod.Invoke(m_policyClientProgressDialog, null);
}
IPolicyClientUIManager2 m_uiManager = (IPolicyClientUIManager2)UIManagerFactory.CreateInstance("Workshare.Policy.ClientManager.ProtectDialog.ProtectPolicyClientUIManager2, Workshare.Policy.ClientManager");
IPolicyClientProgressDialog DialogProgress = m_uiManager.CreatePolicyClientProgressDialog();
IBlockOwner dBlockOwner = DialogProgress as IBlockOwner;
if (null != dBlockOwner)
{
dBlockOwner.SetOwner = new System.Windows.Interop.WindowInteropHelper(psd).Owner;
dBlockOwner.BlockOwner = true;
}
DialogProgress.Description = "Please wait...";
DialogProgress.SubDescription = "Initializing";
DialogProgress.SetSteps(7);
m_policyClientProgressDialog.Complete();
m_policyClientProgressDialog.Hide();
ProcessRequest( DialogProgress, ShowProgress, false );
DialogProgress.Complete();
DialogProgress.Close();
m_policyClientProgressDialog = psd;
MethodInfo stopMethod = m_policyClientProgressDialog.GetType().GetMethod("Stop");
if (stopMethod != null)
{
stopMethod.Invoke(m_policyClientProgressDialog, null);
}
if (m_processResult == ProcessResult.CANCELLED)
{
psd.AllowedToGo = false;
if (psd.Visibility != System.Windows.Visibility.Visible)
{
psd.ShowDialog();
}
psd.EnableControls();
}
else
{
// So if PES dialog has been cancelled, we need to update ProcessResult based on ProtectSimple dialog's DialogResult, later on, see below
// else if PES dialog has been "Sent", we need to remember the ProcessResult, and dont mess with it.
m_bUpdateProcessResult = false;
if (m_processResult == ClientManager.ProcessResult.PROCESSED)
{
psd.UpdateMru();
UpdateClientProfileMru(psd.MRUProfile);
}
}
}
void ProcessDesktopProfiles(object sender, EventArgs eventArgs)
{
NewProtectSimpleDialog psd = sender as NewProtectSimpleDialog;
if (psd == null)
{
Logger.LogError("NewProtectSimpleDialog is null");
return;
}
string profileLocation = psd.SelectedProfile;
m_profileLocation = profileLocation;
if (psd.ShowAdvancedOptions)
{
ResetPolicyCache();// Clear any previously selected profiles
AddProtectSimpleProfile(profileLocation);// Add selected profile, eg what the advanced protect dialog will show as triggered.
// Proceed to show the protect standard (email security) dialog, and let things happen
ShowAdvancedOptions(sender);
return;
}
// if large attachments are there, then we can just do Send Link on them
if (!AllowActionForLargeAttachments(m_profileLocation) && eventArgs is DoWorkEventArgs)
{
((DoWorkEventArgs)eventArgs).Cancel = true;
return;
}
// copy over large attachments, if any
CopyLargeAttachments();
if (m_processResult == ProcessResult.EXCEPTION && eventArgs is DoWorkEventArgs)
{
((DoWorkEventArgs)eventArgs).Cancel = true;
return;
}
// Make sure that progress output is directed to the Protect Simple dialog, otherwise, if the advanced progress dialog
// has been used, the user will see that pop up instead of showing progress within the Simple dialog itself.
m_policyClientProgressDialog = psd;
m_policyClientProgressDialog.SetDescription(Resources.INITIALISEPROTECTENGINE);
m_policyClientProgressDialog.SetSubDescription("");
// Ok the Policy Protect Process Dialog has a start and end method on it so lets dynamically get
// it as we can't get a direct reference to it.
MethodInfo startMethod = m_policyClientProgressDialog.GetType().GetMethod("Start");
if (startMethod != null)
{
startMethod.Invoke(m_policyClientProgressDialog, null);
}
PrepareProtectSimpleResponse(profileLocation);
MethodInfo stopMethod = m_policyClientProgressDialog.GetType().GetMethod("Stop");
if (stopMethod != null)
{
stopMethod.Invoke(m_policyClientProgressDialog, null);
}
if (m_uiResponse.BlockingActions.Count > 0)
{
m_processResult = ClientManager.ProcessResult.BLOCKED_BY_POLICY;
m_bUpdateProcessResult = false;
return;
}
if (!(m_processResult == ProcessResult.NO_ACTIONS || m_processResult == ProcessResult.NO_VIOLATIONS || m_processResult == ClientManager.ProcessResult.ERRORS))
{
ProcessProtectSimpleResponse(m_policyClientProgressDialog);
UserEventAnalyser.SendEvent(UserEventAnalyser.EventName.SimpleSend, new Dictionary<string, object>()
{
{"Profile Type", m_uiResponse.Request.PolicyType},
{"Profile Name", psd.SelectedProfileName}
});
return;
}
// We can't update processResult as there is no processing to be done after this.
// We need to retain this processResult so that OutlookHookWorker doesn't try to play with attachments
m_bUpdateProcessResult = false;
}
private DialogResult LoadStaticDiscoveryDialog(ref bool progressCreatedLocally, bool processAsync)
{
if (m_policyClientProgressDialog == null)
{
if (ShowProgress)
{
m_policyClientProgressDialog = m_uiManager.CreatePolicyClientProgressDialog();
m_policyClientProgressDialog.SetDescription(Resources.PROGRESS_DESC_PROCESSING);
progressCreatedLocally = true;
}
}
// The progress dialog gets updated all over the place so rather than
// trying to trap all of those events (and skip them if showprogress == false)
// just set a local 'showprogress' within the dialog itself and let that code handle it.
if (ShowProgress)
{
m_policyClientProgressDialog.ShouldShowProgress = ShowProgress;
m_policyClientProgressDialog.SetSteps(6);
UpdatePolicyClientProgress(Resources.PROGRESS_STATE_INITIALIZING);
}
StartScanningThread();
// Stuff is happening here on the EngineWorker - thread
while (!m_engineThread.Join(5))
{
// TODO: How long should we wait? Maybe we need to have a timeout.
Application.DoEvents();
}
if (m_processResult != ProcessResult.UNDEFINED)
{
if (ShowProgress)
{
m_policyClientProgressDialog.Complete();
m_policyClientProgressDialog.Refresh();
m_policyClientProgressDialog.Hide();
}
return DialogResult.None;
}
m_policyClientDialog = m_uiManager.CreatePolicyClientDialog2();
if (!processAsync)// Async processing will be carried out in another thread, so don't give the dialog a callback
{
m_policyClientDialog.ProcessResponseActions += responseDialog_ProcessResponseActions;
}
m_policyClientDialog.PreviewResponseAction += policyClientDialog_PreviewResponseAction;
m_policyClientDialog.SetResponse(m_uiResponse);
if (ShowProgress)
{
m_policyClientProgressDialog.Complete();
m_policyClientProgressDialog.Refresh();
}
if (m_policyClientProgressDialog != null && m_policyClientProgressDialog.Visible)
{
m_policyClientProgressDialog.Hide();
}
PerformanceCounters.Instance.StopTimer(PerformanceCounters.CounterType.SendToDialogShow, 0);
m_isInitialised = true;// Engine thread has done its stuff, so no need for us to call it again later(when async processing)
m_policyClientDialog.HideWhenProcessingActions = false;
IntPtr parentHwnd = m_uiManager.ParentHwnd;
ResponseAnalyser.CollectAndStoreDefaultsEvents(m_response, ResponseAnalyser.EventType.Action);
return m_policyClientDialog.ShowDialog(new ParentWindow(parentHwnd));
}
public TransparentActionProgressCallback(IPolicyClientProgressDialog progressDialog, int steps)
{
PolicyActionProgressDialog = progressDialog;
PolicyActionProgressDialog.SetSteps(steps);
}
