protected override void UpgradeExchangeVersion(ADObject adObject)
{
string text = (string)adObject[ADMailboxRecipientSchema.ServerLegacyDN];
if (!string.IsNullOrEmpty(text))
{
Server server = base.GlobalConfigSession.FindServerByLegacyDN(text);
if (server == null)
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorServerNotFound(text)), ExchangeErrorCategory.Client, null);
}
ExchangeObjectVersion exchangeVersion = ExchangeObjectVersion.Exchange2003;
if (server.IsE14OrLater)
{
ADRecipient adrecipient = adObject as ADRecipient;
MailEnabledRecipient mailEnabledRecipient = adObject as MailEnabledRecipient;
RecipientTypeDetails recipientTypeDetails = (adrecipient != null) ? adrecipient.RecipientTypeDetails : ((mailEnabledRecipient != null) ? mailEnabledRecipient.RecipientTypeDetails : RecipientTypeDetails.None);
exchangeVersion = ADUser.GetMaximumSupportedExchangeObjectVersion(recipientTypeDetails, false);
}
else if (server.IsExchange2007OrLater)
{
exchangeVersion = ExchangeObjectVersion.Exchange2007;
}
adObject.SetExchangeVersion(exchangeVersion);
}
}
private void CreateFeatureManagerFactoryFromAD(OWAMiniRecipient miniRecipient)
{
OwaFlightConfigData owaFlightConfigData = UserContext.ReadFlightConfigDataFromAD(base.ExchangePrincipal.MailboxInfo.OrganizationId);
RecipientTypeDetails recipientTypeDetails = base.ExchangePrincipal.RecipientTypeDetails;
this.featuresManagerFactory = new FeaturesManagerFactory(miniRecipient, new ConfigurationContext(this), new ScopeFlightsSettingsProvider(), (VariantConfigurationSnapshot c) => new FeaturesStateOverride(c, recipientTypeDetails), owaFlightConfigData.RampId, owaFlightConfigData.IsFirstRelease);
}
public static string GenerateGroupTypeText(object groupType)
{
if (groupType == DBNull.Value)
{
return(string.Empty);
}
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)groupType;
if (recipientTypeDetails <= RecipientTypeDetails.MailNonUniversalGroup)
{
if (recipientTypeDetails == RecipientTypeDetails.MailUniversalDistributionGroup || recipientTypeDetails == RecipientTypeDetails.MailNonUniversalGroup)
{
return(Strings.DistributionGroupText);
}
}
else
{
if (recipientTypeDetails == RecipientTypeDetails.MailUniversalSecurityGroup)
{
return(Strings.SecurityGroupText);
}
if (recipientTypeDetails == RecipientTypeDetails.DynamicDistributionGroup)
{
return(Strings.DynamicDistributionGroupText);
}
}
throw new InvalidOperationException();
}
private void CreateFeatureManagerFactoryFromMailbox(OWAMiniRecipient miniRecipient)
{
UserConfigurationManager.IAggregationContext aggregationContext = null;
try
{
this.LockAndReconnectMailboxSession();
aggregationContext = base.MailboxSession.UserConfigurationManager.AttachAggregator(AggregatedUserConfigurationSchema.Instance.OwaUserConfiguration);
base.UnlockAndDisconnectMailboxSession();
OwaFlightConfigData owaFlightConfigData = UserContext.ReadAggregatedFlightConfigData(aggregationContext, base.ExchangePrincipal.MailboxInfo.OrganizationId);
RecipientTypeDetails recipientTypeDetails = base.ExchangePrincipal.RecipientTypeDetails;
this.featuresManagerFactory = new FeaturesManagerFactory(miniRecipient, new ConfigurationContext(this), new ScopeFlightsSettingsProvider(), (VariantConfigurationSnapshot c) => new FeaturesStateOverride(c, recipientTypeDetails), owaFlightConfigData.RampId, owaFlightConfigData.IsFirstRelease);
}
finally
{
if (aggregationContext != null)
{
aggregationContext.Detach();
this.bootAggregationContext = aggregationContext;
}
if (base.MailboxSessionLockedByCurrentThread())
{
base.UnlockAndDisconnectMailboxSession();
}
}
}
internal static QueryFilter GetRecipientTypeDetailsFilterOptimization(RecipientTypeDetails recipientTypeDetails)
{
QueryFilter result = null;
Filters.RecipientTypeDetailsFilterOptimizations.TryGetValue(recipientTypeDetails, out result);
return(result);
}
private static RemoteRecipientType CalculateSourceRRT(RecipientTypeDetails recipientTypeDetails)
{
RemoteRecipientType remoteRecipientType = RemoteRecipientType.Migrated;
if (recipientTypeDetails <= RecipientTypeDetails.RoomMailbox)
{
if (recipientTypeDetails != RecipientTypeDetails.SharedMailbox)
{
if (recipientTypeDetails == RecipientTypeDetails.RoomMailbox)
{
remoteRecipientType |= RemoteRecipientType.RoomMailbox;
}
}
else
{
remoteRecipientType |= RemoteRecipientType.SharedMailbox;
}
}
else if (recipientTypeDetails != RecipientTypeDetails.EquipmentMailbox)
{
if (recipientTypeDetails == RecipientTypeDetails.TeamMailbox)
{
remoteRecipientType |= RemoteRecipientType.TeamMailbox;
}
}
else
{
remoteRecipientType |= RemoteRecipientType.EquipmentMailbox;
}
return(remoteRecipientType);
}
public static string GenerateMailboxTypeText(RecipientTypeDetails recipientTypeDetails, Guid archiveGuid, bool isUserFederated)
{
string text = string.Empty;
if (recipientTypeDetails <= Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.LegacyMailbox)
{
if (recipientTypeDetails <= Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.SharedMailbox)
{
if (recipientTypeDetails < Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.UserMailbox)
{
goto IL_BA;
}
switch ((int)(recipientTypeDetails - Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.UserMailbox))
{
case 0:
text = (isUserFederated ? Strings.FederatedUserMailboxText : Strings.UserMailboxText);
goto IL_C6;
case 1:
text = Strings.LinkedMailboxText;
goto IL_C6;
case 2:
goto IL_BA;
case 3:
text = Strings.SharedMailboxText;
goto IL_C6;
}
}
if (recipientTypeDetails == Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.LegacyMailbox)
{
text = Strings.LegacyMailboxText;
goto IL_C6;
}
}
else
{
if (recipientTypeDetails == Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.RoomMailbox)
{
text = Strings.RoomMailboxText;
goto IL_C6;
}
if (recipientTypeDetails == Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.EquipmentMailbox)
{
text = Strings.EquipmentMailboxText;
goto IL_C6;
}
if (recipientTypeDetails == Microsoft.Exchange.Data.Directory.Recipient.RecipientTypeDetails.TeamMailbox)
{
text = Strings.TeamMailboxText;
goto IL_C6;
}
}
IL_BA:
text = recipientTypeDetails.ToString();
IL_C6:
return(archiveGuid.Equals(Guid.Empty) ? text : string.Format(Strings.ArchiveText, text));
}
private static bool IsEntryMailEnabledUser(ExSearchResultEntry entry, RecipientTypeDetails recipientTypeDetail)
{
if (recipientTypeDetail != RecipientTypeDetails.None)
{
return(recipientTypeDetail == RecipientTypeDetails.MailUser);
}
return(entry.Attributes.ContainsKey("mailNickname") && !entry.Attributes.ContainsKey("msExchHomeServerName"));
}
public static void GetListPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
foreach (object obj in dataTable.Rows)
{
DataRow dataRow = (DataRow)obj;
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)dataRow["RecipientTypeDetails"];
dataRow["IsRoom"] = (recipientTypeDetails == RecipientTypeDetails.RoomMailbox);
dataRow["MailboxType"] = MailboxPropertiesHelper.TranslateMailboxTypeForListview(recipientTypeDetails, false, Guid.Empty);
}
}
private bool IsMailboxInterestingAdditionalTests(MailboxProcessorRequest request)
{
if (request.MailboxSession == null)
{
this.tracer.TraceError <MailboxProcessorRequest>((long)this.GetHashCode(), "MailboxProcessor: NOT processing {0} because session has not been initialized.", request);
return(false);
}
IMailboxSession mailboxSession = request.MailboxSession as IMailboxSession;
if (mailboxSession == null)
{
this.tracer.TraceDebug <MailboxProcessorRequest>((long)this.GetHashCode(), "MailboxProcessor: NOT processing {0} because it's not attached to a mailbox session.", request);
return(false);
}
if (mailboxSession.MailboxOwner == null)
{
this.tracer.TraceDebug <MailboxProcessorRequest>((long)this.GetHashCode(), "MailboxProcessor: NOT processing {0} because owner has not been initialized.", request);
return(false);
}
if (!request.IsFlightEnabled)
{
this.tracer.TraceDebug <MailboxProcessorRequest>((long)this.GetHashCode(), "MailboxProcessor: NOT processing {0} because it's not enabled in flight.", request);
return(false);
}
RecipientTypeDetails recipientTypeDetails = mailboxSession.MailboxOwner.RecipientTypeDetails;
if (recipientTypeDetails <= RecipientTypeDetails.DiscoveryMailbox)
{
if (recipientTypeDetails <= RecipientTypeDetails.LinkedMailbox)
{
if (recipientTypeDetails < RecipientTypeDetails.UserMailbox)
{
goto IL_FC;
}
switch ((int)(recipientTypeDetails - RecipientTypeDetails.UserMailbox))
{
case 0:
case 1:
return(true);
}
}
if (recipientTypeDetails != RecipientTypeDetails.ArbitrationMailbox && recipientTypeDetails != RecipientTypeDetails.DiscoveryMailbox)
{
}
}
else if (recipientTypeDetails != RecipientTypeDetails.MonitoringMailbox && recipientTypeDetails != RecipientTypeDetails.GroupMailbox && recipientTypeDetails != RecipientTypeDetails.AuditLogMailbox)
{
}
IL_FC:
this.tracer.TraceDebug <MailboxProcessorRequest, RecipientTypeDetails>((long)this.GetHashCode(), "MailboxProcessor: NOT processing {0} because {1} is not a supported type.", request, mailboxSession.MailboxOwner.RecipientTypeDetails);
return(false);
}
private static RecipientTypeDetails CalculateSourceRTD(ADUser source, int sourceServerVersion, MailboxMoveHelper.Scenario scenario)
{
RecipientTypeDetails result;
if (scenario == MailboxMoveHelper.Scenario.CrossPremiseOnboarding && MailboxMoveHelper.IsRemoteMailboxTypeDefined(sourceServerVersion))
{
RecipientTypeDetails recipientTypeDetails = source.RecipientTypeDetails;
if (recipientTypeDetails <= RecipientTypeDetails.RoomMailbox)
{
if (recipientTypeDetails <= RecipientTypeDetails.SharedMailbox)
{
if (recipientTypeDetails < RecipientTypeDetails.UserMailbox)
{
goto IL_91;
}
switch ((int)(recipientTypeDetails - RecipientTypeDetails.UserMailbox))
{
case 0:
case 1:
case 2:
goto IL_91;
case 3:
return(RecipientTypeDetails.RemoteSharedMailbox);
}
}
if (recipientTypeDetails == RecipientTypeDetails.RoomMailbox)
{
return(RecipientTypeDetails.RemoteRoomMailbox);
}
}
else
{
if (recipientTypeDetails == RecipientTypeDetails.EquipmentMailbox)
{
return(RecipientTypeDetails.RemoteEquipmentMailbox);
}
if (recipientTypeDetails == RecipientTypeDetails.TeamMailbox)
{
return(RecipientTypeDetails.RemoteTeamMailbox);
}
}
IL_91:
result = (RecipientTypeDetails)((ulong)int.MinValue);
}
else
{
result = RecipientTypeDetails.MailUser;
}
return(result);
}
// Token: 0x06000172 RID: 370 RVA: 0x0000A128 File Offset: 0x00008328
private static SmtpAddress GetDiscoveryHolds(DiscoverySearchDataProvider dataProvider, Dictionary <string, MailboxDiscoverySearch> discoveryHolds)
{
SmtpAddress smtpAddress = SmtpAddress.Empty;
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopes(ADSystemConfigurationSession.GetRootOrgContainerIdForLocalForest(), OrganizationId.ForestWideOrgId, null, false);
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.IgnoreInvalid, sessionSettings, 324, "GetDiscoveryHolds", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\elc\\DiscoveryHoldSynchronizer.cs");
foreach (MailboxDiscoverySearch mailboxDiscoverySearch in dataProvider.GetAll <MailboxDiscoverySearch>())
{
if (mailboxDiscoverySearch.InPlaceHoldEnabled)
{
discoveryHolds.Add(mailboxDiscoverySearch.InPlaceHoldIdentity, mailboxDiscoverySearch);
if (smtpAddress == SmtpAddress.Empty)
{
Result <ADRawEntry>[] first = tenantOrRootOrgRecipientSession.FindByLegacyExchangeDNs(mailboxDiscoverySearch.Sources.ToArray(), new ADPropertyDefinition[]
{
ADRecipientSchema.RecipientType,
ADRecipientSchema.RecipientTypeDetails,
ADUserSchema.ArchiveDomain,
ADUserSchema.ArchiveGuid,
ADRecipientSchema.RawExternalEmailAddress,
ADUserSchema.ArchiveStatus
});
foreach (ADRawEntry adrawEntry in from x in first
select x.Data)
{
if (adrawEntry != null)
{
RecipientType recipientType = (RecipientType)adrawEntry[ADRecipientSchema.RecipientType];
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)adrawEntry[ADRecipientSchema.RecipientTypeDetails];
SmtpDomain smtpDomain = (SmtpDomain)adrawEntry[ADUserSchema.ArchiveDomain];
ArchiveStatusFlags archiveStatusFlags = (ArchiveStatusFlags)adrawEntry[ADUserSchema.ArchiveStatus];
if (RemoteMailbox.IsRemoteMailbox(recipientTypeDetails))
{
smtpAddress = new SmtpAddress(((ProxyAddress)adrawEntry[ADRecipientSchema.RawExternalEmailAddress]).AddressString);
}
else if (recipientType == RecipientType.UserMailbox && smtpDomain != null && !string.IsNullOrEmpty(smtpDomain.Domain) && (archiveStatusFlags & ArchiveStatusFlags.Active) == ArchiveStatusFlags.Active)
{
Guid guid = (Guid)adrawEntry[ADUserSchema.ArchiveGuid];
if (guid != Guid.Empty)
{
smtpAddress = new SmtpAddress(SmtpProxyAddress.EncapsulateExchangeGuid(smtpDomain.Domain, guid));
}
}
}
}
}
}
}
return(smtpAddress);
}
public IMailboxOwner Create(MiniRecipient recipient)
{
if (recipient == null)
{
return(new NullMailboxOwnerAdapter());
}
if (this.session.IsGroupMailbox())
{
return(new GroupMailboxOwnerAdapter());
}
RecipientTypeDetails recipientTypeDetails = recipient.RecipientTypeDetails;
return(new MiniRecipientMailboxOwnerAdapter(recipient, recipient.GetContext(null), recipientTypeDetails, this.session.LogonType));
}
private static Persona GetPersonaFromADObject(ADRawEntry rawEntry)
{
if (rawEntry == null)
{
return(null);
}
ADObjectId adobjectId = rawEntry[ADObjectSchema.Id] as ADObjectId;
if (adobjectId == null)
{
return(null);
}
Persona persona = new Persona();
persona.PersonaId = IdConverter.PersonaIdFromADObjectId(adobjectId.ObjectGuid);
RecipientType recipientType = (RecipientType)rawEntry[ADRecipientSchema.RecipientType];
PersonType personType = ADRecipient.IsRecipientTypeDL(recipientType) ? PersonType.DistributionList : PersonType.Person;
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)rawEntry[ADRecipientSchema.RecipientTypeDetails];
if (recipientTypeDetails == RecipientTypeDetails.GroupMailbox)
{
personType = PersonType.ModernGroup;
}
persona.PersonaType = PersonaTypeConverter.ToString(personType);
object obj = rawEntry[ADRecipientSchema.DisplayName];
if (obj != null)
{
persona.DisplayName = (obj as string);
}
object obj2 = rawEntry[ADRecipientSchema.PrimarySmtpAddress];
if (obj2 != null)
{
persona.EmailAddress = new EmailAddressWrapper
{
Name = (persona.DisplayName ?? string.Empty),
EmailAddress = obj2.ToString(),
RoutingType = "SMTP",
MailboxType = MailboxHelper.ConvertToMailboxType(personType).ToString()
};
}
object obj3 = rawEntry[ADUserSchema.RTCSIPPrimaryUserAddress];
if (obj3 != null)
{
persona.ImAddress = obj3.ToString();
}
return(persona);
}
public static void GetSDOPostAction(DataRow input, DataTable dataTable, DataObjectStore store)
{
DataRow dataRow = dataTable.Rows[0];
CalendarConfiguration calendarConfiguration = store.GetDataObject("CalendarConfiguration") as CalendarConfiguration;
if (calendarConfiguration != null)
{
dataRow["ResourceDelegates"] = calendarConfiguration.ResourceDelegates.ResolveRecipientsForSDO(3, (RecipientObjectResolverRow x) => Strings.DisplayedResourceDelegates(x.DisplayName, x.PrimarySmtpAddress));
dataRow["AutomateProcessingAuto"] = (calendarConfiguration.AutomateProcessing == CalendarProcessingFlags.AutoAccept && calendarConfiguration.AllBookInPolicy && !calendarConfiguration.AllRequestInPolicy);
}
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)dataRow["RecipientTypeDetails"];
dataRow["IsRoom"] = (recipientTypeDetails == RecipientTypeDetails.RoomMailbox);
}
public static bool IsSoftDeleteSupportedRecipientTypeDetail(RecipientTypeDetails typeDetail)
{
if (typeDetail <= RecipientTypeDetails.RoomMailbox)
{
if (typeDetail != RecipientTypeDetails.UserMailbox && typeDetail != RecipientTypeDetails.SharedMailbox && typeDetail != RecipientTypeDetails.RoomMailbox)
{
return(false);
}
}
else if (typeDetail != RecipientTypeDetails.EquipmentMailbox && typeDetail != RecipientTypeDetails.MailUser && typeDetail != RecipientTypeDetails.User)
{
return(false);
}
return(true);
}
private static RecipientTypeDetails CalculateTargetRTD(RecipientTypeDetails sourceRTD, bool isLinkedAccount)
{
RecipientTypeDetails recipientTypeDetails;
if (sourceRTD <= RecipientTypeDetails.RoomMailbox)
{
if (sourceRTD <= RecipientTypeDetails.SharedMailbox)
{
if (sourceRTD < RecipientTypeDetails.UserMailbox)
{
goto IL_52;
}
switch ((int)(sourceRTD - RecipientTypeDetails.UserMailbox))
{
case 0:
case 3:
goto IL_49;
case 1:
recipientTypeDetails = RecipientTypeDetails.UserMailbox;
goto IL_55;
case 2:
goto IL_52;
}
}
if (sourceRTD != RecipientTypeDetails.RoomMailbox)
{
goto IL_52;
}
}
else if (sourceRTD != RecipientTypeDetails.EquipmentMailbox && sourceRTD != RecipientTypeDetails.TeamMailbox)
{
goto IL_52;
}
IL_49:
recipientTypeDetails = sourceRTD;
goto IL_55;
IL_52:
recipientTypeDetails = RecipientTypeDetails.UserMailbox;
IL_55:
if (recipientTypeDetails == RecipientTypeDetails.UserMailbox && isLinkedAccount)
{
recipientTypeDetails = RecipientTypeDetails.LinkedMailbox;
}
return(recipientTypeDetails);
}
private void ValidateConvertToRoomList()
{
RecipientTypeDetails recipientTypeDetails = this.DataObject.RecipientTypeDetails;
if (recipientTypeDetails != RecipientTypeDetails.MailUniversalDistributionGroup)
{
base.WriteError(new TaskInvalidOperationException(Strings.ErrorConvertNonUniversalDistributionGroup(this.DataObject.Identity.ToString())), ExchangeErrorCategory.Client, this.DataObject.Identity);
}
foreach (ADObjectId adobjectId in this.DataObject.Members)
{
IRecipientSession session = RecipientTaskHelper.CreatePartitionOrRootOrgScopedGcSession(base.DomainController, adobjectId);
ADRecipient adrecipient = (ADRecipient)base.GetDataObject <ADRecipient>(new RecipientIdParameter(adobjectId), session, null, new LocalizedString?(Strings.ErrorRecipientNotFound(adobjectId.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(adobjectId.ToString())), ExchangeErrorCategory.Client);
if (adrecipient.RecipientTypeDetails != RecipientTypeDetails.RoomMailbox && adrecipient.RecipientTypeDetails != RecipientTypeDetails.RoomList && adrecipient.RecipientDisplayType != RecipientDisplayType.SyncedConferenceRoomMailbox)
{
base.WriteError(new TaskInvalidOperationException(Strings.ErrorConvertGroupContainsNonRoomMailbox(this.DataObject.Identity.ToString(), adrecipient.Identity.ToString())), ExchangeErrorCategory.Client, this.DataObject.Identity);
}
}
}
private static void UpdateRecipientTypeProperties(ADUser source, int sourceServerVersion, ADUser target, int targetServerVersion, MailboxMoveHelper.Scenario scenario, MailboxMoveType moveType, MailboxMoveTransition transition)
{
if (!MailboxMoveHelper.IsMovingPrimary(moveType))
{
return;
}
if (scenario == MailboxMoveHelper.Scenario.CrossPremiseOnboarding && transition == MailboxMoveTransition.UpdateSourceUser && MailboxMoveHelper.IsRemoteMailboxTypeDefined(sourceServerVersion))
{
source.RemoteRecipientType = MailboxMoveHelper.CalculateSourceRRT(source.RecipientTypeDetails);
}
else if (scenario == MailboxMoveHelper.Scenario.CrossPremiseOffboarding && transition == MailboxMoveTransition.UpdateTargetUser && MailboxMoveHelper.IsRemoteMailboxTypeDefined(targetServerVersion))
{
target.RemoteRecipientType = RemoteRecipientType.Migrated;
}
if (transition == MailboxMoveTransition.UpdateTargetUser)
{
RecipientTypeDetails recipientTypeDetails = (source.RecipientTypeDetails != RecipientTypeDetails.None) ? source.RecipientTypeDetails : MailboxMoveHelper.CalculateLegacyMailboxRTD(source);
if (target.MasterAccountSid == null && MailboxMoveHelper.IsResourceOrShared(recipientTypeDetails))
{
target.MasterAccountSid = new SecurityIdentifier(WellKnownSidType.SelfSid, null);
}
if (MailboxMoveHelper.IsRTDRDTDefined(targetServerVersion))
{
target.RecipientTypeDetails = MailboxMoveHelper.CalculateTargetRTD(recipientTypeDetails, MailboxMoveHelper.IsLinkedAccount(target));
target.RecipientDisplayType = new RecipientDisplayType?(MailboxMoveHelper.CalculateTargetRDT(target.RecipientTypeDetails, MailboxMoveHelper.IsSecurityPrincipal(target)));
}
else
{
target.RecipientTypeDetails = RecipientTypeDetails.None;
target.RecipientDisplayType = null;
}
}
if (transition == MailboxMoveTransition.UpdateSourceUser)
{
if (MailboxMoveHelper.IsRTDRDTDefined(sourceServerVersion))
{
source.RecipientDisplayType = new RecipientDisplayType?(MailboxMoveHelper.CalculateSourceRDT(source.RecipientTypeDetails, MailboxMoveHelper.IsACLableSyncedObjectEnabled(source, scenario) && MailboxMoveHelper.IsSecurityPrincipal(source)));
source.RecipientTypeDetails = MailboxMoveHelper.CalculateSourceRTD(source, sourceServerVersion, scenario);
return;
}
source.RecipientTypeDetails = RecipientTypeDetails.None;
source.RecipientDisplayType = null;
}
}
private static void UpdateRecipientTypePropertiesForIntraOrg(ADUser target, int targetServerVersion)
{
if (MailboxMoveHelper.IsRTDRDTDefined(targetServerVersion))
{
RecipientTypeDetails recipientTypeDetails = target.RecipientTypeDetails;
RecipientTypeDetails recipientTypeDetails2 = (recipientTypeDetails == RecipientTypeDetails.None || recipientTypeDetails == RecipientTypeDetails.LegacyMailbox) ? MailboxMoveHelper.CalculateLegacyMailboxRTD(target) : recipientTypeDetails;
target.RecipientTypeDetails = recipientTypeDetails2;
if (target.RecipientDisplayType == null || recipientTypeDetails != recipientTypeDetails2)
{
target.RecipientDisplayType = new RecipientDisplayType?(MailboxMoveHelper.CalculateTargetRDT(target.RecipientTypeDetails, MailboxMoveHelper.IsSecurityPrincipal(target)));
return;
}
}
else
{
target.RecipientTypeDetails = RecipientTypeDetails.None;
target.RecipientDisplayType = null;
}
}
public static void GetObjectPostAction(DataRow inputRow, DataTable dataTable, DataObjectStore store)
{
DataRow dataRow = dataTable.Rows[0];
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)dataRow["RecipientTypeDetails"];
if (recipientTypeDetails == RecipientTypeDetails.LinkedMailbox)
{
dataRow["DomainUserName"] = (string)dataRow["LinkedMasterAccount"];
return;
}
RbacPrincipal rbacPrincipal = RbacPrincipal.Current;
if (rbacPrincipal.RbacConfiguration.SecurityAccessToken != null && rbacPrincipal.RbacConfiguration.SecurityAccessToken.LogonName != null)
{
dataRow["DomainUserName"] = rbacPrincipal.RbacConfiguration.SecurityAccessToken.LogonName;
return;
}
dataRow["DomainUserName"] = string.Format("{0}\\{1}", ((ADObjectId)dataRow["Identity"]).DomainId.Name, (string)dataRow["SamAccountName"]);
}
protected override bool ProcessInternal(PropertyBag propertyBag)
{
if (!RecipientTypeFilter.HasObjectId(propertyBag))
{
ExTraceGlobals.BackSyncTracer.TraceDebug((long)SyncConfiguration.TraceId, "RecipientTypeFilter:: - Skipping object {0}. No object id set on object.", new object[]
{
propertyBag[ADObjectSchema.Id]
});
this.reporter.ReportExcludedObject(propertyBag, DirectoryObjectErrorCode.ObjectOutOfScope, ProcessingStage.RecipientTypeFilter);
return(false);
}
if (ProcessorHelper.IsDeletedObject(propertyBag))
{
return(!ProvisioningTasksConfigImpl.UseBecAPIsforLiveId || !ProcessorHelper.IsUserObject(propertyBag));
}
if (RecipientTypeFilter.IsObjectExcluded(propertyBag))
{
ExTraceGlobals.BackSyncTracer.TraceDebug((long)SyncConfiguration.TraceId, "RecipientTypeFilter:: - Skipping object {0}. It's marked as excluded form backsync.", new object[]
{
propertyBag[ADObjectSchema.Id]
});
this.reporter.ReportExcludedObject(propertyBag, DirectoryObjectErrorCode.UnspecifiedError, ProcessingStage.RecipientTypeFilter);
return(false);
}
bool flag;
if (!ProcessorHelper.IsObjectOrganizationUnit(propertyBag))
{
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)propertyBag[ADRecipientSchema.RecipientTypeDetails];
flag = this.IsAcceptedRecipientType(recipientTypeDetails);
if (!flag)
{
ExTraceGlobals.BackSyncTracer.TraceDebug <object, RecipientTypeDetails>((long)SyncConfiguration.TraceId, "RecipientTypeFilter:: - Skipping object {0}. Recipient type {1} is not included in backsync.", propertyBag[SyncObjectSchema.ObjectId], recipientTypeDetails);
this.reporter.ReportExcludedObject(propertyBag, DirectoryObjectErrorCode.ObjectOutOfScope, ProcessingStage.RecipientTypeFilter);
}
}
else
{
flag = true;
}
return(flag);
}
private static RecipientDisplayType CalculateTargetRDT(RecipientTypeDetails sourceRTD, bool isSecurityPrincipal)
{
if (sourceRTD <= RecipientTypeDetails.RoomMailbox)
{
if (sourceRTD <= RecipientTypeDetails.SharedMailbox)
{
if (sourceRTD < RecipientTypeDetails.UserMailbox)
{
goto IL_4C;
}
switch ((int)(sourceRTD - RecipientTypeDetails.UserMailbox))
{
case 0:
case 1:
case 2:
case 3:
goto IL_4C;
}
}
if (sourceRTD == RecipientTypeDetails.RoomMailbox)
{
return(RecipientDisplayType.ConferenceRoomMailbox);
}
}
else
{
if (sourceRTD == RecipientTypeDetails.EquipmentMailbox)
{
return(RecipientDisplayType.EquipmentMailbox);
}
if (sourceRTD != RecipientTypeDetails.TeamMailbox)
{
}
}
IL_4C:
if (!isSecurityPrincipal)
{
return(RecipientDisplayType.MailboxUser);
}
return(RecipientDisplayType.ACLableMailboxUser);
}
private static RecipientDisplayType CalculateSourceRDT(RecipientTypeDetails originalRTD, bool isSecurityPrincipal)
{
if (originalRTD <= RecipientTypeDetails.RoomMailbox)
{
if (originalRTD <= RecipientTypeDetails.SharedMailbox)
{
if (originalRTD < RecipientTypeDetails.UserMailbox)
{
goto IL_54;
}
switch ((int)(originalRTD - RecipientTypeDetails.UserMailbox))
{
case 0:
case 1:
case 2:
case 3:
goto IL_54;
}
}
if (originalRTD == RecipientTypeDetails.RoomMailbox)
{
return(RecipientDisplayType.SyncedConferenceRoomMailbox);
}
}
else
{
if (originalRTD == RecipientTypeDetails.EquipmentMailbox)
{
return(RecipientDisplayType.SyncedEquipmentMailbox);
}
if (originalRTD != RecipientTypeDetails.TeamMailbox)
{
}
}
IL_54:
if (!isSecurityPrincipal)
{
return(RecipientDisplayType.SyncedMailboxUser);
}
return(RecipientDisplayType.ACLableSyncedMailboxUser);
}
protected override void DoLoad(OwaIdentity logonIdentity, OwaIdentity mailboxIdentity, UserContextStatistics stats)
{
HttpContext httpContext = HttpContext.Current;
RequestDetailsLogger current = RequestDetailsLoggerBase <RequestDetailsLogger> .GetCurrent(httpContext);
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.UserContextLoadBegin);
base.DoLoad(logonIdentity, mailboxIdentity, stats);
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.GetOWAMiniRecipientBegin);
Stopwatch stopwatch = Stopwatch.StartNew();
OWAMiniRecipient owaminiRecipient = base.LogonIdentity.GetOWAMiniRecipient();
stats.MiniRecipientCreationTime = (int)stopwatch.ElapsedMilliseconds;
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.GetOWAMiniRecipientEnd);
base.LogTrace("UserContext.Load", "GetOWAMiniRecipient finished");
this.sipUri = ADPersonToContactConverter.GetSipUri(owaminiRecipient);
stopwatch.Restart();
this.IsBposUser = CapabilityHelper.HasBposSKUCapability(owaminiRecipient.PersistedCapabilities);
stats.SKUCapabilityTestTime = (int)stopwatch.ElapsedMilliseconds;
base.LogTrace("UserContext.Load", "HasBposSKUCapability finished");
if (Globals.IsFirstReleaseFlightingEnabled)
{
this.CreateFeatureManagerFactory(owaminiRecipient);
}
else
{
RecipientTypeDetails recipientTypeDetails = base.ExchangePrincipal.RecipientTypeDetails;
this.featuresManagerFactory = new FeaturesManagerFactory(owaminiRecipient, new ConfigurationContext(this), new ScopeFlightsSettingsProvider(), (VariantConfigurationSnapshot c) => new FeaturesStateOverride(c, recipientTypeDetails), string.Empty, false);
}
this.BposSkuCapability = string.Empty;
if (this.IsBposUser)
{
Capability?skucapability = CapabilityHelper.GetSKUCapability(owaminiRecipient.PersistedCapabilities);
if (skucapability != null)
{
this.BposSkuCapability = skucapability.ToString();
}
}
this.LogEventCommonData = new LogEventCommonData(this);
this.IsGroupUserContext = (base.IsExplicitLogon && base.ExchangePrincipal.RecipientTypeDetails == RecipientTypeDetails.GroupMailbox);
RequestDetailsLogger.LogEvent(current, OwaServerLogger.LoggerData.UserContextLoadEnd);
}
public static string GenerateUserTypeText(object userType)
{
if (userType == DBNull.Value)
{
return(string.Empty);
}
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)userType;
if (recipientTypeDetails != RecipientTypeDetails.UserMailbox)
{
if (recipientTypeDetails == RecipientTypeDetails.MailContact)
{
return(Strings.MailContact);
}
if (recipientTypeDetails != RecipientTypeDetails.MailUser)
{
return(userType.ToString());
}
}
return(Strings.MailUser);
}
protected override bool ProcessInternal(PropertyBag propertyBag)
{
foreach (KeyValuePair <ADPropertyDefinition, RecipientTypeDetails> keyValuePair in this.filterMap)
{
ADPropertyDefinition key = keyValuePair.Key;
RecipientTypeDetails value = keyValuePair.Value;
if (RecipientTypeSpecificPropertyFilter.ShouldFilterOutProperty(propertyBag, key, value))
{
ExTraceGlobals.BackSyncTracer.TraceDebug <string, object, RecipientTypeDetails>((long)SyncConfiguration.TraceId, "RecipientTypeSpecificPropertyFilter:: - Removing property {0} from object {1}. It should not be backsycned for recipient of type {2}.", key.Name, propertyBag[ADObjectSchema.Id], value);
bool isReadOnly = propertyBag.IsReadOnly;
try
{
propertyBag.SetIsReadOnly(false);
propertyBag.Remove(key);
}
finally
{
propertyBag.SetIsReadOnly(isReadOnly);
}
}
}
return(true);
}
public static bool IsPublicFolder(ADRawEntry recipient)
{
RecipientTypeDetails recipientTypeDetails = (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails];
return(recipientTypeDetails == RecipientTypeDetails.PublicFolder);
}
public static bool IsMembershipGroupTypeDetail(RecipientTypeDetails typeDetails)
{
return(SearchRecipient.GroupRecipientTypeDetail.Any((RecipientTypeDetails t) => t == typeDetails));
}
public static bool IsMembershipGroup(ADRawEntry recipient)
{
RecipientTypeDetails typeDetails = (RecipientTypeDetails)recipient[ADRecipientSchema.RecipientTypeDetails];
return(SearchRecipient.IsMembershipGroupTypeDetail(typeDetails));
}
