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; } } } } } }