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