private void AddSortDataForSynchronousGetList(PowerShellResults <JsonDictionary <object> > results, List <JsonDictionary <object> > outputs, IList <string> outputList, List <string> unicodeColumnNames)
{
if (outputs != null && outputs.Count > 0)
{
List <Tuple <int, JsonDictionary <object> > > list = new List <Tuple <int, JsonDictionary <object> > >(outputs.Count);
for (int i = 0; i < outputs.Count; i++)
{
list.Add(new Tuple <int, JsonDictionary <object> >(i, outputs[i]));
}
CultureInfo culture = CultureInfo.CurrentCulture;
using (List <string> .Enumerator enumerator = unicodeColumnNames.GetEnumerator())
{
while (enumerator.MoveNext())
{
string column = enumerator.Current;
list.Sort((Tuple <int, JsonDictionary <object> > tuple1, Tuple <int, JsonDictionary <object> > tuple2) => string.Compare((string)tuple1.Item2.RawDictionary[column], (string)tuple2.Item2.RawDictionary[column], true, culture));
int num = -1;
string key = column + "_s";
Tuple <int, JsonDictionary <object> > tuple = null;
foreach (Tuple <int, JsonDictionary <object> > tuple3 in list)
{
if (tuple == null || !string.Equals((string)tuple.Item2.RawDictionary[column], (string)tuple3.Item2.RawDictionary[column], StringComparison.CurrentCultureIgnoreCase))
{
num++;
}
tuple3.Item2.RawDictionary[key] = num;
tuple = tuple3;
}
}
}
}
}
internal void ExecuteCmdlet(IEnumerable pipelineInput, RunResult runResult, out PowerShellResults <PSObject> result, bool isGetListAsync = false)
{
DDIHelper.Trace(TraceType.InfoTrace, "Executing :" + base.GetType().Name);
DDIHelper.Trace(TraceType.InfoTrace, "Task: {0}", new object[]
{
this.Command
});
DDIHelper.Trace(TraceType.InfoTrace, "Pipeline: {0}", new object[]
{
pipelineInput
});
WebServiceParameters parameters = null;
if (this.AllowExceuteThruHttpGetRequest)
{
parameters = CmdletActivity.allowExceuteThruHttpGetRequestParameters;
}
result = this.Command.Invoke <PSObject>(DataSourceService.UserRunspaces, pipelineInput, parameters, this, isGetListAsync);
if (this.DisableLogging)
{
result.CmdletLogInfo = null;
}
this.StatusReport = result;
runResult.ErrorOccur = !this.StatusReport.Succeeded;
}
private void InvokeDataItemWebService()
{
MethodInfo method = this.GroupWebService.ServiceType.GetMethod(this.WebServiceMethodName ?? "GetList");
try
{
object filter = this.GetFilter();
MethodBase methodBase = method;
object serviceInstance = this.GroupWebService.ServiceInstance;
object[] array = new object[2];
array[0] = filter;
PowerShellResults powerShellResults = (PowerShellResults)methodBase.Invoke(serviceInstance, array);
if (powerShellResults.Succeeded)
{
IEnumerable source = (IEnumerable)powerShellResults;
List <GroupedCheckBoxListItem> list = new List <GroupedCheckBoxListItem>();
foreach (GroupedCheckBoxListItem item in source.Cast <GroupedCheckBoxListItem>())
{
list.Add(item);
}
this.results = new PowerShellResults <GroupedCheckBoxListItem>
{
Output = list.ToArray()
};
}
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
}
private static void AggregateData(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
DLPPolicyReportingService dlppolicyReportingService = new DLPPolicyReportingService();
PowerShellResults <MailTrafficPolicyReport> dlptrafficData = dlppolicyReportingService.GetDLPTrafficData(new DLPPolicyTrafficReportParameters
{
StartDate = new DateTime?((DateTime)ExDateTime.GetNow(EcpDateTimeHelper.GetCurrentUserTimeZone()).Subtract(new TimeSpan(48, 0, 0)).ToUtc()),
EndDate = new DateTime?((DateTime)ExDateTime.GetNow(EcpDateTimeHelper.GetCurrentUserTimeZone()).ToUtc()),
EventType = "DlpPolicyHits,DlpPolicyOverride,DlpPolicyFalsePositive",
Direction = "Outbound"
});
if (dlptrafficData != null && dlptrafficData.Output != null)
{
IEnumerable <MailTrafficPolicyReport> source = from d in dlptrafficData.Output
orderby d.Date.Date descending, d.Date.Hour descending
select d;
IEnumerable <MailTrafficPolicyReport> reportData = source.Take(24);
IEnumerable <MailTrafficPolicyReport> trendData = source.Skip(24);
foreach (object obj in dataTable.Rows)
{
DataRow row = (DataRow)obj;
DLPPolicy.CalcuatePolicyData(row, "Name", "Hits", "HitsTrend", "DlpPolicyHits", reportData, trendData);
DLPPolicy.CalcuatePolicyData(row, "Name", "Overrides", "OverridesTrend", "DlpPolicyOverride", reportData, trendData);
DLPPolicy.CalcuatePolicyData(row, "Name", "FalsePositives", "FalsePositivesTrend", "DlpPolicyFalsePositive", reportData, trendData);
}
}
}
public PowerShellResults <JsonDictionary <object> > Execute()
{
PowerShellResults <JsonDictionary <object> > result;
using (EcpPerformanceData.DDIServiceExecution.StartRequestTimer())
{
switch (this.ExecutingWorkflow.AsyncMode)
{
case AsyncMode.AsynchronousOnly:
this.ExecutingWorkflow.AsyncRunning = true;
break;
case AsyncMode.SynchronousAndAsynchronous:
this.ExecutingWorkflow.AsyncRunning = (base.DataObjectStore.AsyncType == ListAsyncType.GetListAsync || base.DataObjectStore.AsyncType == ListAsyncType.GetListPreLoad);
break;
}
if (!this.ExecutingWorkflow.AsyncRunning || DDIHelper.ForGetListProgress)
{
result = this.ExecuteCore(this.ExecutingWorkflow);
}
else
{
if (!typeof(ProgressCalculatorBase).IsAssignableFrom(this.ExecutingWorkflow.ProgressCalculator))
{
throw new ArgumentException("A valid ProgressCalculator type must be specified for async running workflow.");
}
Func <PowerShellResults> callback = delegate()
{
IList <string> outputVariables = this.GetOutputVariables(this.OutputVariableWorkflow);
AsyncGetListContext asyncGetListContext = new AsyncGetListContext
{
WorkflowOutput = string.Join(",", outputVariables ?? ((IList <string>)Array <string> .Empty)),
UnicodeOutputColumnNames = this.GetUnicodeVariablesFrom(outputVariables),
Parameters = this.parameters
};
AsyncServiceManager.RegisterWorkflow(this.ExecutingWorkflow, asyncGetListContext);
return(this.ExecuteCore(this.ExecutingWorkflow));
};
AsyncTaskType taskType = AsyncTaskType.Default;
string text = this.ExecutingWorkflow.Name;
if (base.DataObjectStore.AsyncType == ListAsyncType.GetListAsync)
{
taskType = AsyncTaskType.AsyncGetList;
}
else if (base.DataObjectStore.AsyncType == ListAsyncType.GetListPreLoad)
{
taskType = AsyncTaskType.AsyncGetListPreLoad;
text += "_PreLoad";
}
PowerShellResults powerShellResults = AsyncServiceManager.InvokeAsync(callback, null, this.UniqueLogonUserIdentity, taskType, text);
result = new PowerShellResults <JsonDictionary <object> >
{
ProgressId = powerShellResults.ProgressId,
ErrorRecords = powerShellResults.ErrorRecords
};
}
}
return(result);
}
protected override PowerShellResults <JsonDictionary <object> > ExecuteCore(Workflow workflow)
{
PowerShellResults <JsonDictionary <object> > powerShellResults = new PowerShellResults <JsonDictionary <object> >();
PowerShellResults powerShellResults2 = workflow.Run(base.Input, base.Table, base.DataObjectStore, base.ProfileBuilder.Class, delegate(string result, bool fillAllColumns)
{
});
powerShellResults.MergeErrors(powerShellResults2);
powerShellResults.MergeProgressData <JsonDictionary <object> >(powerShellResults2 as PowerShellResults <JsonDictionary <object> >);
if (powerShellResults.ErrorRecords.Length == 0)
{
using (EcpPerformanceData.DDITypeConversion.StartRequestTimer())
{
Dictionary <string, object> dictionary = null;
List <JsonDictionary <object> > list = new List <JsonDictionary <object> >();
IList <string> outputList = base.GetOutputVariables(base.OutputVariableWorkflow);
DataColumn[] columns = (from DataColumn c in base.Table.Columns
where outputList == null || outputList.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase)
select c).ToArray <DataColumn>();
foreach (object obj in base.Table.DefaultView)
{
DataRowView dataRowView = (DataRowView)obj;
base.ExtractDataRow(dataRowView.Row, columns, out dictionary);
list.Add(dictionary);
}
this.AddSortDataToResult(powerShellResults, list, outputList);
if (this.sortOptions != null && outputList.Contains(this.sortOptions.PropertyName))
{
Func <JsonDictionary <object>[], JsonDictionary <object>[]> ddisortFunction = this.sortOptions.GetDDISortFunction();
powerShellResults.Output = ddisortFunction(list.ToArray());
}
else
{
powerShellResults.Output = list.ToArray();
}
GetListWorkflow getListWorkflow = workflow as GetListWorkflow;
if (getListWorkflow != null)
{
int resultSizeInt = getListWorkflow.GetResultSizeInt32(base.Input, base.Table);
if (resultSizeInt > 0 && resultSizeInt < list.Count)
{
powerShellResults.Output = powerShellResults.Output.Take(resultSizeInt).ToArray <JsonDictionary <object> >();
if (!powerShellResults.Warnings.Contains(Strings.WarningMoreResultsAvailable))
{
powerShellResults.Warnings = powerShellResults.Warnings.Concat(new string[]
{
Strings.WarningMoreResultsAvailable
}).ToArray <string>();
}
}
}
}
}
DDIHelper.Trace(TraceType.InfoTrace, "Result: ");
DDIHelper.Trace <PowerShellResults <JsonDictionary <object> > >(TraceType.InfoTrace, powerShellResults);
return(powerShellResults);
}
public static void FetchRelayDomains(DataRow inputRow, DataTable dataTable, DataObjectStore store, PowerShellResults[] results)
{
PowerShellResults <PSObject> powerShellResults = (PowerShellResults <PSObject>)results[0];
if (powerShellResults.Succeeded)
{
dataTable.Rows[0]["_AcceptedDomains"] = MigrationBatchService.FilterAcceptedDomains(powerShellResults.Output, (Microsoft.Exchange.Data.Directory.SystemConfiguration.AcceptedDomain domain) => domain.DomainType != AcceptedDomainType.Authoritative);
}
}
public IList GetData(IEntity entity, Expression expression)
{
IPSCommandWrapper ipscommandWrapper = DependencyFactory.CreatePSCommandWrapper();
ipscommandWrapper.AddCommand(entity.TaskInvocationInfo.CmdletName);
if (entity.TaskInvocationInfo.Parameters != null)
{
foreach (KeyValuePair <string, string> keyValuePair in entity.TaskInvocationInfo.Parameters)
{
ipscommandWrapper.AddParameter(keyValuePair.Key, keyValuePair.Value);
}
}
if (!this.principal.IsInRole(string.Format("{0}\\{1}?{2}", entity.TaskInvocationInfo.SnapinName, entity.TaskInvocationInfo.CmdletName, "Expression")))
{
throw new InvalidOperationException(string.Format("Expression parameter is not avaible for the cmdlet {0}\\{1}. Add an entry in Microsoft.Exchange.Configuration.Authorization.ClientRoleEntries.TenantReportingRequiredParameters for your cmdlet.", entity.TaskInvocationInfo.SnapinName, entity.TaskInvocationInfo.CmdletName));
}
ipscommandWrapper.AddParameter("Expression", expression);
IList data = null;
using (new AverageTimePerfCounter(RwsPerfCounters.AverageReportCmdletResponseTime, RwsPerfCounters.AverageReportCmdletResponseTimeBase, true))
{
PowerShellResults result = ipscommandWrapper.Invoke(ReportingDataSource.RunspaceMediator);
if (result.Succeeded)
{
ElapsedTimeWatcher.Watch(RequestStatistics.RequestStatItem.CreateGenericTypeListForResults, delegate
{
data = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(new Type[]
{
entity.ClrType
}), new object[]
{
result.Output.Count
});
});
foreach (PSObject psobject in result.Output)
{
data.Add(psobject.BaseObject);
}
ReportingDataSource.reportRowCounter.AddSample((long)data.Count);
}
else
{
ReportingWebServiceEventLogConstants.Tuple_InvokeCmdletFailed.LogEvent(new object[]
{
EventLogExtension.GetUserNameToLog(),
ipscommandWrapper.Commands[0].CommandText,
result.Errors[0].Exception
});
RwsPerfCounters.ReportCmdletErrors.Increment();
this.ThrowError(result.Errors[0]);
}
}
return(data);
}
public static void GetListRawResultAction(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
PowerShellResults <PSObject> powerShellResults = (PowerShellResults <PSObject>)store.GetDataObject("CASMailbox");
if (powerShellResults != null && powerShellResults.Output.Length == 1)
{
foreach (object obj in dataTable.Rows)
{
DataRow dataRow = (DataRow)obj;
dataRow["IsLoggingRunning"] = powerShellResults.Output[0].Properties["ActiveSyncDebugLogging"].Value;
}
}
}
public override PowerShellResults[] GetStatusReport(DataRow input, DataTable dataTable, DataObjectStore store)
{
if (base.ErrorBehavior == ErrorBehavior.SilentlyContinue)
{
this.errorRecords.Clear();
}
PowerShellResults[] array = new PowerShellResults[]
{
new PowerShellResults()
};
array[0].ErrorRecords = this.errorRecords.ToArray();
return(array);
}
private void AddSortDataToResult(PowerShellResults <JsonDictionary <object> > results, List <JsonDictionary <object> > outputs, IList <string> outputList)
{
List <string> unicodeVariablesFrom = base.GetUnicodeVariablesFrom(outputList);
if (unicodeVariablesFrom.Count > 0)
{
if (!DDIHelper.ForGetListProgress || base.DataObjectStore.AsyncType == ListAsyncType.GetListEndLoad)
{
this.AddSortDataForSynchronousGetList(results, outputs, outputList, unicodeVariablesFrom);
return;
}
this.AddSortDataForAsynchronousGetList(results, outputs, outputList, unicodeVariablesFrom);
}
}
public static void FetchMigrationEndpoints(DataRow inputRow, DataTable dataTable, DataObjectStore store, PowerShellResults[] results)
{
PowerShellResults <PSObject> powerShellResults = (PowerShellResults <PSObject>)results[0];
List <MigrationEndpointObject> list = new List <MigrationEndpointObject>(powerShellResults.HasValue ? powerShellResults.Output.Length : 0);
if (powerShellResults.Succeeded)
{
foreach (PSObject psobject in powerShellResults.Output)
{
list.Add(new MigrationEndpointObject((MigrationEndpoint)psobject.BaseObject));
}
}
dataTable.Rows[0]["_AllMigrationEndpoints"] = list;
}
internal static PowerShellResults InsertError(PowerShellResults result, string error)
{
Microsoft.Exchange.Management.ControlPanel.ErrorRecord[] array = new Microsoft.Exchange.Management.ControlPanel.ErrorRecord[]
{
new Microsoft.Exchange.Management.ControlPanel.ErrorRecord(new Exception(error))
};
if (result.ErrorRecords == null)
{
result.ErrorRecords = array;
}
else
{
result.ErrorRecords = result.ErrorRecords.Concat(array).ToArray <Microsoft.Exchange.Management.ControlPanel.ErrorRecord>();
}
return(result);
}
public PowerShellResults Run(DataRow input, DataTable dataTable, DataObjectStore store, Type codeBehind, Workflow.UpdateTableDelegate updateTableDelegate)
{
DDIHelper.Trace("Executing workflow: {0} {1}", new object[]
{
base.GetType().Name,
this.Name
});
this.Initialize(input, dataTable);
List <PowerShellResults> list = new List <PowerShellResults>();
this.activitiesExecutedCount = 0;
bool forGetListProgress = DDIHelper.ForGetListProgress;
foreach (Activity activity in this.Activities)
{
if (activity.IsRunnable(input, dataTable, store))
{
this.currentExecutingActivity = activity;
if (!forGetListProgress && this.AsyncRunning)
{
foreach (Activity activity2 in activity.Find((Activity x) => x is CmdletActivity))
{
CmdletActivity cmdletActivity = (CmdletActivity)activity2;
cmdletActivity.PSProgressChanged += this.Activity_ProgressChanged;
}
}
RunResult runResult = activity.RunCore(input, dataTable, store, codeBehind, updateTableDelegate);
list.AddRange(activity.GetStatusReport(input, dataTable, store));
if (runResult.ErrorOccur && activity.ErrorBehavior == ErrorBehavior.Stop)
{
break;
}
}
this.activitiesExecutedCount++;
}
PowerShellResults powerShellResults = forGetListProgress ? new PowerShellResults <JsonDictionary <object> >() : new PowerShellResults();
foreach (PowerShellResults powerShellResults2 in list)
{
powerShellResults.MergeErrors(powerShellResults2);
if (forGetListProgress)
{
((PowerShellResults <JsonDictionary <object> >)powerShellResults).MergeProgressData <PSObject>(powerShellResults2 as PowerShellResults <PSObject>);
}
}
return(powerShellResults);
}
public static void NewObjectPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store, PowerShellResults[] results)
{
if (results.Length == 0 || dataTable.Rows.Count == 0)
{
return;
}
DataRow dataRow = dataTable.Rows[0];
PowerShellResults powerShellResults = results[0];
if (powerShellResults.Succeeded && string.Compare((string)inputRow["Name"], (string)dataRow["DisplayName"]) != 0)
{
string text = Strings.GroupNameWithNamingPolciy((string)dataRow["DisplayName"]);
powerShellResults.Informations = new string[]
{
text
};
}
}
public static bool CanAccessMailboxOf(string smtpAddress)
{
if (!RbacPrincipal.Current.IsInRole(string.Format("{0}?Identity&User", "Get-MailboxPermission")))
{
return(false);
}
if (string.Compare(smtpAddress, LocalSession.Current.ExecutingUserPrimarySmtpAddress.ToString(), true) == 0)
{
return(true);
}
MailboxPermissions mailboxPermissions = new MailboxPermissions();
PowerShellResults <MailboxPermissionsRow> list = mailboxPermissions.GetList(new GetMailboxPermissionParameters
{
Identity = new Identity(smtpAddress),
User = Identity.FromExecutingUserId()
}, null);
return(list.Output.Length == 1 && (list.Output[0].HasReadAccess || list.Output[0].HasFullAccess));
}
internal static PowerShellResults InsertWarning(PowerShellResults result, string warning)
{
string[] warnings = new string[]
{
warning
};
if (result.Warnings == null)
{
result.Warnings = warnings;
}
else
{
result.Warnings = result.Warnings.Concat(new string[]
{
warning
}).ToArray <string>();
}
return(result);
}
public static void GetProgressPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store, PowerShellResults[] results)
{
PowerShellResults <PSObject> powerShellResults = results[0] as PowerShellResults <PSObject>;
if (powerShellResults != null && powerShellResults.SucceededWithValue)
{
UMPhoneSession umphoneSession = (UMPhoneSession)powerShellResults.Value.BaseObject;
if (umphoneSession.OperationResult == UMOperationResult.InProgress)
{
powerShellResults.ProgressRecord = new Microsoft.Exchange.Management.ControlPanel.ProgressRecord
{
Status = umphoneSession.CallState.ToString()
};
return;
}
powerShellResults.ProgressRecord = new Microsoft.Exchange.Management.ControlPanel.ProgressRecord
{
Status = umphoneSession.CallState.ToString(),
HasCompleted = true,
Percent = 100
};
}
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
HtmlTableCell htmlTableCell = (HtmlTableCell)base.ContentContainer.FindControl("genericErrorsLink");
PowerShellResults <MailboxSearch> powerShellResults = base.Results as PowerShellResults <MailboxSearch>;
if (powerShellResults != null && powerShellResults.SucceededWithValue)
{
MailboxSearch mailboxSearch = powerShellResults.Output[0];
string leftPart = this.Context.GetRequestUrl().GetLeftPart(UriPartial.Authority);
string arg = Encoder.UrlEncode(Encoder.HtmlEncode(mailboxSearch.Identity.RawIdentity));
HtmlAnchor htmlAnchor = new HtmlAnchor();
htmlAnchor.InnerHtml = Strings.ClickHereForDetails;
string arg2 = string.Format("{0}/ecp/Reporting/ViewMailboxSearchGenericErrors.aspx?Id={1}", leftPart, arg);
htmlAnchor.HRef = "#";
htmlAnchor.Attributes.Add("onclick", string.Format("window.open(\"{0}\",\"_blank\",\"width=800,height=600,scrollbars=yes,resizable=no,toolbar=yes,directories=no,location=center,menubar=yes,status=yes\"); return false", arg2));
if (htmlTableCell != null && mailboxSearch.TotalUndefinedErrors > 0)
{
htmlTableCell.Controls.Add(htmlAnchor);
}
htmlAnchor.Dispose();
}
}
public static void FetchAcceptedDomains(DataRow inputRow, DataTable dataTable, DataObjectStore store, PowerShellResults[] results)
{
PowerShellResults <PSObject> powerShellResults = (PowerShellResults <PSObject>)results[0];
if (!powerShellResults.Succeeded)
{
return;
}
bool flag = false;
if (!DBNull.Value.Equals(dataTable.Rows[0]["IsDedicated"]))
{
flag = (bool)dataTable.Rows[0]["IsDedicated"];
}
if (flag)
{
dataTable.Rows[0]["_AcceptedDomains"] = MigrationBatchService.FilterAcceptedDomains(powerShellResults.Output, (Microsoft.Exchange.Data.Directory.SystemConfiguration.AcceptedDomain domain) => domain.DomainType == AcceptedDomainType.Authoritative);
return;
}
bool flag2 = false;
if (!DBNull.Value.Equals(dataTable.Rows[0]["IsMultiTenant"]))
{
flag2 = (bool)dataTable.Rows[0]["IsMultiTenant"];
}
if (flag2)
{
string[] array = MigrationBatchService.FilterAcceptedDomains(powerShellResults.Output, (Microsoft.Exchange.Data.Directory.SystemConfiguration.AcceptedDomain domain) => domain.IsCoexistenceDomain);
if (array.Length > 0)
{
dataTable.Rows[0]["TargetDeliveryDomain"] = array[0];
dataTable.Rows[0]["_AcceptedDomains"] = array;
}
return;
}
dataTable.Rows[0]["_AcceptedDomains"] = MigrationBatchService.FilterAcceptedDomains(powerShellResults.Output, (Microsoft.Exchange.Data.Directory.SystemConfiguration.AcceptedDomain domain) => true);
}
private PowerShellResults <JsonDictionary <object> > GetListCommon(DDIParameters filter, SortOptions sort, bool forGetProgress)
{
string workflowName = this.workflow ?? "GetList";
WSDataHandler wsdataHandler = new WSListDataHandler(this.schemaFilesInstallPath, this.schema, workflowName, filter, sort);
this.RaiseWSDataHandlerCreatedEvent(wsdataHandler);
this.SetWorkflowOutput(workflowName, wsdataHandler, filter);
wsdataHandler.DataObjectStore.SetModifiedColumns(this.InitializeDDIParameters(wsdataHandler, filter));
wsdataHandler.DataObjectStore.IsGetListWorkflow = true;
if (filter != null && filter.Parameters != null && filter.Parameters.ContainsKey("ProgressId") && !forGetProgress)
{
wsdataHandler.DataObjectStore.AsyncType = ListAsyncType.GetListEndLoad;
DDIHelper.ProgressIdForGetListAsync = (string)filter.Parameters["ProgressId"];
}
else if (DDIHelper.IsGetListAsync)
{
wsdataHandler.DataObjectStore.AsyncType = ListAsyncType.GetListAsync;
}
else if (DDIHelper.IsGetListPreLoad)
{
wsdataHandler.DataObjectStore.AsyncType = ListAsyncType.GetListPreLoad;
}
PowerShellResults <JsonDictionary <object> > powerShellResults = wsdataHandler.Execute();
if (powerShellResults.HasWarnings)
{
for (int i = 0; i < powerShellResults.Warnings.Length; i++)
{
if (powerShellResults.Warnings[i] == Strings.WarningMoreResultsAvailable)
{
powerShellResults.Warnings[i] = ClientStrings.ListViewMoreResultsWarning;
}
}
}
return(powerShellResults);
}
protected override PowerShellResults <JsonDictionary <object> > ExecuteCore(Workflow workflow)
{
DataRow row = base.Table.NewRow();
base.Table.Rows.Add(row);
base.Row.ItemArray = base.Input.ItemArray;
PowerShellResults <JsonDictionary <object> > powerShellResults = new PowerShellResults <JsonDictionary <object> >();
powerShellResults.MergeErrors(workflow.Run(base.Input, base.Table, base.DataObjectStore, base.ProfileBuilder.Class, new Workflow.UpdateTableDelegate(this.UpdateTable)));
if (powerShellResults.ErrorRecords.Length == 0)
{
if (workflow.AsyncRunning && AsyncServiceManager.IsCurrentWorkCancelled())
{
goto IL_451;
}
using (EcpPerformanceData.DDITypeConversion.StartRequestTimer())
{
IList <string> outputVariables = base.GetOutputVariables(base.OutputVariableWorkflow);
Func <DataColumn, bool> predicate;
if (this.IsGetObjectForNew)
{
predicate = ((DataColumn c) => outputVariables.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase) && this.Row[c.ColumnName] != DBNull.Value);
}
else
{
predicate = ((DataColumn c) => outputVariables.Contains(c.ColumnName, StringComparer.OrdinalIgnoreCase) || (Variable.MandatoryVariablesForGetObject.Contains(c.ColumnName) && this.ExecutingWorkflow is GetObjectWorkflow));
}
IEnumerable <DataColumn> columns = (outputVariables == null) ? base.Table.Columns.Cast <DataColumn>() : base.Table.Columns.Cast <DataColumn>().Where(predicate);
Dictionary <string, object> dictionary;
base.ExtractDataRow(base.Table.Rows[0], columns, out dictionary);
if (base.ExecutingWorkflow is GetObjectWorkflow)
{
foreach (string name in this.GetOutputRelatedDataObjects(columns))
{
IVersionable versionable = base.DataObjectStore.GetDataObject(name) as IVersionable;
if (versionable != null && versionable.ExchangeVersion != null)
{
bool flag = versionable.ExchangeVersion.IsOlderThan(base.DataObjectStore.GetDataObjectDeclaration(name).MinSupportedVersion);
if (versionable.IsReadOnly || flag)
{
base.Table.Rows[0]["IsReadOnly"] = true;
if (dictionary.ContainsKey("IsReadOnly"))
{
dictionary["IsReadOnly"] = true;
}
string text = flag ? Strings.ObjectTooOld : Strings.VersionMismatchWarning(versionable.ExchangeVersion.ExchangeBuild);
powerShellResults.Warnings = ((powerShellResults.Warnings == null) ? new string[]
{
text
} : powerShellResults.Warnings.Concat(new string[]
{
text
}).ToArray <string>());
break;
}
}
}
}
Dictionary <string, ValidatorInfo[]> dictionary2;
IList <string> source;
IList <string> source2;
workflow.LoadMetaData(base.Input, base.Table, base.DataObjectStore, outputVariables, out dictionary2, out source, out source2, base.ProfileBuilder);
powerShellResults.Validators = dictionary2;
powerShellResults.ReadOnlyProperties = source.ToArray <string>();
powerShellResults.NoAccessProperties = source2.ToArray <string>();
powerShellResults.Output = new JsonDictionary <object>[]
{
dictionary
};
goto IL_451;
}
}
ShouldContinueException ex = powerShellResults.ErrorRecords[0].Exception as ShouldContinueException;
if (ex != null)
{
ShouldContinueContext shouldContinueContext = (HttpContext.Current.Items["ShouldContinueContext"] as ShouldContinueContext) ?? new ShouldContinueContext();
if (!shouldContinueContext.CmdletsPrompted.Contains(ex.Details.CurrentCmdlet))
{
shouldContinueContext.CmdletsPrompted.Add(ex.Details.CurrentCmdlet);
}
powerShellResults.ErrorRecords[0].Context = shouldContinueContext;
}
if (!workflow.OutputOnError.IsNullOrEmpty())
{
IEnumerable <DataColumn> columns2 = from DataColumn c in base.Table.Columns
where workflow.OutputOnError.Contains(c.ColumnName)
select c;
Dictionary <string, object> dictionary3;
base.ExtractDataRow(base.Table.Rows[0], columns2, out dictionary3);
if (powerShellResults.ErrorRecords[0].Context == null)
{
powerShellResults.ErrorRecords[0].Context = new ErrorRecordContext();
}
powerShellResults.ErrorRecords[0].Context.LastOuput = dictionary3;
}
IL_451:
DDIHelper.Trace(TraceType.InfoTrace, "Result: ");
DDIHelper.Trace <PowerShellResults <JsonDictionary <object> > >(TraceType.InfoTrace, powerShellResults);
return(powerShellResults);
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
MultiLineLabel multiLineLabel = (MultiLineLabel)base.ContentContainer.FindControl("lblKeywordStatisticsInformation");
Repeater repeater = (Repeater)base.ContentContainer.FindControl("keywordHitsRepeater");
HtmlTableCell htmlTableCell = (HtmlTableCell)base.ContentContainer.FindControl("errorDetailsLink");
PowerShellResults <MailboxSearch> powerShellResults = base.Results as PowerShellResults <MailboxSearch>;
if (powerShellResults != null && powerShellResults.SucceededWithValue)
{
MailboxSearch mailboxSearch = powerShellResults.Output[0];
repeater.DataSource = mailboxSearch.KeywordHits;
repeater.DataBind();
if (string.IsNullOrEmpty(mailboxSearch.Icon))
{
WebControl webControl = (WebControl)base.ContentContainer.FindControl("imgStatus");
webControl.Visible = false;
}
Label label = (Label)base.ContentContainer.FindControl("lblInformation_label");
label.Visible = false;
MultiLineLabel multiLineLabel2 = (MultiLineLabel)base.ContentContainer.FindControl("lblInformation");
multiLineLabel2.Visible = false;
this.HideOrShowKeywordStatisticsPagingUI(false);
string leftPart = this.Context.GetRequestUrl().GetLeftPart(UriPartial.Authority);
string arg = Encoder.UrlEncode(Encoder.HtmlEncode(mailboxSearch.Identity.RawIdentity));
HtmlAnchor htmlAnchor = new HtmlAnchor();
htmlAnchor.InnerHtml = Strings.ViewAllDetails;
string arg2 = string.Format("{0}/ecp/Reporting/ViewMailboxSearchErrors.aspx?Id={1}", leftPart, arg);
htmlAnchor.HRef = "#";
htmlAnchor.Attributes.Add("onclick", string.Format("window.open(\"{0}\",\"popup\",\"width=800,height=600,sscrollbars=yes,resizable=no,toolbar=no,directories=no,location=center,menubar=no,status=yes\"); return false", arg2));
if (htmlTableCell != null && mailboxSearch.TotalKnownErrors + mailboxSearch.TotalUndefinedErrors > 0)
{
htmlTableCell.Controls.Add(htmlAnchor);
}
htmlAnchor.Dispose();
if (mailboxSearch.MailboxSearch.EstimateOnly)
{
if (mailboxSearch.MailboxSearch.Status == SearchState.EstimateInProgress || mailboxSearch.MailboxSearch.Status == SearchState.Queued)
{
repeater.Visible = false;
if (mailboxSearch.MailboxSearch.IncludeKeywordStatistics && !mailboxSearch.MailboxSearch.KeywordStatisticsDisabled)
{
multiLineLabel.Text = Strings.RetrievingStatistics;
}
else
{
Label label2 = (Label)base.ContentContainer.FindControl("lblKeywordStatistics");
label2.Text = string.Empty;
}
}
else
{
LinkButton linkButton = (LinkButton)base.ContentContainer.FindControl("lnkStartFullStatsSearch");
linkButton.Visible = false;
if (mailboxSearch.MailboxSearch.KeywordStatisticsDisabled)
{
Label label3 = (Label)base.ContentContainer.FindControl("lblKeywordStatistics");
label3.Text = string.Empty;
repeater.Visible = false;
label.Visible = true;
multiLineLabel2.Visible = true;
}
else if (mailboxSearch.IsFullStatsSearchAllowed)
{
multiLineLabel.Visible = false;
Label label4 = (Label)base.ContentContainer.FindControl("lblRetrievingStatistics");
label4.Visible = true;
linkButton.OnClientClick = string.Format("MailboxSearchUtil.StartFullStatsMailboxSearchHandler('{0}', '{1}', '{2}', '{3}')", new object[]
{
linkButton.ClientID,
label4.ClientID,
mailboxSearch.Identity.RawIdentity,
HttpUtility.JavaScriptStringEncode(mailboxSearch.Identity.DisplayName)
});
repeater.Visible = false;
linkButton.Visible = true;
}
else if (mailboxSearch.SearchQuery == null || mailboxSearch.SearchQuery == string.Empty)
{
multiLineLabel.Text = Strings.KeywordStatisticsEmptyQuery;
repeater.Visible = false;
}
else
{
if (mailboxSearch.ExcludeDuplicateMessages)
{
multiLineLabel.Text = Strings.DuplicatesNotExcluded;
}
Label label5 = (Label)base.ContentContainer.FindControl("lblKeywordStatisticsPagingInfo");
if (label5 != null)
{
int num = mailboxSearch.StatisticsStartIndex + Math.Min(24, mailboxSearch.TotalKeywords - mailboxSearch.StatisticsStartIndex);
label5.Text = string.Format(Strings.KeywordStatisticsPagingInfo, mailboxSearch.StatisticsStartIndex, num, mailboxSearch.TotalKeywords);
LinkButton linkButton2 = (LinkButton)base.ContentContainer.FindControl("lnkKeywordStatisticsNavigationPrevious");
LinkButton linkButton3 = (LinkButton)base.ContentContainer.FindControl("lnkKeywordStatisticsNavigationNext");
Label label6 = (Label)base.ContentContainer.FindControl("lblRetrievingStatisticsForPaging");
label6.Visible = true;
linkButton2.Enabled = (mailboxSearch.StatisticsStartIndex > 25);
if (linkButton2.Enabled)
{
linkButton2.OnClientClick = string.Format("MailboxSearchUtil.KeywordStatisticsPaginationSearch('{0}', '{1}', '{2}', '{3}', '{4}', {5})", new object[]
{
linkButton2.ClientID,
linkButton3.ClientID,
label6.ClientID,
mailboxSearch.Identity.RawIdentity,
HttpUtility.JavaScriptStringEncode(mailboxSearch.Identity.DisplayName),
mailboxSearch.StatisticsStartIndex - 25
});
}
linkButton3.Enabled = (num < mailboxSearch.TotalKeywords);
if (linkButton3.Enabled)
{
linkButton3.OnClientClick = string.Format("MailboxSearchUtil.KeywordStatisticsPaginationSearch('{0}', '{1}', '{2}', '{3}', '{4}', {5})", new object[]
{
linkButton2.ClientID,
linkButton3.ClientID,
label6.ClientID,
mailboxSearch.Identity.RawIdentity,
HttpUtility.JavaScriptStringEncode(mailboxSearch.Identity.DisplayName),
1 + num
});
}
this.HideOrShowKeywordStatisticsPagingUI(true);
}
}
}
}
else
{
Label label7 = (Label)base.ContentContainer.FindControl("lblKeywordStatistics");
label7.Text = string.Empty;
repeater.Visible = false;
}
if (mailboxSearch.MailboxSearch.PreviewDisabled)
{
label.Visible = true;
multiLineLabel2.Visible = true;
}
this.rowResultMailbox = (HtmlControl)base.ContentContainer.FindControl("rowResultMailbox");
if (this.rowResultMailbox != null)
{
this.rowResultMailbox.Visible = !string.IsNullOrEmpty(mailboxSearch.ResultsLink);
}
if (string.IsNullOrEmpty(mailboxSearch.InPlaceHoldErrors))
{
base.ContentContainer.FindControl("InPlaceHoldErrorLabelContainer").Visible = false;
}
if (!RbacPrincipal.Current.IsInRole("LegalHold"))
{
base.ContentContainer.FindControl("InPlaceHoldSection").Visible = false;
}
if (!RbacPrincipal.Current.IsInRole("MailboxSearch"))
{
base.ContentContainer.FindControl("DiscoverySection").Visible = false;
}
if (string.IsNullOrEmpty(multiLineLabel.Text))
{
multiLineLabel.Visible = false;
}
}
}
private void AddSortDataForAsynchronousGetList(PowerShellResults <JsonDictionary <object> > results, List <JsonDictionary <object> > outputs, IList <string> outputList, List <string> unicodeColumnNames)
{
AsyncGetListContext asyncGetListContext = results.AsyncGetListContext;
if (asyncGetListContext != null)
{
int count = unicodeColumnNames.Count;
if (outputs != null && outputs.Count > 0)
{
if (asyncGetListContext.UnicodeColumns == null)
{
asyncGetListContext.UnicodeColumns = new List <Tuple <int, string[], string> >(Math.Max(outputs.Count, DDIHelper.GetListDefaultResultSize * 4));
}
int m = 0;
int num = asyncGetListContext.UnicodeColumns.Count;
while (m < outputs.Count)
{
Dictionary <string, object> rawDictionary = outputs[m].RawDictionary;
string[] array = new string[count];
for (int j = 0; j < count; j++)
{
array[j] = (string)rawDictionary[unicodeColumnNames[j]];
}
string rawIdentity = ((Identity)rawDictionary["Identity"]).RawIdentity;
asyncGetListContext.UnicodeColumns.Add(new Tuple <int, string[], string>(num, array, rawIdentity));
m++;
num++;
}
if (asyncGetListContext.Completed)
{
WSListDataHandler.< > c__DisplayClassc CS$ < > 8__locals1 = new WSListDataHandler.< > c__DisplayClassc();
List <Tuple <int, string[], string> > unicodeColumns = asyncGetListContext.UnicodeColumns;
results.SortColumnNames = unicodeColumnNames.ToArray();
results.SortDataRawId = new string[unicodeColumns.Count];
for (int k = 0; k < unicodeColumns.Count; k++)
{
results.SortDataRawId[k] = unicodeColumns[k].Item3;
}
results.SortData = new int[unicodeColumnNames.Count][];
CS$ < > 8__locals1.culture = CultureInfo.CurrentCulture;
int i;
for (i = 0; i < unicodeColumnNames.Count; i++)
{
string text = unicodeColumnNames[i];
results.SortData[i] = new int[unicodeColumns.Count];
unicodeColumns.Sort((Tuple <int, string[], string> tuple1, Tuple <int, string[], string> tuple2) => string.Compare(tuple1.Item2[i], tuple2.Item2[i], true, CS$ < > 8__locals1.culture));
int num2 = -1;
Tuple <int, string[], string> tuple = null;
for (int l = 0; l < unicodeColumns.Count; l++)
{
Tuple <int, string[], string> tuple3 = unicodeColumns[l];
if (tuple == null || !string.Equals(tuple.Item2[i], tuple3.Item2[i], StringComparison.CurrentCultureIgnoreCase))
{
num2++;
}
results.SortData[i][tuple3.Item1] = num2;
tuple = tuple3;
}
}
}
}
}
}
