private PowerShellResults <AdminRoleGroupRow> SetRoleAssignments(IEnumerable <Identity> unchangedRoles, ManagementRoleAssignments roleAssignmentsWebService, Identity identity, ManagementScopeRow scopeRow, ExtendedOrganizationalUnit ouRow, PowerShellResults <AdminRoleGroupRow> results) { if ((ouRow != null || scopeRow != null) && unchangedRoles != null) { foreach (Identity roleIdentity in unchangedRoles) { PowerShellResults <ManagementRoleAssignment> roleAssignments = this.GetRoleAssignments(roleIdentity, identity, roleAssignmentsWebService); if (roleAssignments.Failed) { results.MergeErrors <ManagementRoleAssignment>(roleAssignments); return(results); } SetManagementRoleAssignment properties = this.SetScopeInfoInParameter(roleIdentity, null, scopeRow, ouRow, results); if (results.Failed) { return(results); } ManagementRoleAssignment[] output = roleAssignments.Output; foreach (ManagementRoleAssignment managementRoleAssignment in output) { if (managementRoleAssignment.DelegationType == RoleAssignmentDelegationType.Regular) { results.MergeErrors <ManagementRoleAssignment>(roleAssignmentsWebService.SetObject(managementRoleAssignment.Identity, properties)); if (results.Failed) { return(results); } } } } return(results); } return(results); }
public PowerShellResults <DeviceClassPickerObject> GetList(DeviceClassPickerFilter filter, SortOptions sort) { if (!string.IsNullOrEmpty(filter.DeviceType)) { filter.Filter = string.Format("DeviceType -eq '{0}'", filter.DeviceType); } PowerShellResults <DeviceClassPickerObject> list = base.GetList <DeviceClassPickerObject, DeviceClassPickerFilter>("Get-ActiveSyncDeviceClass", filter, sort); if (filter.GroupDeviceType) { List <DeviceClassPickerObject> list2 = new List <DeviceClassPickerObject>(); list2.Add(new DeviceClassPickerObject(DeviceClassPickerObject.AllDeviceTypeQueryString, DeviceClassPickerObject.AllDeviceModelQueryString)); HashSet <string> hashSet = new HashSet <string>(); foreach (DeviceClassPickerObject deviceClassPickerObject in list.Output) { if (!hashSet.Contains(deviceClassPickerObject.DeviceType.QueryString)) { list2.Add(deviceClassPickerObject); hashSet.Add(deviceClassPickerObject.DeviceType.QueryString); } } list.Output = list2.ToArray(); } else if (!string.IsNullOrEmpty(filter.DeviceType)) { List <DeviceClassPickerObject> list3 = new List <DeviceClassPickerObject>(); list3.Add(new DeviceClassPickerObject(new DeviceAccessRuleQueryString { QueryString = filter.DeviceType }, DeviceClassPickerObject.AllDeviceModelQueryString)); list3.AddRange(list.Output); list.Output = list3.ToArray(); } return(list); }
public PowerShellResults <EndUserRoleRow> GetAssignedEndUserRoles(RoleAssignmentPolicyFilter filter, SortOptions sort) { PowerShellResults <RoleAssignmentPolicy> @object = this.GetObject(filter.Policy); PowerShellResults <EndUserRoleRow> powerShellResults = new PowerShellResults <EndUserRoleRow> { ErrorRecords = @object.ErrorRecords, Warnings = @object.Warnings }; if (@object.SucceededWithValue) { EndUserRoles endUserRoles = new EndUserRoles(); powerShellResults.MergeAll(endUserRoles.GetList(null, null)); if (powerShellResults.Succeeded) { List <EndUserRoleRow> list = new List <EndUserRoleRow>(); foreach (EndUserRoleRow endUserRoleRow in powerShellResults.Output) { if (@object.Value.AssignedEndUserRoles.Contains(endUserRoleRow.Identity)) { list.Add(endUserRoleRow); } } powerShellResults.Output = list.ToArray(); } } return(powerShellResults); }
protected override void OnLoad(EventArgs e) { WebServiceReference webServiceReference = new WebServiceReference("~/DDI/DDIService.svc?schema=DisconnectedMailbox&workflow=GetServerDropDown"); try { PowerShellResults <JsonDictionary <object> > list = webServiceReference.GetList(null, null); if (list.Output != null && list.Output.Length > 0) { Microsoft.Exchange.Management.ControlPanel.WebControls.ListView listView = (Microsoft.Exchange.Management.ControlPanel.WebControls.ListView) this.FindControl("disconnectedMailboxListView"); listView.Views = new List <ListItem>(); JsonDictionary <object>[] output = list.Output; for (int i = 0; i < output.Length; i++) { Dictionary <string, object> dictionary = output[i]; listView.Views.Add(new ListItem((string)dictionary["Name"], (string)dictionary["Name"])); } listView.Views.Sort((ListItem item1, ListItem item2) => item1.Text.CompareTo(item2.Text)); } } catch (TargetInvocationException ex) { throw ex.InnerException; } base.OnLoad(e); }
private void DisplayResults <T>(PowerShellResults <T> results) where T : PimSubscription { if (results.Failed) { if (results.ErrorRecords[0].Exception is ManagementObjectNotFoundException) { ErrorHandlingUtil.TransferToErrorPage("liveidmismatch"); return; } if (results.ErrorRecords[0].Exception is ValidateSecretFailureException) { ErrorHandlingUtil.TransferToErrorPage("verificationfailed"); return; } ErrorHandlingUtil.TransferToErrorPage("verificationprocessingerror"); return; } else { if (results.Output.Length == 0) { ErrorHandlingUtil.TransferToErrorPage("verificationprocessingerror"); return; } this.msgText.Text = OwaOptionStrings.VerificationSuccessText(results.Output[0].EmailAddress); base.Title = OwaOptionStrings.VerificationSuccessPageTitle; return; } }
protected PowerShellResults ChangePriority <T>(Identity[] identities, int offset, WebServiceParameters parameters) where T : RuleRow { identities.FaultIfNotExactlyOne(); PowerShellResults <T> @object = base.GetObject <T>("Get-" + this.TaskNoun, identities[0]); if (@object.Failed) { return(@object); } int num = @object.Output[0].Priority + offset; if (num < 0) { return(new PowerShellResults()); } PSCommand pscommand = new PSCommand().AddCommand("Set-" + this.TaskNoun); pscommand.AddParameter("Priority", num); PowerShellResults powerShellResults = base.Invoke(pscommand, identities, parameters); if (powerShellResults.ErrorRecords != null && powerShellResults.ErrorRecords.Length == 1 && powerShellResults.ErrorRecords[0].Exception is InvalidPriorityException) { powerShellResults.ErrorRecords = new ErrorRecord[0]; } return(powerShellResults); }
private PowerShellResults <T> CoreInvoke <T>(PSCommand psCommand, IEnumerable pipelineInput, Identity translationIdentity, WebServiceParameters parameters) { PowerShellResults <T> powerShellResults = psCommand.Invoke(this.runspaceMediator, pipelineInput, parameters); powerShellResults.TranslationIdentity = translationIdentity; return(powerShellResults); }
public PowerShellResults BlockDevice(Identity[] identities, BaseWebServiceParameters parameters) { PowerShellResults powerShellResults = new PowerShellResults(); foreach (Identity identity in identities) { PowerShellResults <MobileDevice> @object = base.GetObject <MobileDevice>("Get-MobileDevice", identity); powerShellResults.MergeErrors <MobileDevice>(@object); if (@object.HasValue) { MobileDevice value = @object.Value; Identity identity2 = value.Id.Parent.Parent.ToIdentity(); PowerShellResults <CASMailbox> object2 = base.GetObject <CASMailbox>("Get-CASMailbox", identity2); powerShellResults.MergeErrors <CASMailbox>(object2); if (object2.HasValue) { MultiValuedProperty <string> activeSyncBlockedDeviceIDs = object2.Value.ActiveSyncBlockedDeviceIDs; if (!activeSyncBlockedDeviceIDs.Contains(value.DeviceId)) { activeSyncBlockedDeviceIDs.Add(value.DeviceId); PSCommand psCommand = new PSCommand().AddCommand("Set-CASMailbox").AddParameter("Identity", identity2).AddParameter("ActiveSyncBlockedDeviceIDs", activeSyncBlockedDeviceIDs); powerShellResults.MergeErrors(base.Invoke(psCommand)); } } } } return(powerShellResults); }
protected override void RenderChanges() { PowerShellResults <AdminAuditLogDetailRow> powerShellResults = base.Results as PowerShellResults <AdminAuditLogDetailRow>; if (powerShellResults != null && powerShellResults.Output != null && powerShellResults.Succeeded && powerShellResults.Output.Length > 0) { Table table = new Table(); int num = 0; while (num < powerShellResults.Output.Length && num < 500) { AdminAuditLogDetailRow adminAuditLogDetailRow = powerShellResults.Output[num]; table.Rows.Add(base.GetDetailRowForTable(string.Format("<b>{0}</b>", Strings.AuditLogDateSDO))); table.Rows.Add(base.GetDetailRowForTable(adminAuditLogDetailRow.AdminAuditLogEvent.RunDate.Value.ToUniversalTime().UtcToUserDateTimeString())); table.Rows.Add(base.GetEmptyRowForTable()); table.Rows.Add(base.GetDetailRowForTable(string.Format("<b>{0}</b>", Strings.AuditLogUserSDO))); table.Rows.Add(base.GetDetailRowForTable(adminAuditLogDetailRow.UserFriendlyCaller)); table.Rows.Add(base.GetEmptyRowForTable()); table.Rows.Add(base.GetDetailRowForTable(string.Format("<b>{0}</b>", Strings.AuditLogCmdletSDO))); table.Rows.Add(base.GetDetailRowForTable(adminAuditLogDetailRow.AdminAuditLogEvent.CmdletName)); table.Rows.Add(base.GetEmptyRowForTable()); table.Rows.Add(base.GetDetailRowForTable(string.Format("<b>{0}</b>", Strings.AuditLogCmdletParameters))); table.Rows.Add(base.GetDetailRowForTable(this.FormatParameters(adminAuditLogDetailRow.AdminAuditLogEvent.CmdletParameters))); table.Rows.Add(base.GetEmptyRowForTable()); num++; } if (table.Rows.Count > 0) { this.detailsPane.Controls.Add(table); return; } table.Dispose(); } }
public PowerShellResults <SmsOptions> SetObject(Identity identity, SetSmsOptions properties) { properties.FaultIfNull(); identity = Identity.FromExecutingUserId(); if (!string.IsNullOrEmpty(properties.VerificationCode)) { PSCommand pscommand = new PSCommand(); pscommand.AddCommand("Compare-TextMessagingVerificationCode"); pscommand.AddParameter("VerificationCode", properties.VerificationCode); PowerShellResults results = base.Invoke(pscommand, new Identity[] { identity }, new BaseWebServiceParameters { ShouldContinue = properties.ShouldContinue }); PowerShellResults <SmsOptions> @object = this.GetObject(identity); @object.MergeErrors(results); return(@object); } if (!string.IsNullOrEmpty(properties.CountryCode) && !string.IsNullOrEmpty(properties.NotificationPhoneNumber) && !properties.NotificationPhoneNumber.StartsWith(properties.CountryCode)) { properties.NotificationPhoneNumber = properties.CountryCode + properties.NotificationPhoneNumber; } return(base.SetObject <SmsOptions, SetSmsOptions>("Set-TextMessagingAccount", identity, properties)); }
public PowerShellResults <MailboxSearchRow> StartSearch(Identity[] identities, StartMailboxSearchParameters parameters) { List <Identity> list = new List <Identity>(); if (parameters != null && parameters.Resume) { list.AddRange(identities); } else { foreach (Identity identity in identities) { PowerShellResults <MailboxSearch> @object = base.GetObject <MailboxSearch>("Get-MailboxSearch", identity); if (@object.Succeeded && @object.HasValue) { if ([email protected][0].IsEstimateOnly) { PSCommand pscommand = new PSCommand().AddCommand("Set-MailboxSearch"); pscommand.AddParameter("Identity", identity); pscommand.AddParameter("EstimateOnly", true); pscommand.AddParameter("ExcludeDuplicateMessages", false); pscommand.AddParameter("LogLevel", LoggingLevel.Suppress); pscommand.AddParameter("Force", true); PowerShellResults powerShellResults = base.Invoke(pscommand); if (!powerShellResults.Succeeded) { break; } } list.Add(identity); } } } return(base.InvokeAndGetObject <MailboxSearchRow>(new PSCommand().AddCommand("Start-MailboxSearch"), list.ToArray(), parameters)); }
internal override bool?IsInRoleCmdlet(ExchangeRunspaceConfiguration rbacConfiguration) { RbacQuery rbacQuery = new RbacQuery("Get-SupervisionPolicy"); if (!rbacQuery.IsInRole(rbacConfiguration)) { return(new bool?(false)); } Supervision supervision = new Supervision(); PowerShellResults <SupervisionStatus> @object = supervision.GetObject(null); if (@object.SucceededWithValue) { foreach (SupervisionStatus supervisionStatus in @object.Output) { if (supervisionStatus.ClosedCampusPolicyEnabled) { return(new bool?(true)); } } return(new bool?(false)); } base.LogCmdletError(@object, "ClosedCampus"); return(null); }
public PowerShellResults <PimSubscriptionRow> ResendImapVerificationEmail(Identity[] identities, BaseWebServiceParameters parameters) { identities.FaultIfNotExactlyOne(); SetImapSubscription setImapSubscription = new SetImapSubscription(); setImapSubscription.ResendVerification = true; PowerShellResults <PimSubscriptionRow> powerShellResults = base.SetObject <ImapSubscription, SetImapSubscription, PimSubscriptionRow>("Set-ImapSubscription", identities[0], setImapSubscription); if (powerShellResults.Succeeded) { ImapSubscriptions imapSubscriptions = new ImapSubscriptions(); PowerShellResults <ImapSubscription> @object = imapSubscriptions.GetObject(identities[0]); if ([email protected]) { throw new FaultException(OwaOptionStrings.SubscriptionProcessingError); } string verificationFeedbackString = @object.Output[0].VerificationFeedbackString; if (verificationFeedbackString != null) { powerShellResults.Informations = new string[] { verificationFeedbackString }; } } return(powerShellResults); }
public PowerShellResults JoinGroups(Identity[] identities) { identities.FaultIfNullOrEmpty(); Identity groupIdentityForTranslation = DistributionGroupServiceBase.GetGroupIdentityForTranslation(identities); PowerShellResults powerShellResults = new PowerShellResults(); int num = 0; int num2 = -1; for (int i = 0; i < identities.Length; i++) { PSCommand psCommand = new PSCommand().AddCommand("Add-DistributionGroupMember").AddParameter("Identity", identities[i]); PowerShellResults powerShellResults2 = base.Invoke(psCommand, groupIdentityForTranslation, null); if (powerShellResults2.SucceededWithoutWarnings) { num++; if (num == 1) { num2 = i; } } powerShellResults.MergeErrors(powerShellResults2); } if (num > 0) { string text = (num == 1) ? OwaOptionStrings.JoinDlSuccess(identities[num2].DisplayName) : ((num == identities.Length) ? OwaOptionStrings.JoinDlsSuccess(num) : OwaOptionStrings.JoinOtherDlsSuccess(num)); powerShellResults.Informations = new string[] { text }; } return(powerShellResults); }
public PowerShellResults <ManagementRoleRow> GetList(ManagementRoleFilter filter, SortOptions sort) { PowerShellResults <ManagementRoleRow> list = base.GetList <ManagementRoleRow, ManagementRoleFilter>("Get-ManagementRole", filter, sort, "Name"); list.Output = Array.FindAll <ManagementRoleRow>(list.Output, (ManagementRoleRow x) => !x.IsEndUserRole); return(list); }
private void SetAddExtensionUrl(PowerShellResults <SetUMMailboxConfiguration> result) { Section section = base.Sections["UMMailboxExtensionSection"]; EcpCollectionEditor ecpCollectionEditor = (EcpCollectionEditor)section.FindControl("ceExtensions"); ecpCollectionEditor.PickerFormUrl = EcpUrl.AppendQueryParameter(ecpCollectionEditor.PickerFormUrl, "dialPlanId", result.Value.DialPlanId); }
public PowerShellResults ProcessRequest(HttpContext context) { Identity identity = Identity.FromIdParameter(context.Request.QueryString["Identity"]); string text = context.Request.QueryString["Name"]; if (identity == null || string.IsNullOrEmpty(identity.RawIdentity)) { throw new BadQueryParameterException("Identity"); } if (string.IsNullOrEmpty(text)) { throw new BadQueryParameterException("Name"); } context.Response.ContentType = "text/csv"; context.Response.AddHeader("Content-Disposition", string.Format("attachment; filename=\"{0}\"", HttpUtility.UrlEncode(text))); Dictionary <string, object> dictionary = new Dictionary <string, object>(); dictionary["CsvStream"] = context.Response.OutputStream; DDIParameters properties = new DDIParameters { Parameters = new JsonDictionary <object>(dictionary) }; IDDIService iddiservice = (IDDIService) new WebServiceReference(EcpUrl.EcpVDirForStaticResource + "DDI/DDIService.svc?schema=MigrationReport&workflow=ExportMigrationReport").ServiceInstance; PowerShellResults powerShellResults = iddiservice.SingleObjectExecute(identity, properties); if (this.IsValidUserError(powerShellResults)) { powerShellResults = new PowerShellResults(); } return(powerShellResults); }
private void SetDynamicLabels(PowerShellResults <SetUMMailboxConfiguration> result) { Section section = base.Sections["UMMailboxConfigurationSection"]; Label label = (Label)section.FindControl("txtExtension_label"); Label label2 = (Label)section.FindControl("lblLockedOutStatusAction"); if (result.Output[0].IsSipDialPlan) { label.Text = Strings.UMMailboxSipLabel; } else if (result.Output[0].IsE164DialPlan) { label.Text = Strings.UMMailboxE164Label; } else { label.Text = Strings.UMMailboxExtensionLabel; } if (result.Output[0].AccountLockedOut) { label2.Style["display"] = "inline"; return; } label2.Style["display"] = "none"; }
protected PowerShellResults <L> SetObject <O, U, L>(string setCmdlet, Identity identity, U properties, Identity identityForGetCmdlet) where O : L where U : SetObjectProperties { EcpPerfCounters.WebServiceSetObject.Increment(); identity.FaultIfNull(); properties.FaultIfNull(); PowerShellResults <L> powerShellResults = new PowerShellResults <L>(); properties.IgnoreNullOrEmpty = false; if (properties.Any <KeyValuePair <string, object> >()) { powerShellResults = this.CoreInvoke <L>(new PSCommand().AddCommand(setCmdlet), identity.ToPipelineInput(), identity, properties); } if (powerShellResults.Succeeded && null != identityForGetCmdlet) { PowerShellResults <L> powerShellResults2 = null; if (properties.ReturnObjectType == ReturnObjectTypes.Full && this is IGetObjectService <O> ) { IGetObjectService <O> getObjectService = this as IGetObjectService <O>; PowerShellResults <O> @object = getObjectService.GetObject(identityForGetCmdlet); powerShellResults2 = new PowerShellResults <L>(); powerShellResults2.MergeOutput(@object.Output.Cast <L>().ToArray <L>()); powerShellResults2.MergeErrors <O>(@object); } else if (properties.ReturnObjectType == ReturnObjectTypes.PartialForList && this is IGetObjectForListService <L> ) { IGetObjectForListService <L> getObjectForListService = this as IGetObjectForListService <L>; powerShellResults2 = getObjectForListService.GetObjectForList(identityForGetCmdlet); } if (powerShellResults2 != null) { powerShellResults.MergeAll(powerShellResults2); } } return(powerShellResults); }
public PowerShellResults <NewUMMailboxConfiguration> GetConfigurationForNewUMMailbox(Identity identity, UMEnableSelectedPolicyParameters properties) { properties.FaultIfNull(); PSCommand pscommand = new PSCommand().AddCommand("Enable-UMMailbox"); pscommand.AddParameter("Identity", identity); pscommand.AddParameter("ValidateOnly"); if (properties.UMMailboxPolicy != null) { pscommand.AddParameter("UMMailboxPolicy", properties.UMMailboxPolicy); } PowerShellResults <NewUMMailboxConfiguration> powerShellResults = base.Invoke <NewUMMailboxConfiguration>(pscommand); if (!powerShellResults.Succeeded) { powerShellResults.ErrorRecords = Array.FindAll <ErrorRecord>(powerShellResults.ErrorRecords, (ErrorRecord x) => !(x.Exception is CouldNotGenerateExtensionException) && !(x.Exception is SipResourceIdAndExtensionsNeededException) && !(x.Exception is E164ResourceIdNeededException)); } if (powerShellResults.SucceededWithValue) { PowerShellResults <UMMailboxPolicy> powerShellResults2 = powerShellResults.MergeErrors <UMMailboxPolicy>(base.GetObject <UMMailboxPolicy>("Get-UMMailboxPolicy", properties.UMMailboxPolicy)); if (powerShellResults2.SucceededWithValue) { powerShellResults.Value.Policy = powerShellResults2.Value; } } return(powerShellResults); }
protected PowerShellResults <L> GetList <L, F>(PSCommand psCommand, F filter, SortOptions sort) where F : WebServiceParameters, new() { EcpPerfCounters.WebServiceGetList.Increment(); Func <L[], L[]> func = (sort != null) ? sort.GetSortFunction <L>() : null; F f; if ((f = filter) == null) { f = Activator.CreateInstance <F>(); } filter = f; PowerShellResults <L> powerShellResults = this.CoreInvoke <L>(psCommand, null, null, filter); if (func != null) { powerShellResults.Output = func(powerShellResults.Output); } ResultSizeFilter resultSizeFilter = filter as ResultSizeFilter; if (resultSizeFilter != null && powerShellResults.HasWarnings) { for (int i = 0; i < powerShellResults.Warnings.Length; i++) { if (powerShellResults.Warnings[i] == Strings.WarningMoreResultsAvailable || powerShellResults.Warnings[i] == Strings.WarningDefaultResultSizeReached(resultSizeFilter.ResultSize.ToString())) { powerShellResults.Warnings[i] = ClientStrings.ListViewMoreResultsWarning; } } } return(powerShellResults); }
protected override void OnLoad(EventArgs e) { string value = this.Context.Request.QueryString["Identity"]; if (string.IsNullOrEmpty(value)) { throw new BadQueryParameterException("Identity"); } if (string.IsNullOrEmpty(this.Context.Request.QueryString["Name"])) { throw new BadQueryParameterException("Name"); } if (string.IsNullOrEmpty(this.Context.Request.QueryString["HandlerClass"])) { throw new BadQueryParameterException("HandlerClass"); } Identity identity = Identity.FromIdParameter(value); WebServiceReference webServiceReference = new WebServiceReference(EcpUrl.EcpVDirForStaticResource + "DDI/DDIService.svc?schema=MigrationReport"); PowerShellResults <JsonDictionary <object> > powerShellResults = (PowerShellResults <JsonDictionary <object> >)webServiceReference.GetObject(identity); if (!powerShellResults.SucceededWithValue) { throw new BadQueryParameterException("Identity"); } if ((MigrationType)powerShellResults.Output[0]["MigrationType"] == MigrationType.BulkProvisioning) { this.OverrideStringsForBulkProvisioning(); } if (this.linkShowReport != null) { this.linkShowReport.NavigateUrl = this.Context.Request.RawUrl.Replace("DownloadReport.aspx?", "Download.aspx?"); } base.OnLoad(e); }
public PowerShellResults <GetVoiceMailConfiguration> SetObject(Identity identity, SetVoiceMailConfiguration properties) { properties.FaultIfNull(); identity = Identity.FromExecutingUserId(); PowerShellResults <GetVoiceMailConfiguration> powerShellResults = new PowerShellResults <GetVoiceMailConfiguration>(); PowerShellResults <GetVoiceMailConfiguration> @object = this.GetObject(identity); powerShellResults.MergeErrors <GetVoiceMailConfiguration>(@object); if (powerShellResults.Failed) { return(powerShellResults); } powerShellResults.MergeErrors <UMMailboxPin>(base.SetObject <UMMailboxPin, SetVoiceMailPIN>("Set-UMMailboxPIN", identity, properties.SetVoiceMailPIN)); if (powerShellResults.Failed) { return(powerShellResults); } properties.ReturnObjectType = ReturnObjectTypes.Full; powerShellResults.MergeAll(base.SetObject <GetVoiceMailConfiguration, SetVoiceMailConfiguration>("Set-UMMailbox", identity, properties)); if (powerShellResults.SucceededWithValue) { GetVoiceMailConfiguration value = powerShellResults.Value; RbacPrincipal.Current.RbacConfiguration.ExecutingUserIsUmConfigured = value.IsConfigured; if (this.IsPhoneVerified(value.PhoneNumber, value) && !string.IsNullOrEmpty(properties.PhoneProviderId)) { PowerShellResults <SmsOptions> results = this.SetTextMessagingAccount(identity, value.PhoneNumber, value.PhoneProviderId, value); powerShellResults.MergeErrors <SmsOptions>(results); } } return(powerShellResults); }
private static PowerShellResults <T> GetProgressImpl <T>(string progressId, out AsyncServiceManager.WorkItem workItem) { PowerShellResults <T> powerShellResults = new PowerShellResults <T>(); workItem = null; if (!string.IsNullOrEmpty(progressId) && AsyncServiceManager.workItems.TryGetValue(progressId, out workItem)) { lock (workItem) { if (workItem.Results != null) { PowerShellResults <T> powerShellResults2 = workItem.Results as PowerShellResults <T>; if (powerShellResults2 != null) { powerShellResults = powerShellResults2; } else { powerShellResults.MergeErrors(workItem.Results); } AsyncServiceManager.workItems.Remove(progressId); workItem.FinishedEvent.Close(); } else { ProgressRecord progressRecord = null; if (workItem.LegacyProgressRecord != null) { progressRecord = workItem.LegacyProgressRecord; } else { ProgressRecord progressRecord2 = (workItem.ProgressCalculator == null) ? new ProgressRecord() : workItem.ProgressCalculator.ProgressRecord; lock (progressRecord2.SyncRoot) { progressRecord = new ProgressRecord { Errors = progressRecord2.Errors, FailedCount = progressRecord2.FailedCount, MaxCount = progressRecord2.MaxCount, Percent = progressRecord2.Percent, Status = progressRecord2.Status, SucceededCount = progressRecord2.SucceededCount, HasCompleted = progressRecord2.HasCompleted, IsCancelled = progressRecord2.IsCancelled }; progressRecord2.Errors = null; } } powerShellResults.ProgressRecord = progressRecord; } } } DDIHelper.Trace("GetProgress: {0}, Results: {1}", new object[] { progressId, powerShellResults }); return(powerShellResults); }
public PowerShellResults <EndUserRoleRow> GetList(ManagementRoleFilter filter, SortOptions sort) { PowerShellResults <EndUserRoleRow> list = base.GetList <EndUserRoleRow, ManagementRoleFilter>("Get-ManagementRole", filter, sort); if (!list.Succeeded) { return(list); } list.Output = Array.FindAll <EndUserRoleRow>(list.Output, (EndUserRoleRow x) => x.IsEndUserRole); if (Util.IsDataCenter && filter != null && filter.Policy != null) { PowerShellResults <RoleAssignmentPolicy> result = EndUserRoles.policyService.GetObject(filter.Policy); if (result.HasValue) { bool flag = (from role in list.Output where !string.IsNullOrEmpty(role.MailboxPlanIndex) select role).Count <EndUserRoleRow>() > 0; if (flag) { list.Output = (from role in list.Output where string.IsNullOrEmpty(role.MailboxPlanIndex) || role.MailboxPlanIndex == result.Value.MailboxPlanIndex select role).ToArray <EndUserRoleRow>(); } } else { list.Output = new EndUserRoleRow[0]; } } return(list); }
public PowerShellResults <AdminAuditLogResultRow> GetList(ExternalAccessFilter filter, SortOptions sort) { filter.ExternalAccess = new bool?(true); PowerShellResults <AdminAuditLogResultRow> list = base.GetList <AdminAuditLogResultRow, ExternalAccessFilter>("Search-AdminAuditLog", filter, sort); if (list.Succeeded) { PowerShellResults <AdminAuditLogResultRow> powerShellResults = new PowerShellResults <AdminAuditLogResultRow>(); int num = list.Output.Length; AdminAuditLogResultRow[] array = new AdminAuditLogResultRow[num]; for (int i = 0; i < num; i++) { string text = string.Format("{0};{1};{2};{3}", new object[] { list.Output[i].AuditReportSearchBaseResult.ObjectModified, list.Output[i].AuditReportSearchBaseResult.CmdletName, filter.StartDate, filter.EndDate }); Identity id = new Identity(text, text); array[i] = new AdminAuditLogResultRow(id, list.Output[i].AuditReportSearchBaseResult); } powerShellResults.Output = array; return(powerShellResults); } return(list); }
public PowerShellResults <ImportContactsResult> ImportObject(Identity identity, ImportContactListParameters properties) { PowerShellResults <ImportContactsResult> powerShellResults = base.SetObject <ImportContactsResult, ImportContactListParameters>("Import-ContactList", identity, properties); bool succeeded = powerShellResults.Succeeded; return(powerShellResults); }
protected override void RenderChanges() { PowerShellResults <AdminAuditLogDetailRow> powerShellResults = base.Results as PowerShellResults <AdminAuditLogDetailRow>; if (powerShellResults != null && powerShellResults.Output != null && powerShellResults.Succeeded && powerShellResults.Output.Length > 0) { Table table = new Table(); int num = 0; while (num < powerShellResults.Output.Length && num < 500) { AdminAuditLogDetailRow adminAuditLogDetailRow = powerShellResults.Output[num]; foreach (AdminAuditLogCmdletParameter adminAuditLogCmdletParameter in adminAuditLogDetailRow.AdminAuditLogEvent.CmdletParameters) { if (adminAuditLogCmdletParameter.Name.Equals("LitigationHoldEnabled", StringComparison.InvariantCultureIgnoreCase)) { table.Rows.Add(base.GetDetailRowForTable(adminAuditLogDetailRow.AdminAuditLogEvent.RunDate.Value.ToUniversalTime().UtcToUserDateTimeString())); table.Rows.Add(base.GetDetailRowForTable(adminAuditLogDetailRow.UserFriendlyCaller)); table.Rows.Add(base.GetDetailRowForTable(this.GetLocalizedState(adminAuditLogCmdletParameter.Value))); table.Rows.Add(base.GetEmptyRowForTable()); break; } } num++; } if (table.Rows.Count > 0) { this.detailsPane.Controls.Add(table); return; } table.Dispose(); } }
public PowerShellResults <RoleAssignmentPolicyRow> SetObject(Identity identity, SetRoleAssignmentPolicy properties) { properties.FaultIfNull(); PowerShellResults <RoleAssignmentPolicyRow> powerShellResults; if (!string.IsNullOrEmpty(properties.Name) || !string.IsNullOrEmpty(properties.Description)) { powerShellResults = base.SetObject <RoleAssignmentPolicyRow, SetRoleAssignmentPolicy>("Set-RoleAssignmentPolicy", identity, properties); } else { powerShellResults = base.GetObject <RoleAssignmentPolicyRow>("Get-RoleAssignmentPolicy", identity); } if (!powerShellResults.SucceededWithValue) { powerShellResults.Output = null; return(powerShellResults); } PowerShellResults <RoleAssignmentPolicy> @object = this.GetObject(identity); if (@object.SucceededWithValue && properties.AssignedEndUserRoles != null) { this.UpdateRoleAssignments(@object, properties); } if ([email protected]) { powerShellResults.MergeErrors <RoleAssignmentPolicy>(@object); powerShellResults.Output = null; } return(powerShellResults); }
private PowerShellResults <AdminRoleGroupRow> RemoveRoleAssignments(IEnumerable <Identity> removedRoles, ManagementRoleAssignments roleAssignmentsWebService, Identity identity, PowerShellResults <AdminRoleGroupRow> results) { if (removedRoles != null) { foreach (Identity roleIdentity in removedRoles) { PowerShellResults <ManagementRoleAssignment> roleAssignments = this.GetRoleAssignments(roleIdentity, identity, roleAssignmentsWebService); if (roleAssignments.Failed) { results.MergeErrors <ManagementRoleAssignment>(roleAssignments); return(results); } if (roleAssignments != null && roleAssignments.Output != null) { ManagementRoleAssignment[] output = roleAssignments.Output; IEnumerable <Identity> source = from entry in output where entry.DelegationType == RoleAssignmentDelegationType.Regular select entry.Identity; results.MergeErrors(roleAssignmentsWebService.RemoveObjects(source.ToArray <Identity>(), null)); if (results.Failed) { return(results); } } } return(results); } return(results); }