protected override void WriteResult(IConfigurable dataObject) { RoleAssignmentPolicy roleAssignmentPolicy = (RoleAssignmentPolicy)dataObject; Result <ExchangeRoleAssignment>[] roleAssignmentResults; if (base.SharedConfiguration != null) { SharedConfiguration sharedConfiguration = base.SharedConfiguration; IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(true, ConsistencyMode.PartiallyConsistent, sharedConfiguration.GetSharedConfigurationSessionSettings(), 553, "WriteResult", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\MailboxPolicies\\RoleAssignmentPolicyTasks.cs"); roleAssignmentResults = tenantOrTopologyConfigurationSession.FindRoleAssignmentsByUserIds(new ADObjectId[] { sharedConfiguration.GetSharedRoleAssignmentPolicy() }, false); roleAssignmentPolicy.SharedConfiguration = sharedConfiguration.SharedConfigurationCU.Id; } else { roleAssignmentResults = this.ConfigurationSession.FindRoleAssignmentsByUserIds(new ADObjectId[] { roleAssignmentPolicy.Id }, false); } roleAssignmentPolicy.PopulateRoles(roleAssignmentResults); base.WriteResult(roleAssignmentPolicy); }
protected override void InternalProcessRecord() { LazilyInitialized <SharedTenantConfigurationState> currentOrgState = this.CurrentOrgState; OrganizationId currentOrganizationId = base.CurrentOrganizationId; TDataObject dataObject = base.DataObject; if (!currentOrganizationId.Equals(dataObject.OrganizationId)) { currentOrgState = new LazilyInitialized <SharedTenantConfigurationState>(delegate() { TDataObject dataObject3 = base.DataObject; return(SharedConfiguration.GetSharedConfigurationState(dataObject3.OrganizationId)); }); } if (SharedConfigurationTaskHelper.ShouldPrompt(this, this.SharedTenantConfigurationMode, currentOrgState) && !base.InternalForce) { TDataObject dataObject2 = base.DataObject; if (!base.ShouldContinue(Strings.ConfirmSharedConfiguration(dataObject2.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } } base.InternalProcessRecord(); }
public DataClassificationConfig GetDataClassificationConfig(OrganizationId organizationId, IConfigurationSession currentDataSession) { if (object.ReferenceEquals(null, organizationId)) { throw new ArgumentNullException("organizationId"); } if (currentDataSession == null) { throw new ArgumentNullException("currentDataSession"); } if (!VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled || OrganizationId.ForestWideOrgId.Equals(organizationId)) { return(null); } if (!organizationId.Equals(currentDataSession.SessionSettings.CurrentOrganizationId)) { throw new ArgumentException(new ArgumentException().Message, "currentDataSession"); } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(organizationId); IConfigurationSession configurationSession; if (sharedConfiguration != null) { configurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(true, ConsistencyMode.PartiallyConsistent, sharedConfiguration.GetSharedConfigurationSessionSettings(), 1186, "GetDataClassificationConfig", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\transport\\ClassificationDefinitions\\ClassificationDefinitionUtils.cs"); } else { configurationSession = currentDataSession; } DataClassificationConfig[] array = configurationSession.Find <DataClassificationConfig>(null, QueryScope.SubTree, null, null, 1); ExAssert.RetailAssert(array != null && 1 == array.Length, "There should be one and only one DataClassificationConfig applicable to a particular tenant."); return(array[0]); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } if (this.updateOtherDefaultPolicies) { if (!base.ShouldContinue(Strings.ConfirmationMessageSwitchMailboxPolicy("OWAMailboxPolicy", this.Identity.ToString()))) { return; } try { DefaultMailboxPolicyUtility <OwaMailboxPolicy> .ClearDefaultPolicies(base.DataSession as IConfigurationSession, this.otherDefaultPolicies); } catch (DataSourceTransientException exception) { base.WriteError(exception, ErrorCategory.ReadError, null); } } if (base.Fields.IsChanged("DisableFacebook") && this.DisableFacebook) { this.DataObject.FacebookEnabled = false; } base.InternalProcessRecord(); TaskLogger.LogExit(); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (this.DataObject != null && SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } if (this.updateExistingDefaultPolicies) { if (!base.ShouldContinue(Strings.ConfirmationMessageSwitchMailboxPolicy("RetentionPolicy", this.DataObject.Name))) { return; } try { RetentionPolicyUtility.ClearDefaultPolicies(base.DataSession as IConfigurationSession, this.existingDefaultPolicies, this.IsDefaultArbitrationMailbox); } catch (DataSourceTransientException exception) { base.WriteError(exception, ErrorCategory.ReadError, null); } } base.InternalProcessRecord(); TaskLogger.LogExit(); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (!this.Force && SharedConfiguration.IsSharedConfiguration(base.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(base.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } ADPagedReader <ADRawEntry> adpagedReader = this.ConfigurationSession.FindPagedADRawEntryWithDefaultFilters <ExchangeRole>(base.DataObject.Id, this.Recurse ? QueryScope.SubTree : QueryScope.Base, new ExistsFilter(ExchangeRoleSchema.RoleAssignments), null, 0, new PropertyDefinition[] { ADObjectSchema.Id, ExchangeRoleSchema.RoleAssignments }); foreach (ADRawEntry adrawEntry in adpagedReader) { base.WriteError(new InvalidOperationException(Strings.ErrorCannotDeleteRoleWithAssignment(adrawEntry.Id.ToString())), ErrorCategory.InvalidOperation, base.DataObject.Id); } if (this.Recurse) { ((IConfigurationSession)base.DataSession).DeleteTree(base.DataObject, new TreeDeleteNotFinishedHandler(this.ReportDeleteTreeProgress)); } else { base.InternalProcessRecord(); } TaskLogger.LogExit(); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (!this.Force && SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } IConfigurationSession configurationSession = null; base.InternalProcessRecord(); if (this.WellKnownObjectGuid != Guid.Empty || this.roleAssignments != null) { configurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(null, false, ConsistencyMode.PartiallyConsistent, base.SessionSettings, 676, "InternalProcessRecord", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\RBAC\\RoleGroup\\NewRoleGroup.cs"); configurationSession.LinkResolutionServer = this.DataObject.OriginatingServer; } if (this.WellKnownObjectGuid != Guid.Empty) { try { RoleGroupCommon.StampWellKnownObjectGuid(configurationSession, this.DataObject.OrganizationId, this.DataObject.DistinguishedName, this.WellKnownObjectGuid); } catch (Exception) { this.DataObject.ExternalDirectoryObjectId = null; base.DataSession.Save(this.DataObject); base.DataSession.Delete(this.DataObject); throw; } } if (this.roleAssignments != null) { List <ExchangeRoleAssignment> list = new List <ExchangeRoleAssignment>(); string id = string.Empty; try { foreach (ExchangeRoleAssignment exchangeRoleAssignment in this.roleAssignments) { exchangeRoleAssignment.User = this.DataObject.Id; id = exchangeRoleAssignment.Id.Name; configurationSession.Save(exchangeRoleAssignment); list.Add(exchangeRoleAssignment); } } catch (Exception) { this.WriteWarning(Strings.WarningCouldNotCreateRoleAssignment(id, this.Name)); foreach (ExchangeRoleAssignment exchangeRoleAssignment2 in list) { base.WriteVerbose(Strings.VerboseRemovingRoleAssignment(exchangeRoleAssignment2.Id.ToString())); configurationSession.Delete(exchangeRoleAssignment2); base.WriteVerbose(Strings.VerboseRemovedRoleAssignment(exchangeRoleAssignment2.Id.ToString())); } base.WriteVerbose(Strings.VerboseRemovingRoleGroup(this.DataObject.Id.ToString())); base.DataSession.Delete(this.DataObject); throw; } } TaskLogger.LogExit(); }
private void FillTaskPopulatedFields(ADOrganizationConfig organization) { RbacContainer rbacContainer = null; if (OrganizationId.ForestWideOrgId.Equals(organization.OrganizationId)) { rbacContainer = this.ConfigurationSession.GetRbacContainer(); } else { ExchangeConfigurationUnit exchangeConfigurationUnit = this.ConfigurationSession.GetOrgContainer() as ExchangeConfigurationUnit; if (exchangeConfigurationUnit != null) { organization.ServicePlan = exchangeConfigurationUnit.ServicePlan; organization.TargetServicePlan = exchangeConfigurationUnit.TargetServicePlan; if (exchangeConfigurationUnit.IsStaticConfigurationShared) { SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(organization.OrganizationId); rbacContainer = sharedConfiguration.GetRbacContainer(); } else { rbacContainer = this.ConfigurationSession.GetRbacContainer(); } } } if (rbacContainer != null) { organization.RBACConfigurationVersion = rbacContainer.ExchangeVersion; } }
static async Task AsyncMain() { var defaultFactory = LogManager.Use <DefaultFactory>(); defaultFactory.Level(LogLevel.Warn); Console.Title = "Samples.RenameSaga.Version2"; Console.WriteLine("Renaming SQL tables:"); Console.WriteLine(" from Samples_RenameSaga_MyReplySagaVersion1 to Samples_RenameSaga_MyReplySagaVersion2"); Console.WriteLine(" from Samples_RenameSaga_MyTimeoutSagaVersion1 to Samples_RenameSaga_MyTimeoutSagaVersion2"); #region renameTables var connectionString = @"Data Source=.\SqlExpress;Initial Catalog=Samples.SqlPersistence.RenameSaga;Integrated Security=True"; using (var connection = new SqlConnection(connectionString)) { await connection.OpenAsync() .ConfigureAwait(false); using (var command = connection.CreateCommand()) { command.CommandText = "exec sp_rename 'Samples_RenameSaga_MyReplySagaVersion1', 'Samples_RenameSaga_MyReplySagaVersion2'"; await command.ExecuteNonQueryAsync() .ConfigureAwait(false); } using (var command = connection.CreateCommand()) { command.CommandText = "exec sp_rename 'Samples_RenameSaga_MyTimeoutSagaVersion1', 'Samples_RenameSaga_MyTimeoutSagaVersion2'"; await command.ExecuteNonQueryAsync() .ConfigureAwait(false); } } #endregion var endpointConfiguration = new EndpointConfiguration("Samples.RenameSaga"); await SharedConfiguration.Apply(endpointConfiguration) .ConfigureAwait(false); #region registerMutator endpointConfiguration.RegisterComponents( registration: components => { components.ConfigureComponent <ReplyMutator>(DependencyLifecycle.InstancePerCall); }); #endregion var endpointInstance = await Endpoint.Start(endpointConfiguration) .ConfigureAwait(false); Console.WriteLine("Waiting to receive timeout and reply. Should happen withing 10 seconds"); Console.WriteLine("Press any key to exit"); Console.ReadKey(); await endpointInstance.Stop() .ConfigureAwait(false); }
protected override void InternalValidate() { base.InternalValidate(); if (SharedConfiguration.IsDehydratedConfiguration(base.CurrentOrganizationId)) { base.WriteError(new ArgumentException(Strings.ErrorWriteOpOnDehydratedTenant), ErrorCategory.InvalidArgument, base.DataObject.Identity); } }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } if (this.DataObject.IsConflicted()) { base.WriteError(new OperationNotAllowedException(Strings.ConflictedPolicyUpdateNotAllowed), ErrorCategory.InvalidOperation, this.DataObject.Identity); } MalwareFilterPolicy malwareFilterPolicy = null; if (this.MakeDefault && !this.DataObject.IsDefault) { this.DataObject.IsDefault = true; malwareFilterPolicy = this.GetDefaultMalwareFilterPolicy(); if (malwareFilterPolicy != null && malwareFilterPolicy.IsDefault) { malwareFilterPolicy.IsDefault = false; base.DataSession.Save(malwareFilterPolicy); } } else if (base.Fields.Contains("MakeDefault") && !this.MakeDefault && this.DataObject.IsDefault) { MalwareFilterPolicy[] allDefaultMalwareFilterPolicies = this.GetAllDefaultMalwareFilterPolicies(); if (allDefaultMalwareFilterPolicies.Length > 1 && !this.DataObject.IsConflicted()) { foreach (MalwareFilterPolicy malwareFilterPolicy2 in allDefaultMalwareFilterPolicies) { if (malwareFilterPolicy2.IsConflicted()) { malwareFilterPolicy2.IsDefault = false; base.DataSession.Save(malwareFilterPolicy2); } } } else { base.WriteError(new OperationNotAllowedException(Strings.OperationNotAllowed), ErrorCategory.InvalidOperation, this.MakeDefault); } } try { base.InternalProcessRecord(); malwareFilterPolicy = null; } finally { if (malwareFilterPolicy != null) { malwareFilterPolicy.IsDefault = true; base.DataSession.Save(malwareFilterPolicy); } } TaskLogger.LogExit(); }
static async Task Main() { //required to prevent possible occurrence of .NET Core issue https://github.com/dotnet/coreclr/issues/12668 Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); var defaultFactory = LogManager.Use <DefaultFactory>(); defaultFactory.Level(LogLevel.Warn); Console.Title = "Samples.RenameSaga.Version2"; Console.WriteLine("Renaming SQL tables:"); Console.WriteLine(" from Samples_RenameSaga_MyReplySagaVersion1 to Samples_RenameSaga_MyReplySagaVersion2"); Console.WriteLine(" from Samples_RenameSaga_MyTimeoutSagaVersion1 to Samples_RenameSaga_MyTimeoutSagaVersion2"); #region renameTables var connectionString = @"Data Source=.\SqlExpress;Initial Catalog=NsbSamplesSqlPersistenceRenameSaga;Integrated Security=True"; using (var connection = new SqlConnection(connectionString)) { await connection.OpenAsync() .ConfigureAwait(false); using (var command = connection.CreateCommand()) { command.CommandText = "exec sp_rename 'Samples_RenameSaga_MyReplySagaVersion1', 'Samples_RenameSaga_MyReplySagaVersion2'"; await command.ExecuteNonQueryAsync() .ConfigureAwait(false); } using (var command = connection.CreateCommand()) { command.CommandText = "exec sp_rename 'Samples_RenameSaga_MyTimeoutSagaVersion1', 'Samples_RenameSaga_MyTimeoutSagaVersion2'"; await command.ExecuteNonQueryAsync() .ConfigureAwait(false); } } #endregion var endpointConfiguration = new EndpointConfiguration("Samples.RenameSaga"); SharedConfiguration.Apply(endpointConfiguration); #region registerMutator endpointConfiguration.RegisterMessageMutator(new ReplyMutator()); #endregion var endpointInstance = await Endpoint.Start(endpointConfiguration) .ConfigureAwait(false); Console.WriteLine("Waiting to receive timeout and reply. Should happen within 10 seconds"); Console.WriteLine("Press any key to exit"); Console.ReadKey(); await endpointInstance.Stop() .ConfigureAwait(false); }
internal static RoleGroup PopulateRoleAssignmentsAndConvert(ADGroup group, IConfigurationSession configurationSession) { Result <ExchangeRoleAssignment>[] roleAssignmentResults = null; if (RoleGroup.ContainsRoleAssignments(group)) { return(new RoleGroup(group, roleAssignmentResults)); } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(group.OrganizationId); RoleGroup roleGroup; if (sharedConfiguration != null) { if (group.RoleGroupType == RoleGroupType.PartnerLinked) { roleGroup = new RoleGroup(group, null); } else { ADObjectId sharedConfiguration2 = null; ADObjectId[] sharedRoleGroupIds; if (group.IsModified(ADObjectSchema.Name)) { sharedRoleGroupIds = sharedConfiguration.GetSharedRoleGroupIds(new ADObjectId[] { group.OriginalId }); } else { sharedRoleGroupIds = sharedConfiguration.GetSharedRoleGroupIds(new ADObjectId[] { group.Id }); } if (sharedRoleGroupIds != null && sharedRoleGroupIds.Length != 0) { IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.PartiallyConsistent, sharedConfiguration.GetSharedConfigurationSessionSettings(), 171, "PopulateRoleAssignmentsAndConvert", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\RBAC\\RoleGroup\\RoleGroupCommon.cs"); roleAssignmentResults = tenantOrTopologyConfigurationSession.FindRoleAssignmentsByUserIds(new ADObjectId[] { sharedRoleGroupIds[0] }, false); sharedConfiguration2 = sharedConfiguration.SharedConfigurationCU.Id; } roleGroup = new RoleGroup(group, roleAssignmentResults); roleGroup.SharedConfiguration = sharedConfiguration2; } } else { configurationSession.SessionSettings.IsSharedConfigChecked = true; roleAssignmentResults = configurationSession.FindRoleAssignmentsByUserIds(new ADObjectId[] { group.Id }, false); roleGroup = new RoleGroup(group, roleAssignmentResults); } return(roleGroup); }
protected override void InternalBeginProcessing() { TaskLogger.LogEnter(); base.InternalBeginProcessing(); if (this.SharedTenantConfigurationMode == SharedTenantConfigurationMode.Static || (this.SharedTenantConfigurationMode == SharedTenantConfigurationMode.Dehydrateable && SharedConfiguration.IsDehydratedConfiguration(base.CurrentOrganizationId))) { this.sharedConfig = SharedConfiguration.GetSharedConfiguration(base.CurrentOrganizationId); } TaskLogger.LogExit(); }
/// <summary> /// Gets the validation errors for a specified property or for the entire entity. /// </summary> /// <param name="propertyName"> /// The name of the property to retrieve validation errors for; or <see cref="String.Empty"/>, /// to retrieve entity-level errors. /// </param> /// <returns>The validation errors for the property or entity.</returns> public override IEnumerable GetErrors(string propertyName) { string sharedPropertyName; if (propertyName != null && SharedPropertiesMapping.TryGetKey(propertyName, out sharedPropertyName)) { return(SharedConfiguration.GetErrors(sharedPropertyName)); } return(base.GetErrors(propertyName)); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (!this.Force && SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } base.InternalProcessRecord(); TaskLogger.LogExit(); }
public void ValidateIsSafeToRemoveRoleGroupMember(ADGroup group, List <ADObjectId> membersToRemove) { if (group == null || membersToRemove == null) { return; } this.InitializeContextVariables(); this.excludedFromEmptinessValidation.AddRange(membersToRemove); this.excludedFromAssignmentSearch.Add(group.Id); if (!this.IsGroupEmpty(group)) { return; } this.excludedFromEmptinessValidation.Add(group.Id); string membersToRemove2 = RoleGroupCommon.NamesFromObjects(membersToRemove); bool flag = RoleGroupCommon.IsPrecannedRoleGroup(group, this.configurationSession, new Guid[] { RoleGroup.OrganizationManagement_InitInfo.WellKnownGuid }); if (flag) { this.writeError(new TaskInvalidOperationException(Strings.ErrorCannedRoleGroupCannotBeEmpty(group.Name, membersToRemove2)), ExchangeErrorCategory.Client, null); } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(group.OrganizationId); if (sharedConfiguration != null) { return; } Result <ExchangeRoleAssignment>[] directRoleAssignmentsForGroup = this.GetDirectRoleAssignmentsForGroup(group); if (directRoleAssignmentsForGroup != null) { foreach (Result <ExchangeRoleAssignment> result in directRoleAssignmentsForGroup) { if (!this.IsSafeToRemoveDisableAssignmentFromGroup(result.Data)) { this.writeError(new TaskInvalidOperationException(Strings.ErrorGroupCannotBeEmptyRoleAssignmentConstraint(group.Name, membersToRemove2, result.Data.Name, result.Data.Role.Name)), ExchangeErrorCategory.Client, null); } } } ExchangeRoleAssignment exchangeRoleAssignment; if (!this.HierarchicalCheckForGroupEmptiness(group, out exchangeRoleAssignment)) { this.writeError(new TaskInvalidOperationException(Strings.ErrorGroupCannotBeEmptyRoleAssignmentConstraint(group.Name, membersToRemove2, exchangeRoleAssignment.Name, exchangeRoleAssignment.Role.Name)), ExchangeErrorCategory.Client, null); } ADGroup adgroup = null; if (!this.HierarchicalCheckForCannedRoleGroups(group, out adgroup)) { this.writeError(new TaskInvalidOperationException(Strings.ErrorCannedRoleGroupCannotBeEmpty(adgroup.Name, membersToRemove2)), ExchangeErrorCategory.Client, null); } }
public bool DoAllCoreSCTsExistForVersion(ServerVersion version, PartitionId partitionId) { foreach (string offerId in this.coreOffers) { new SharedConfigurationInfo(version, "MSOnline", offerId); if (!SharedConfiguration.DoesSctExistForVersion(version, "MSOnline", offerId, partitionId)) { return(false); } } return(true); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (SharedConfiguration.IsSharedConfiguration(base.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(base.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } base.InternalProcessRecord(); FfoDualWriter.DeleteFromFfo <HostedConnectionFilterPolicy>(this, base.DataObject); TaskLogger.LogExit(); }
// Token: 0x06001113 RID: 4371 RVA: 0x000635C4 File Offset: 0x000617C4 protected override Dictionary <Guid, OrganizationId> GetTenantsNeedingGrammars(List <ADUser> systemMailboxes) { UMTracer.DebugTrace("DatacenterUMGrammarTenantCache.GetTenantsNeedingGrammars", new object[0]); Dictionary <Guid, OrganizationId> dictionary = new Dictionary <Guid, OrganizationId>(); foreach (ADUser aduser in systemMailboxes) { if (aduser.OrganizationId != null && aduser.OrganizationId.ConfigurationUnit != null && aduser.OrganizationId.OrganizationalUnit != null) { if (SharedConfiguration.IsSharedConfiguration(aduser.OrganizationId)) { UMTracer.DebugTrace("Skipping Mbox='{0}', Organization='{1}' because it is a shared configuration", new object[] { aduser.ExchangeGuid, aduser.OrganizationId }); } else { IADRecipientLookup iadrecipientLookup = ADRecipientLookupFactory.CreateFromOrganizationId(aduser.OrganizationId, null); if (iadrecipientLookup.TenantSizeExceedsThreshold(GrammarRecipientHelper.GetUserFilter(), 10)) { if (!dictionary.ContainsKey(aduser.ExchangeGuid)) { UMTracer.DebugTrace("Adding Mbox='{0}', Organization='{1}'", new object[] { aduser.ExchangeGuid, aduser.OrganizationId }); dictionary.Add(aduser.ExchangeGuid, aduser.OrganizationId); } else { UMTracer.DebugTrace("Skipping Mbox='{0}', Organization='{1}' because Mbox is already included. ", new object[] { aduser.ExchangeGuid, aduser.OrganizationId }); } } else { UMTracer.DebugTrace("Skipping Mbox='{0}', Organization='{1}' because it does not exceed size threshold", new object[] { aduser.ExchangeGuid, aduser.OrganizationId }); } } } } return(dictionary); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } base.InternalProcessRecord(); this.dualWriter.Save <HostedOutboundSpamFilterPolicy>(this, this.DataObject); TaskLogger.LogExit(); }
protected override void InternalValidate() { base.InternalValidate(); if (SharedConfiguration.IsDehydratedConfiguration(base.CurrentOrganizationId)) { base.WriteError(new ArgumentException(Strings.ErrorWriteOpOnDehydratedTenant), ErrorCategory.InvalidArgument, base.DataObject.Identity); } if (base.DataObject.IsDefault || base.DataObject.IsDefaultArbitrationMailbox) { base.WriteError(new InvalidOperationException(Strings.RemovingDefaultPolicyIsNotSupported(this.Identity.ToString())), ErrorCategory.WriteError, base.DataObject); } }
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject) { if (dataObject == null) { return(null); } ADUser user = (ADUser)dataObject; SharedConfiguration sharedConfig = null; if (SharedConfiguration.IsDehydratedConfiguration(user.OrganizationId) || (SharedConfiguration.GetSharedConfigurationState(user.OrganizationId) & SharedTenantConfigurationState.Static) != SharedTenantConfigurationState.UnSupported) { sharedConfig = base.ProvisioningCache.TryAddAndGetOrganizationData <SharedConfiguration>(CannedProvisioningCacheKeys.MailboxSharedConfigCacheKey, user.OrganizationId, () => SharedConfiguration.GetSharedConfiguration(user.OrganizationId)); } if (null != user.MasterAccountSid) { user.LinkedMasterAccount = SecurityPrincipalIdParameter.GetFriendlyUserName(user.MasterAccountSid, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose)); user.ResetChangeTracking(); } Mailbox mailbox = new Mailbox(user); mailbox.propertyBag.SetField(MailboxSchema.Database, ADObjectIdResolutionHelper.ResolveDN(mailbox.Database)); if (sharedConfig != null) { mailbox.SharedConfiguration = sharedConfig.SharedConfigId.ConfigurationUnit; if (mailbox.RoleAssignmentPolicy == null) { mailbox.RoleAssignmentPolicy = base.ProvisioningCache.TryAddAndGetOrganizationData <ADObjectId>(CannedProvisioningCacheKeys.MailboxRoleAssignmentPolicyCacheKey, user.OrganizationId, () => sharedConfig.GetSharedRoleAssignmentPolicy()); } } else if (mailbox.RoleAssignmentPolicy == null && !mailbox.ExchangeVersion.IsOlderThan(MailboxSchema.RoleAssignmentPolicy.VersionAdded)) { ADObjectId defaultRoleAssignmentPolicy = RBACHelper.GetDefaultRoleAssignmentPolicy(user.OrganizationId); if (defaultRoleAssignmentPolicy != null) { mailbox.RoleAssignmentPolicy = defaultRoleAssignmentPolicy; } } if (mailbox.SharingPolicy == null && !mailbox.propertyBag.IsReadOnlyProperty(MailboxSchema.SharingPolicy)) { mailbox.SharingPolicy = base.GetDefaultSharingPolicyId(user, sharedConfig); } if (mailbox.RetentionPolicy == null && mailbox.ShouldUseDefaultRetentionPolicy && !mailbox.propertyBag.IsReadOnlyProperty(MailboxSchema.RetentionPolicy)) { mailbox.RetentionPolicy = base.GetDefaultRetentionPolicyId(user, sharedConfig); } if (mailbox.Database != null && mailbox.UseDatabaseRetentionDefaults) { this.SetDefaultRetentionValues(mailbox); } mailbox.AdminDisplayVersion = Microsoft.Exchange.Data.Directory.SystemConfiguration.Server.GetServerVersion(mailbox.ServerName); return(mailbox); }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); if (base.Fields.IsModified(ADRecipientSchema.RoleAssignmentPolicy) && (MailboxPolicyIdParameter)base.Fields[ADRecipientSchema.RoleAssignmentPolicy] == null && !OrganizationId.ForestWideOrgId.Equals(this.DataObject.OrganizationId)) { base.WriteError(new TaskInvalidOperationException(Strings.ResettingPolicyIsNotSupported("RoleAssignmentPolicy")), ExchangeErrorCategory.Client, this.Identity); } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(base.CurrentOrganizationId); if (sharedConfiguration != null) { this.DataObject.SharedConfiguration = sharedConfiguration.SharedConfigId.ConfigurationUnit; } if (this.DataObject.IsResource) { this.CheckResourceProperties(); } else if (this.DataObject.RecipientTypeDetails == RecipientTypeDetails.DiscoveryMailbox) { if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFrom) || base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFromSendersOrMembers)) { base.WriteError(new TaskInvalidOperationException(Strings.ErrorCannotChangeAcceptMessagesFrom), ExchangeErrorCategory.Client, this.DataObject); } MailboxTaskHelper.ValidateMaximumDiscoveryMailboxQuota(this.DataObject, this.ConfigurationSession, base.CurrentOrganizationId, new Task.ErrorLoggerDelegate(base.WriteError)); } else if (this.PublicFolder && base.UserSpecifiedParameters.Contains(MailEnabledRecipientSchema.HiddenFromAddressListsEnabled.Name)) { base.WriteError(new TaskInvalidOperationException(Strings.ErrorCannotChangeHiddenFromAddressListsEnabled), ExchangeErrorCategory.Client, this.DataObject); } if (this.RetentionPolicy != null && this.DataObject.RecipientTypeDetails == RecipientTypeDetails.TeamMailbox) { base.WriteError(new RecipientTaskException(Strings.ErrorNoRetentionPolicyForTeamMailbox(this.DataObject.Name)), ExchangeErrorCategory.Client, this.DataObject); } if (this.AuditLog) { Mailbox mailbox = (Mailbox)this.GetDynamicParameters(); foreach (object obj in SetMailboxBase<MailboxIdParameter, Mailbox>.InvalidAuditLogParameters) { ProviderPropertyDefinition providerPropertyDefinition = obj as ProviderPropertyDefinition; if (base.Fields.IsModified(obj) || (providerPropertyDefinition != null && mailbox.IsModified(providerPropertyDefinition))) { base.WriteError(new TaskArgumentException(Strings.ErrorInvalidParameterForAuditLog((providerPropertyDefinition == null) ? obj.ToString() : providerPropertyDefinition.Name, "AuditLog")), ExchangeErrorCategory.Client, this.Identity); } } } else if (this.DataObject.RecipientTypeDetails == RecipientTypeDetails.AuditLogMailbox) { base.WriteError(new RecipientTaskException(Strings.RecipientNotFoundException(this.DataObject.Name)), ExchangeErrorCategory.Client, this.DataObject); } base.VerifyIsWithinScopes((IRecipientSession)base.DataSession, this.DataObject, true, new DataAccessTask<ADUser>.ADObjectOutOfScopeString(Strings.ErrorCannotChangeMailboxOutOfWriteScope)); TaskLogger.LogExit(); }
// Token: 0x06000E61 RID: 3681 RVA: 0x000568D8 File Offset: 0x00054AD8 private static SharingPolicyCache GetDehydratedPolicyFromCacheOrAD(OrganizationId orgId, ADObjectId policyId) { SharingPolicyCache sharingPolicyCache; if (policyId != SharingPolicyCache.DynamicDefaultPolicy) { lock (SharingPolicyCache.cacheSyncLock) { if (SharingPolicyCache.dehydratedDefaultCache.TryGetValue(policyId.ObjectGuid, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId>(0L, "Found Sharing Policy {0} in dehydrated cache.", policyId); return(sharingPolicyCache); } } } SharedConfiguration sharedConfiguration = SharedConfiguration.GetSharedConfiguration(orgId); IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, sharedConfiguration.GetSharedConfigurationSessionSettings(), 282, "GetDehydratedPolicyFromCacheOrAD", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\SharingPolicy\\SharingPolicyCache.cs"); tenantOrTopologyConfigurationSession.SessionSettings.IsSharedConfigChecked = true; bool flag2 = policyId == SharingPolicyCache.DynamicDefaultPolicy; if (flag2) { SharingPolicyCache.Tracer.TraceDebug <OrganizationId>(0L, "Find Default Policy Id for Org {0} ", orgId); policyId = SharingPolicyCache.GetDefaultSharingPolicyId(tenantOrTopologyConfigurationSession); if (policyId == null) { return(null); } lock (SharingPolicyCache.cacheSyncLock) { if (SharingPolicyCache.dehydratedDefaultCache.TryGetValue(policyId.ObjectGuid, out sharingPolicyCache)) { SharingPolicyCache.Tracer.TraceDebug <ADObjectId>(0L, "Found Sharing Policy {0} in dehydrated cache.", policyId); return(sharingPolicyCache); } } } SharingPolicy sharingPolicy = tenantOrTopologyConfigurationSession.Read <SharingPolicy>(policyId); if (sharingPolicy == null) { SharingPolicyCache.Tracer.TraceError <ADObjectId, bool>(0L, "Unable to find SharingPolicy {0} in the AD. PolicyId is default:{1}", policyId, flag2); return(null); } sharingPolicyCache = new SharingPolicyCache(sharingPolicy, true); lock (SharingPolicyCache.cacheSyncLock) { SharingPolicyCache.dehydratedDefaultCache[policyId.ObjectGuid] = sharingPolicyCache; } return(sharingPolicyCache); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); bool advancedHydrateableObjectsSharedEnabled = this.newServicePlanSettings.Organization.AdvancedHydrateableObjectsSharedEnabled; base.InternalCreateSharedConfiguration = (this.oldServicePlanSettings.Organization.ShareableConfigurationEnabled && this.newServicePlanSettings.Organization.ShareableConfigurationEnabled && this.tenantCU.SupportedSharedConfigurations.Count == 0); base.InternalIsSharedConfigServicePlan = this.config.IsSharedConfigurationAllowedForServicePlan(this.newServicePlanSettings); this.monadConnection.RunspaceProxy.SetVariable("TargetServicePlan", this.newServicePlan); this.monadConnection.RunspaceProxy.SetVariable("TargetProgramId", this.targetProgramId); this.monadConnection.RunspaceProxy.SetVariable("TargetOfferId", this.targetOfferId); if (this.tenantCU.ServicePlan == this.newServicePlan) { base.WriteVerbose(Strings.VerboseWillSkipUpdateServicePlan(this.Identity.ToString())); } else if (!ServicePlan.CompareAndCalculateDelta(this.oldServicePlanSettings, this.newServicePlanSettings, this.IsCrossSKUMigration, out this.deltaServicePlanSettings, out this.featuresToApply)) { base.WriteVerbose(Strings.VerboseWillUpgradeServicePlan(this.Identity.ToString(), this.tenantCU.ServicePlan, this.newServicePlan)); if (advancedHydrateableObjectsSharedEnabled) { string text; if (!this.config.TryGetHydratedOfferId(this.targetProgramId, this.targetOfferId, out text)) { text = this.targetOfferId; } SharedConfigurationInfo sharedConfigurationInfo = SharedConfigurationInfo.FromInstalledVersion(this.targetProgramId, text); OrganizationId organizationId = SharedConfiguration.FindOneSharedConfigurationId(sharedConfigurationInfo, this.tenantCU.OrganizationId.PartitionId); if (organizationId == null) { base.WriteError(new SharedConfigurationValidationException(Strings.ErrorSharedConfigurationNotFound(this.targetProgramId, text, sharedConfigurationInfo.CurrentVersion.ToString())), (ErrorCategory)1000, null); } else { this.monadConnection.RunspaceProxy.SetVariable("TargetSharedConfiguration", organizationId.OrganizationalUnit.Name); } } if (ManageServicePlanMigrationBase.MailboxPlanConfigurationChanged(this.deltaServicePlanSettings)) { ManageServicePlanMigrationBase.CopyEnabledMailboxPlanRoleAssignmentFeatures(this.deltaServicePlanSettings, this.newServicePlanSettings); } this.newServicePlanSettings.Name = "new"; base.InternalProcessRecord(); if (this.configOnly) { this.WriteWarning(Strings.WarningUpgradeIsNotComplete(this.UpgradePhase.ToString())); } } else { base.WriteVerbose(Strings.VerboseWillSkipUpdateServicePlan(this.Identity.ToString())); } TaskLogger.LogExit(); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (SharedConfiguration.IsSharedConfiguration(this.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(this.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } base.CreateParentContainerIfNeeded(this.DataObject); base.InternalProcessRecord(); FfoDualWriter.SaveToFfo <HostedContentFilterPolicy>(this, this.DataObject, null); TaskLogger.LogExit(); }
// Token: 0x06000E5F RID: 3679 RVA: 0x000566F0 File Offset: 0x000548F0 private static SharingPolicyCache InternalGet(OrganizationId orgId, ADObjectId policyId) { orgId = (orgId ?? OrganizationId.ForestWideOrgId); policyId = (policyId ?? SharingPolicyCache.DynamicDefaultPolicy); bool flag = SharedConfiguration.IsDehydratedConfiguration(orgId); SharingPolicyCache.Tracer.TraceDebug <ADObjectId, string, OrganizationId>(0L, "Find Sharing policy {0} in {1} Org {2} ", policyId, flag ? "dehydrated" : "hydrated", orgId); if (!flag) { return(SharingPolicyCache.GetHydratedPolicyFromCacheOrAD(orgId, policyId)); } return(SharingPolicyCache.GetDehydratedPolicyFromCacheOrAD(orgId, policyId)); }
protected override void InternalProcessRecord() { if (!this.Force && SharedConfiguration.IsSharedConfiguration(base.DataObject.OrganizationId) && !base.ShouldContinue(Strings.ConfirmSharedConfiguration(base.DataObject.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } if (this.roleAssignmentResults.Length != 0) { ((IRecipientSession)base.DataSession).VerifyIsWithinScopes(base.DataObject, true); } bool flag = true; foreach (Result <ExchangeRoleAssignment> result in this.roleAssignmentResults) { string id = result.Data.Id.ToString(); try { base.WriteVerbose(Strings.VerboseRemovingRoleAssignment(id)); result.Data.Session.Delete(result.Data); base.WriteVerbose(Strings.VerboseRemovedRoleAssignment(id)); } catch (Exception ex) { flag = false; if (!base.IsKnownException(ex)) { throw; } this.WriteWarning(Strings.WarningCouldNotRemoveRoleAssignment(id, ex.Message)); } } if (!flag) { base.WriteError(new TaskException(Strings.ErrorCouldNotRemoveRoleAssignments(base.DataObject.Id.ToString())), ExchangeErrorCategory.ServerOperation, base.DataObject); } if (this.RemoveWellKnownObjectGuid) { ExchangeConfigurationUnit exchangeConfigurationUnit = this.writableConfigSession.Read <ExchangeConfigurationUnit>(base.DataObject.OrganizationId.ConfigurationUnit); foreach (DNWithBinary dnwithBinary in exchangeConfigurationUnit.OtherWellKnownObjects) { if (dnwithBinary.DistinguishedName.Equals(base.DataObject.DistinguishedName, StringComparison.OrdinalIgnoreCase)) { exchangeConfigurationUnit.OtherWellKnownObjects.Remove(dnwithBinary); this.writableConfigSession.Save(exchangeConfigurationUnit); break; } } } base.InternalProcessRecord(); }
// Token: 0x060005CC RID: 1484 RVA: 0x0001614C File Offset: 0x0001434C protected override void InternalProcessRecord() { TaskLogger.LogEnter(); OrganizationId currentOrganizationId = base.CurrentOrganizationId; TDataObject dataObject = this.DataObject; if (!currentOrganizationId.Equals(dataObject.OrganizationId)) { this.CurrentOrgState = new LazilyInitialized <SharedTenantConfigurationState>(delegate() { TDataObject dataObject8 = this.DataObject; return(SharedConfiguration.GetSharedConfigurationState(dataObject8.OrganizationId)); }); } if (SharedConfigurationTaskHelper.ShouldPrompt(this, this.SharedTenantConfigurationMode, this.CurrentOrgState) && !base.InternalForce) { TDataObject dataObject2 = this.DataObject; if (!base.ShouldContinue(Strings.ConfirmSharedConfiguration(dataObject2.OrganizationId.OrganizationalUnit.Name))) { TaskLogger.LogExit(); return; } } TDataObject dataObject3 = this.DataObject; if (dataObject3.IsChanged(ADObjectSchema.Id)) { IDirectorySession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(base.DomainController, true, ConsistencyMode.PartiallyConsistent, null, base.OrgWideSessionSettings, ConfigScopes.TenantSubTree, 702, "InternalProcessRecord", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\SetAdObjectTask.cs"); tenantOrTopologyConfigurationSession.UseConfigNC = ((IDirectorySession)base.DataSession).UseConfigNC; TDataObject dataObject4 = this.DataObject; ADObjectId parent = dataObject4.Id.Parent; ADRawEntry adrawEntry = tenantOrTopologyConfigurationSession.ReadADRawEntry(parent, new PropertyDefinition[] { ADObjectSchema.ExchangeVersion, ADObjectSchema.ObjectClass }); ExchangeObjectVersion exchangeObjectVersion = (ExchangeObjectVersion)adrawEntry[ADObjectSchema.ExchangeVersion]; MultiValuedProperty <string> multiValuedProperty = (MultiValuedProperty <string>)adrawEntry[ADObjectSchema.ObjectClass]; TDataObject dataObject5 = this.DataObject; if (dataObject5.ExchangeVersion.IsOlderThan(exchangeObjectVersion) && !multiValuedProperty.Contains(Organization.MostDerivedClass)) { TDataObject dataObject6 = this.DataObject; string name = dataObject6.Name; TDataObject dataObject7 = this.DataObject; base.WriteError(new TaskException(Strings.ErrorParentHasNewerVersion(name, dataObject7.ExchangeVersion.ToString(), exchangeObjectVersion.ToString())), (ErrorCategory)1004, null); } } base.InternalProcessRecord(); TaskLogger.LogExit(); }