protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject)
{
if (dataObject == null)
{
return(null);
}
ADUser dataObject2 = (ADUser)dataObject;
SyncMailbox syncMailbox = new SyncMailbox(dataObject2);
syncMailbox.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailbox.AcceptMessagesOnlyFrom));
syncMailbox.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailbox.AcceptMessagesOnlyFromDLMembers));
syncMailbox.propertyBag.SetField(ADRecipientSchema.RejectMessagesFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailbox.RejectMessagesFrom));
syncMailbox.propertyBag.SetField(ADRecipientSchema.RejectMessagesFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailbox.RejectMessagesFromDLMembers));
if (syncMailbox.MailboxPlan != null)
{
ADUser aduser = base.ProvisioningCache.TryAddAndGetOrganizationDictionaryValue <ADUser, ADObjectId>(CannedProvisioningCacheKeys.CacheKeyMailboxPlanId, base.CurrentOrganizationId, syncMailbox.MailboxPlan, () => (ADUser)this.GetDataObject <ADUser>(new MailboxPlanIdParameter(syncMailbox.MailboxPlan), this.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorMailboxPlanNotFound(syncMailbox.MailboxPlan.ToString())), new LocalizedString?(Strings.ErrorMailboxPlanNotUnique(syncMailbox.MailboxPlan.ToString()))));
syncMailbox.propertyBag.SetField(SyncMailboxSchema.MailboxPlanName, aduser.DisplayName);
}
if (this.outputCookie != null)
{
syncMailbox.propertyBag.SetField(SyncMailboxSchema.Cookie, this.outputCookie.ToBytes());
if (this.outputCookie.HighWatermark == 0L)
{
syncMailbox.propertyBag.SetField(SyncMailboxSchema.EndOfList, true);
}
}
syncMailbox.ResetChangeTracking();
return(syncMailbox);
}
protected override IConfigDataProvider CreateSession()
{
IRecipientSession sessionForDeletedObjects = MailboxTaskHelper.GetSessionForDeletedObjects(this.DomainController, base.CurrentOrganizationId, base.ExecutingUserOrganizationId);
this.inputCookie = SyncTaskHelper.ResolveSyncCookie(this.Cookie, sessionForDeletedObjects, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError));
return(sessionForDeletedObjects);
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
ADUser aduser = (ADUser)base.PrepareDataObject();
aduser.BypassModerationCheck = true;
if (this.SmtpAndX500Addresses != null && this.SmtpAndX500Addresses.Count > 0)
{
aduser.EmailAddresses = SyncTaskHelper.ReplaceSmtpAndX500Addresses(this.SmtpAndX500Addresses, aduser.EmailAddresses);
}
if (base.Fields.IsModified("SipAddresses"))
{
aduser.EmailAddresses = SyncTaskHelper.ReplaceSipAddresses(this.SipAddresses, aduser.EmailAddresses);
}
if (this.DataObject != null && this.DataObject.IsModified(MailEnabledRecipientSchema.EmailAddresses))
{
aduser.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, this.DataObject.EmailAddresses, this.DataObject, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
aduser.EmailAddresses = SyncTaskHelper.UpdateSipNameEumProxyAddress(aduser.EmailAddresses);
}
if (base.Fields.IsModified(SyncMailboxSchema.ReleaseTrack))
{
aduser.ReleaseTrack = this.ReleaseTrack;
}
if (base.Fields.IsModified(MailboxSchema.ArchiveGuid))
{
aduser.ArchiveGuid = this.ArchiveGuid;
}
if (this.DataObject.IsModified(SyncMailboxSchema.AccountDisabled))
{
SyncTaskHelper.SetExchangeAccountDisabledWithADLogon(aduser, this.DataObject.AccountDisabled);
}
TaskLogger.LogExit();
return(aduser);
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
ADUser aduser = (ADUser)base.PrepareDataObject();
aduser.BypassModerationCheck = true;
if (base.Fields.IsModified("IntendedMailboxPlan"))
{
aduser.IntendedMailboxPlan = ((this.intendedMailboxPlanObject == null) ? null : this.intendedMailboxPlanObject.Id);
}
if (this.SmtpAndX500Addresses != null && this.SmtpAndX500Addresses.Count > 0)
{
aduser.EmailAddresses = SyncTaskHelper.ReplaceSmtpAndX500Addresses(this.SmtpAndX500Addresses, aduser.EmailAddresses);
}
if (base.Fields.IsModified("ReleaseTrack"))
{
aduser.ReleaseTrack = this.ReleaseTrack;
}
if (base.Fields.IsModified("SipAddresses"))
{
aduser.EmailAddresses = SyncTaskHelper.ReplaceSipAddresses(this.SipAddresses, aduser.EmailAddresses);
}
if (this.DataObject.IsModified(MailEnabledRecipientSchema.EmailAddresses))
{
aduser.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, this.DataObject.EmailAddresses, this.DataObject, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
TaskLogger.LogExit();
return(aduser);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
base.ValidateReferenceParameter(SyncDistributionGroupSchema.RawManagedBy, SyncTaskHelper.ValidateWithBaseObjectBypassADUser <ADGroup>(new ValidateRecipientWithBaseObjectDelegate <ADGroup>(MailboxTaskHelper.ValidateGroupManagedBy)));
base.ValidateMultiReferenceParameter("RawCoManagedBy", SyncTaskHelper.ValidateWithBaseObjectBypassADUser <ADGroup>(new ValidateRecipientWithBaseObjectDelegate <ADGroup>(MailboxTaskHelper.ValidateGroupManagedBy)));
base.ValidateMultiReferenceParameter("RawMembers", SyncTaskHelper.ValidateWithBaseObjectBypassADUser <ADGroup>(new ValidateRecipientWithBaseObjectDelegate <ADGroup>(MailboxTaskHelper.ValidateGroupMember)));
TaskLogger.LogExit();
}
protected override void WriteResult <T>(IEnumerable <T> dataObjects)
{
if (base.ParameterSetName == "CookieSet")
{
SyncTaskHelper.HandleTaskWritePagedResult <ADContact>((IEnumerable <ADContact>)dataObjects, this.inputCookie, ref this.outputCookie, () => base.Stopping, new SyncTaskHelper.OneParameterMethod <bool, IConfigurable>(base.ShouldSkipObject), new SyncTaskHelper.VoidOneParameterMethod <IConfigurable>(this.WriteResult), this.Pages, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError));
return;
}
base.WriteResult <T>(dataObjects);
}
protected override void PrepareRecipientObject(ADGroup group)
{
TaskLogger.LogEnter();
base.PrepareRecipientObject(group);
if (base.ManagedBy == null)
{
MultiValuedProperty <ADObjectId> multiValuedProperty = new MultiValuedProperty <ADObjectId>();
RoleGroupIdParameter roleGroupIdParameter = new RoleGroupIdParameter("Organization Management");
ADGroup adgroup = (ADGroup)base.GetDataObject <ADGroup>(roleGroupIdParameter, base.TenantGlobalCatalogSession, null, null, new LocalizedString?(Strings.ErrorRecipientNotFound(roleGroupIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(roleGroupIdParameter.ToString())), ExchangeErrorCategory.Client);
multiValuedProperty.Add(adgroup.Id);
group.ManagedBy = multiValuedProperty;
}
group.BypassModerationCheck = true;
if (base.Fields.IsModified(ADRecipientSchema.GrantSendOnBehalfTo) && this.grantSendOnBehalfTo != null)
{
foreach (ADRecipient adrecipient in this.grantSendOnBehalfTo)
{
group.GrantSendOnBehalfTo.Add(adrecipient.Identity as ADObjectId);
}
}
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFrom))
{
group.BypassModerationFrom = this.bypassModerationFrom;
}
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFromDLMembers))
{
group.BypassModerationFromDLMembers = this.bypassModerationFromDLMembers;
}
if (this.DataObject != null && this.DataObject.IsModified(ADRecipientSchema.EmailAddresses))
{
group.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, this.DataObject.EmailAddresses, this.DataObject, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFrom))
{
group.AcceptMessagesOnlyFrom = (from c in this.acceptMessagesOnlyFrom
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers))
{
group.AcceptMessagesOnlyFromDLMembers = (from c in this.acceptMessagesOnlyFromDLMembers
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFrom))
{
group.RejectMessagesFrom = (from c in this.rejectMessagesFrom
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFromDLMembers))
{
group.RejectMessagesFromDLMembers = (from c in this.rejectMessagesFromDLMembers
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
group.ReportToOriginatorEnabled = this.ReportToOriginatorEnabled;
group.RequireAllSendersAreAuthenticated = this.RequireSenderAuthenticationEnabled;
TaskLogger.LogExit();
}
protected override IConfigDataProvider CreateSession()
{
IRecipientSession recipientSession = (IRecipientSession)base.CreateSession();
if (base.ParameterSetName == "CookieSet")
{
recipientSession.UseGlobalCatalog = true;
this.inputCookie = SyncTaskHelper.ResolveSyncCookie(this.Cookie, recipientSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError));
}
return(recipientSession);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
bool flag = false;
if (base.Fields.IsModified(ADGroupSchema.Members))
{
if (this.DataObject.RoleGroupType == RoleGroupType.Linked)
{
base.WriteError(new RecipientTaskException(Strings.ErrorLinkedRoleGroupCannotHaveMembers), (ErrorCategory)1000, null);
}
List <ADObjectId> list = null;
SecurityPrincipalIdParameter[] parameters = this.GetChangedValues(true);
SecurityPrincipalIdParameter[] changedValues = this.GetChangedValues(false);
if (this.Members == null || !this.Members.IsChangesOnlyCopy)
{
flag = true;
if (this.Members != null)
{
parameters = this.Members.ToArray();
}
list = this.DataObject.Members.ToList <ADObjectId>();
this.DataObject.Members = new MultiValuedProperty <ADObjectId>();
}
SyncTaskHelper.ResolveModifiedMultiReferenceParameter <SecurityPrincipalIdParameter>("Members", "AddedMembers", parameters, new GetRecipientDelegate <SecurityPrincipalIdParameter>(this.GetRecipient), this.ReferenceErrorReporter, this.recipientIdsDictionary, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.ValidateModifiedMultiReferenceParameter <ADGroup>("Members", "AddedMembers", this.DataObject, new ValidateRecipientWithBaseObjectDelegate <ADGroup>(MailboxTaskHelper.ValidateGroupMember), this.ReferenceErrorReporter, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.AddModifiedRecipientIds("AddedMembers", SyncDistributionGroupSchema.Members, this.DataObject, this.recipientIdsDictionary);
if (flag)
{
MultiValuedProperty <ADObjectId> multiValuedProperty = new MultiValuedProperty <ADObjectId>();
foreach (ADObjectId item in list)
{
if (!this.DataObject.Members.Contains(item))
{
multiValuedProperty.Add(item);
}
}
this.recipientIdsDictionary["RemovedMembers"] = multiValuedProperty;
}
else
{
SyncTaskHelper.ResolveModifiedMultiReferenceParameter <SecurityPrincipalIdParameter>("Members", "RemovedMembers", changedValues, new GetRecipientDelegate <SecurityPrincipalIdParameter>(this.GetRecipient), this.ReferenceErrorReporter, this.recipientIdsDictionary, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.RemoveModifiedRecipientIds("RemovedMembers", SyncDistributionGroupSchema.Members, this.DataObject, this.recipientIdsDictionary);
}
}
MailboxTaskHelper.ValidateAddedMembers(base.TenantGlobalCatalogSession, this.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>));
if (this.recipientIdsDictionary.ContainsKey("RemovedMembers") && this.recipientIdsDictionary["RemovedMembers"].Count > 0)
{
RoleAssignmentsGlobalConstraints roleAssignmentsGlobalConstraints = new RoleAssignmentsGlobalConstraints(this.ConfigurationSession, base.TenantGlobalCatalogSession, new Task.ErrorLoggerDelegate(base.WriteError));
roleAssignmentsGlobalConstraints.ValidateIsSafeToRemoveRoleGroupMember(this.DataObject, new List <ADObjectId>(this.recipientIdsDictionary["RemovedMembers"]));
}
TaskLogger.LogExit();
}
private void UpdateMembersWhenRawMembersChanged()
{
if (this.addedValues.Length > 0)
{
SyncTaskHelper.ResolveModifiedMultiReferenceParameter <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >("RawMembers", "AddedMembers", this.addedValues, new GetRecipientDelegate <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >(this.GetRecipient), this.ReferenceErrorReporter, this.recipientIdsDictionary, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.ValidateModifiedMultiReferenceParameter <ADGroup>("RawMembers", "AddedMembers", this.DataObject, SyncTaskHelper.ValidateWithBaseObjectBypassADUser <ADGroup>(new ValidateRecipientWithBaseObjectDelegate <ADGroup>(MailboxTaskHelper.ValidateGroupMember)), this.ReferenceErrorReporter, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.AddModifiedRecipientIds("AddedMembers", SyncDistributionGroupSchema.Members, this.DataObject, this.recipientIdsDictionary, new Func <ADGroup, ADObjectId, IConfigDataProvider, bool>(MailboxTaskHelper.GroupContainsMember), base.TenantGlobalCatalogSession);
}
if (this.removedValues.Length > 0)
{
SyncTaskHelper.ResolveModifiedMultiReferenceParameter <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >("RawMembers", "RemovedMembers", this.removedValues, new GetRecipientDelegate <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >(this.GetRecipient), this.ReferenceErrorReporter, this.recipientIdsDictionary, this.recipientsDictionary, this.parameterDictionary);
SyncTaskHelper.RemoveModifiedRecipientIds("RemovedMembers", SyncDistributionGroupSchema.Members, this.DataObject, this.recipientIdsDictionary, new Func <ADGroup, ADObjectId, IConfigDataProvider, bool>(MailboxTaskHelper.GroupContainsMember), base.TenantGlobalCatalogSession);
}
}
protected override IEnumerable <ADRawEntry> GetPagedData()
{
if (this.Cookie == null)
{
DeletedRecipient item = new DeletedRecipient();
return(new List <ADRawEntry>
{
item
});
}
PropertyDefinition[] properties = new PropertyDefinition[]
{
ADObjectSchema.Id,
ADObjectSchema.Name,
ADObjectSchema.DistinguishedName,
ADObjectSchema.Guid,
ADObjectSchema.OrganizationalUnitRoot,
ADObjectSchema.ObjectClass,
ADObjectSchema.WhenChanged,
ADObjectSchema.WhenChangedUTC,
ADObjectSchema.WhenCreated,
ADObjectSchema.WhenCreatedUTC
};
if (this.requireTwoQueries)
{
IRecipientSession sessionForSoftDeletedObjects = SoftDeletedTaskHelper.GetSessionForSoftDeletedObjects(base.CurrentOrganizationId, this.DomainController);
ADObjectId childId = base.CurrentOrganizationId.OrganizationalUnit.GetChildId("OU", "Soft Deleted Objects");
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.IsSoftDeletedByRemove, true);
queryFilter = new AndFilter(new QueryFilter[]
{
queryFilter,
SyncTaskHelper.GetDeltaFilter(this.inputCookie)
});
this.reader2 = sessionForSoftDeletedObjects.FindPagedADRawEntry(childId, QueryScope.OneLevel, queryFilter, null, this.PageSize, properties);
this.reader2.Cookie = this.inputCookie.PageCookie2;
base.WriteVerbose(TaskVerboseStringHelper.GetFindDataObjectsVerboseString(sessionForSoftDeletedObjects, typeof(ADRawEntry), queryFilter, null, false));
}
IRecipientSession recipientSession = (IRecipientSession)base.DataSession;
ADObjectId deletedObjectsContainer = ADSession.GetDeletedObjectsContainer(recipientSession.GetDomainNamingContext());
QueryFilter internalFilter = this.InternalFilter;
recipientSession.SessionSettings.SkipCheckVirtualIndex = true;
ADPagedReader <ADRawEntry> adpagedReader = recipientSession.FindPagedADRawEntry(deletedObjectsContainer, QueryScope.OneLevel, internalFilter, null, this.PageSize, properties);
adpagedReader.IncludeDeletedObjects = true;
adpagedReader.Cookie = this.inputCookie.PageCookie;
base.WriteVerbose(TaskVerboseStringHelper.GetFindDataObjectsVerboseString(base.DataSession, typeof(ADRawEntry), this.InternalFilter, null, false));
return(adpagedReader);
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
base.DataSession.Save(this.DataObject);
base.WriteVerbose(Strings.VerboseSettingPassword(this.DataObject.Id.ToString()));
MailboxTaskHelper.SetMailboxPassword((IRecipientSession)base.DataSession, this.DataObject, null, new Task.ErrorLoggerDelegate(base.WriteError));
this.DataObject = (ADUser)base.DataSession.Read <ADUser>(this.DataObject.Identity);
this.DataObject[ADUserSchema.PasswordLastSetRaw] = new long?(-1L);
this.DataObject.UserAccountControl = UserAccountControlFlags.NormalAccount;
if (base.Fields.IsModified(SyncMailUserSchema.AccountDisabled))
{
SyncTaskHelper.SetExchangeAccountDisabled(this.DataObject, this.AccountDisabled);
}
base.InternalProcessRecord();
TaskLogger.LogExit();
}
protected override void WriteResult <T>(IEnumerable <T> dataObjects)
{
SyncTaskHelper.OneParameterMethod <bool, IConfigurable> oneParameterMethod = null;
SyncTaskHelper.OneParameterMethod <bool, IConfigurable> oneParameterMethod2 = null;
ADRawEntry adrawEntry = null;
if (dataObjects is ADPagedReader <ADRawEntry> )
{
bool flag;
if (this.requireTwoQueries)
{
IEnumerable <ADRawEntry> dataObjects2 = (IEnumerable <ADRawEntry>)dataObjects;
IEnumerable <ADRawEntry> dataObjects3 = this.reader2;
SyncCookie syncCookie = this.inputCookie;
SyncTaskHelper.ParameterlessMethod <bool> isStopping = () => base.Stopping;
if (oneParameterMethod == null)
{
oneParameterMethod = ((IConfigurable dataObject) => false);
}
this.searchNeedsRetry = !SyncTaskHelper.HandleTaskWritePagedResult <ADRawEntry>(dataObjects2, dataObjects3, syncCookie, ref this.outputCookie, isStopping, oneParameterMethod, new SyncTaskHelper.VoidOneParameterMethod <IConfigurable>(this.WriteResult), this.Pages, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError), out flag);
}
else
{
IEnumerable <ADRawEntry> dataObjects4 = (IEnumerable <ADRawEntry>)dataObjects;
SyncCookie syncCookie2 = this.inputCookie;
SyncTaskHelper.ParameterlessMethod <bool> isStopping2 = () => base.Stopping;
if (oneParameterMethod2 == null)
{
oneParameterMethod2 = ((IConfigurable dataObject) => false);
}
this.searchNeedsRetry = !SyncTaskHelper.HandleTaskWritePagedResult <ADRawEntry>(dataObjects4, syncCookie2, ref this.outputCookie, isStopping2, oneParameterMethod2, new SyncTaskHelper.VoidOneParameterMethod <IConfigurable>(this.WriteResult), this.Pages, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError), out flag);
}
if (!this.searchNeedsRetry && !flag)
{
adrawEntry = new DeletedRecipient();
}
}
else
{
adrawEntry = ((List <ADRawEntry>)dataObjects)[0];
}
if (adrawEntry != null)
{
this.outputCookie = new SyncCookie(this.inputCookie.DomainController, this.inputCookie.HighWatermarks, WatermarkMap.Empty, null);
this.WriteResult(adrawEntry);
}
}
protected override IConfigDataProvider CreateSession()
{
IRecipientSession recipientSession = (IRecipientSession)base.CreateSession();
ADObjectId rootId = recipientSession.SearchRoot;
if (this.SoftDeletedMailUser.IsPresent && base.CurrentOrganizationId != null && base.CurrentOrganizationId.OrganizationalUnit != null)
{
rootId = new ADObjectId("OU=Soft Deleted Objects," + base.CurrentOrganizationId.OrganizationalUnit.DistinguishedName);
}
if (this.SoftDeletedMailUser.IsPresent)
{
recipientSession = SoftDeletedTaskHelper.GetSessionForSoftDeletedObjects(recipientSession, rootId);
}
if (base.ParameterSetName == "CookieSet")
{
recipientSession.UseGlobalCatalog = true;
this.inputCookie = SyncTaskHelper.ResolveSyncCookie(this.Cookie, recipientSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskErrorLoggingDelegate(base.WriteError));
}
return(recipientSession);
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
ADContact adcontact = (ADContact)base.PrepareDataObject();
adcontact.BypassModerationCheck = true;
if (this.SmtpAndX500Addresses != null && this.SmtpAndX500Addresses.Count > 0)
{
adcontact.EmailAddresses = SyncTaskHelper.ReplaceSmtpAndX500Addresses(this.SmtpAndX500Addresses, adcontact.EmailAddresses);
}
if (base.Fields.IsModified("SipAddresses"))
{
adcontact.EmailAddresses = SyncTaskHelper.ReplaceSipAddresses(this.SipAddresses, adcontact.EmailAddresses);
}
if (adcontact.IsModified(MailEnabledRecipientSchema.EmailAddresses))
{
adcontact.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, adcontact.EmailAddresses, adcontact, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
TaskLogger.LogExit();
return(adcontact);
}
protected override IConfigurable ConvertDataObjectToPresentationObject(IConfigurable dataObject)
{
if (dataObject == null)
{
return(null);
}
ADContact dataObject2 = (ADContact)dataObject;
SyncMailContact syncMailContact = new SyncMailContact(dataObject2);
syncMailContact.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.AcceptMessagesOnlyFrom));
syncMailContact.propertyBag.SetField(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.AcceptMessagesOnlyFromDLMembers));
syncMailContact.propertyBag.SetField(ADRecipientSchema.RejectMessagesFrom, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.RejectMessagesFrom));
syncMailContact.propertyBag.SetField(ADRecipientSchema.RejectMessagesFromDLMembers, SyncTaskHelper.RetrieveFullADObjectId(base.TenantGlobalCatalogSession, syncMailContact.RejectMessagesFromDLMembers));
if (this.outputCookie != null)
{
syncMailContact.propertyBag.SetField(SyncMailContactSchema.Cookie, this.outputCookie.ToBytes());
if (this.outputCookie.HighWatermark == 0L)
{
syncMailContact.propertyBag.SetField(SyncMailContactSchema.EndOfList, true);
}
}
return(syncMailContact);
}
private void InternalResolveLocalSecondaryIdentities()
{
SyncMailUser syncMailUser = (SyncMailUser)this.GetDynamicParameters();
base.SetReferenceParameter <UserContactIdParameter>(SyncMailUserSchema.Manager, this.Manager, syncMailUser, new GetRecipientDelegate <UserContactIdParameter>(this.GetRecipient));
base.SetReferenceParameter <RecipientIdParameter>(MailUserSchema.ForwardingAddress, this.ForwardingAddress, syncMailUser, new GetRecipientDelegate <RecipientIdParameter>(this.GetRecipient));
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFrom, this.BypassModerationFrom, syncMailUser, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual));
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFromDLMembers, this.BypassModerationFromDLMembers, syncMailUser, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionGroup));
if (base.Fields.IsModified("IntendedMailboxPlan"))
{
this.intendedMailboxPlanObject = null;
if (this.IntendedMailboxPlanName != null)
{
this.intendedMailboxPlanObject = base.ProvisioningCache.TryAddAndGetOrganizationDictionaryValue <ADUser, string>(CannedProvisioningCacheKeys.CacheKeyMailboxPlanIdParameterId, base.CurrentOrganizationId, this.IntendedMailboxPlanName.RawIdentity, () => (ADUser)base.GetDataObject <ADUser>(this.IntendedMailboxPlanName, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorMailboxPlanNotFound(this.IntendedMailboxPlanName.ToString())), new LocalizedString?(Strings.ErrorMailboxPlanNotUnique(this.IntendedMailboxPlanName.ToString())), ExchangeErrorCategory.Client));
}
}
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawAcceptMessagesOnlyFrom", MailEnabledRecipientSchema.AcceptMessagesOnlyFrom, this.RawAcceptMessagesOnlyFrom, "RawAcceptMessagesOnlyFrom", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawBypassModerationFrom", MailEnabledRecipientSchema.BypassModerationFrom, this.RawBypassModerationFrom, "RawBypassModerationFrom", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawRejectMessagesFrom", MailEnabledRecipientSchema.RejectMessagesFrom, this.RawRejectMessagesFrom, "RawRejectMessagesFrom", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawGrantSendOnBehalfTo", MailEnabledRecipientSchema.GrantSendOnBehalfTo, this.RawGrantSendOnBehalfTo, "RawGrantSendOnBehalfTo", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateGrantSendOnBehalfTo)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <ModeratorIDParameter> >("RawModeratedBy", MailEnabledRecipientSchema.ModeratedBy, this.RawModeratedBy, "RawModeratedBy", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <ModeratorIDParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(RecipientTaskHelper.ValidateModeratedBy)));
base.SetReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawForwardingAddress", MailUserSchema.ForwardingAddress, this.RawForwardingAddress, "RawForwardingAddress", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), null);
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawSiteMailboxOwners", SyncMailUserSchema.SiteMailboxOwners, this.RawSiteMailboxOwners, "RawSiteMailboxOwners", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(SetSyncMailUser.ValidateSiteMailboxUsers)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawSiteMailboxUsers", SyncMailUserSchema.SiteMailboxUsers, this.RawSiteMailboxUsers, "RawSiteMailboxUsers", syncMailUser, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(SetSyncMailUser.ValidateSiteMailboxUsers)));
if (base.Fields.IsModified(SyncMailUserSchema.SiteMailboxOwners))
{
MultiValuedProperty <ADObjectId> value = SetSyncMailUser.ResolveSiteMailboxOwnersReferenceParameter(this.SiteMailboxOwners, base.TenantGlobalCatalogSession, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), new WriteWarningDelegate(this.WriteWarning));
syncMailUser[SyncMailUserSchema.SiteMailboxOwners] = value;
}
base.SetMultiReferenceParameter <RecipientIdParameter>(SyncMailUserSchema.SiteMailboxUsers, SyncMailUserSchema.SiteMailboxUsers, this.SiteMailboxUsers, "SiteMailboxUsers", syncMailUser, new GetRecipientDelegate <RecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(SetSyncMailUser.ValidateSiteMailboxUsers));
}
private void InternalResolveLocalSecondaryIdentities()
{
SyncMailbox dataObject = (SyncMailbox)this.GetDynamicParameters();
base.SetReferenceParameter <UserContactIdParameter>(SyncMailboxSchema.Manager, this.Manager, dataObject, new GetRecipientDelegate <UserContactIdParameter>(this.GetRecipient));
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFrom, this.BypassModerationFrom, dataObject, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual));
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFromDLMembers, this.BypassModerationFromDLMembers, dataObject, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionGroup));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawAcceptMessagesOnlyFrom", MailEnabledRecipientSchema.AcceptMessagesOnlyFrom, this.RawAcceptMessagesOnlyFrom, "RawAcceptMessagesOnlyFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawBypassModerationFrom", MailEnabledRecipientSchema.BypassModerationFrom, this.RawBypassModerationFrom, "RawBypassModerationFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawRejectMessagesFrom", MailEnabledRecipientSchema.RejectMessagesFrom, this.RawRejectMessagesFrom, "RawRejectMessagesFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawGrantSendOnBehalfTo", MailEnabledRecipientSchema.GrantSendOnBehalfTo, this.RawGrantSendOnBehalfTo, "RawGrantSendOnBehalfTo", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateGrantSendOnBehalfTo)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <ModeratorIDParameter> >("RawModeratedBy", MailEnabledRecipientSchema.ModeratedBy, this.RawModeratedBy, "RawModeratedBy", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <ModeratorIDParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(RecipientTaskHelper.ValidateModeratedBy)));
base.SetReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawForwardingAddress", MailboxSchema.ForwardingAddress, this.RawForwardingAddress, "RawForwardingAddress", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), null);
}
protected override void PrepareRecipientObject(ADContact contact)
{
TaskLogger.LogEnter();
base.PrepareRecipientObject(contact);
contact.BypassModerationCheck = true;
if (base.Fields.IsModified("Manager"))
{
contact.Manager = ((this.manager == null) ? null : ((ADObjectId)this.manager.Identity));
}
if (base.Fields.IsModified(ADRecipientSchema.GrantSendOnBehalfTo) && this.grantSendOnBehalfTo != null)
{
foreach (ADRecipient adrecipient in this.grantSendOnBehalfTo)
{
contact.GrantSendOnBehalfTo.Add(adrecipient.Identity as ADObjectId);
}
}
if (!base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFromSendersOrMembers))
{
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFrom))
{
contact.BypassModerationFrom = this.bypassModerationFrom;
}
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFromDLMembers))
{
contact.BypassModerationFromDLMembers = this.bypassModerationFromDLMembers;
}
}
if (this.DataObject != null && this.DataObject.IsModified(ADRecipientSchema.EmailAddresses))
{
contact.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, this.DataObject.EmailAddresses, this.DataObject, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFrom))
{
contact.AcceptMessagesOnlyFrom = (from c in this.acceptMessagesOnlyFrom
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers))
{
contact.AcceptMessagesOnlyFromDLMembers = (from c in this.acceptMessagesOnlyFromDLMembers
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFrom))
{
contact.RejectMessagesFrom = (from c in this.rejectMessagesFrom
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFromDLMembers))
{
contact.RejectMessagesFromDLMembers = (from c in this.rejectMessagesFromDLMembers
select c.Identity as ADObjectId).ToArray <ADObjectId>();
}
if (base.Fields.IsModified(ADRecipientSchema.Certificate))
{
contact.UserCertificate = this.UserCertificate;
}
if (base.Fields.IsModified(ADRecipientSchema.SMimeCertificate))
{
contact.UserSMIMECertificate = this.UserSMimeCertificate;
}
if (base.Fields.IsModified(SyncMailContactSchema.CountryOrRegion))
{
contact.CountryOrRegion = this.CountryOrRegion;
}
TaskLogger.LogExit();
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
ADGroup adgroup = (ADGroup)base.PrepareDataObject();
adgroup.BypassModerationCheck = true;
if (this.SmtpAndX500Addresses != null && this.SmtpAndX500Addresses.Count > 0)
{
adgroup.EmailAddresses = SyncTaskHelper.ReplaceSmtpAndX500Addresses(this.SmtpAndX500Addresses, adgroup.EmailAddresses);
}
if (base.Fields.IsModified("SipAddresses"))
{
adgroup.EmailAddresses = SyncTaskHelper.ReplaceSipAddresses(this.SipAddresses, adgroup.EmailAddresses);
}
if (adgroup.IsModified(MailEnabledRecipientSchema.EmailAddresses))
{
adgroup.EmailAddresses = SyncTaskHelper.FilterDuplicateEmailAddresses(base.TenantGlobalCatalogSession, adgroup.EmailAddresses, adgroup, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning));
}
if (base.Fields.IsModified(ADGroupSchema.GroupType))
{
if (this.Type != GroupType.Distribution && this.Type != GroupType.Security)
{
base.WriteError(new RecipientTaskException(Strings.ErrorGroupTypeInvalid), ExchangeErrorCategory.Client, null);
}
bool flag = (adgroup.GroupType & GroupTypeFlags.SecurityEnabled) == GroupTypeFlags.SecurityEnabled;
if (this.Type == GroupType.Distribution && flag)
{
adgroup.GroupType &= (GroupTypeFlags)2147483647;
if ((adgroup.GroupType & GroupTypeFlags.Universal) == GroupTypeFlags.Universal)
{
adgroup.RecipientTypeDetails = RecipientTypeDetails.MailUniversalDistributionGroup;
}
else
{
adgroup.RecipientTypeDetails = RecipientTypeDetails.MailNonUniversalGroup;
}
base.DesiredRecipientType = adgroup.RecipientType;
if (!adgroup.IsChanged(ADRecipientSchema.RecipientDisplayType))
{
adgroup.RecipientDisplayType = new RecipientDisplayType?(RecipientDisplayType.DistributionGroup);
}
}
else if (this.Type == GroupType.Security && !flag)
{
if (adgroup.RecipientTypeDetails == RecipientTypeDetails.RoomList)
{
base.WriteError(new TaskInvalidOperationException(Strings.ErrorConvertNonUniversalDistributionGroup(adgroup.Identity.ToString())), ExchangeErrorCategory.Client, adgroup.Identity);
}
adgroup.GroupType |= GroupTypeFlags.SecurityEnabled;
if ((adgroup.GroupType & GroupTypeFlags.Universal) == GroupTypeFlags.Universal)
{
adgroup.RecipientTypeDetails = RecipientTypeDetails.MailUniversalSecurityGroup;
}
else
{
adgroup.RecipientTypeDetails = RecipientTypeDetails.MailNonUniversalGroup;
}
base.DesiredRecipientType = adgroup.RecipientType;
if (!adgroup.IsChanged(ADRecipientSchema.RecipientDisplayType))
{
adgroup.RecipientDisplayType = new RecipientDisplayType?(RecipientDisplayType.SecurityDistributionGroup);
}
}
}
TaskLogger.LogExit();
return(adgroup);
}
protected override void InternalBeginProcessing()
{
TaskLogger.LogEnter();
if (base.Fields.IsModified(SyncMailContactSchema.CountryOrRegion) && (this.DataObject.IsModified(SyncMailContactSchema.C) || this.DataObject.IsModified(SyncMailContactSchema.Co) || this.DataObject.IsModified(SyncMailContactSchema.CountryCode)))
{
base.WriteError(new RecipientTaskException(Strings.ErrorConflictCountryOrRegion), ExchangeErrorCategory.Client, null);
}
if ((this.SmtpAndX500Addresses != null && this.SmtpAndX500Addresses.Count > 0) || (this.SipAddresses != null && this.SipAddresses.Count > 0))
{
this.DataObject.EmailAddresses = SyncTaskHelper.MergeAddresses(this.SmtpAndX500Addresses, this.SipAddresses);
}
base.InternalBeginProcessing();
if (this.ValidationOrganization != null && !string.Equals(this.ValidationOrganization, base.CurrentOrganizationId.ToString(), StringComparison.OrdinalIgnoreCase))
{
base.ThrowTerminatingError(new ValidationOrgCurrentOrgNotMatchException(this.ValidationOrganization, base.CurrentOrganizationId.ToString()), ExchangeErrorCategory.Client, null);
}
if (base.Fields.IsModified("Manager"))
{
this.manager = MailboxTaskHelper.LookupManager(this.Manager, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), ExchangeErrorCategory.Client, base.TenantGlobalCatalogSession);
}
if (base.Fields.IsModified(ADRecipientSchema.GrantSendOnBehalfTo) && this.GrantSendOnBehalfTo != null && this.GrantSendOnBehalfTo.Length != 0)
{
this.grantSendOnBehalfTo = new MultiValuedProperty <ADRecipient>();
foreach (RecipientIdParameter recipientIdParameter in this.GrantSendOnBehalfTo)
{
ADRecipient item = (ADRecipient)base.GetDataObject <ADRecipient>(recipientIdParameter, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(recipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(recipientIdParameter.ToString())), ExchangeErrorCategory.Client);
this.grantSendOnBehalfTo.Add(item);
}
}
if (!base.Fields.IsModified(ADRecipientSchema.BypassModerationFromSendersOrMembers))
{
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFrom) && this.BypassModerationFrom != null)
{
MultiValuedProperty <ADObjectId> multiValuedProperty;
MultiValuedProperty <ADObjectId> multiValuedProperty2;
this.bypassModerationFromRecipient = SetMailEnabledRecipientObjectTask <MailContactIdParameter, SyncMailContact, ADContact> .ResolveAndSeparateMessageDeliveryRestrictionRecipientIdentities(this.BypassModerationFrom, "BypassModerationFrom", base.TenantGlobalCatalogSession, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), new Task.ErrorLoggerDelegate(base.WriteError), out multiValuedProperty, out multiValuedProperty2);
if (multiValuedProperty != null && multiValuedProperty.Count > 0)
{
base.ThrowTerminatingError(new RecipientTaskException(Strings.ErrorIndividualRecipientNeeded(multiValuedProperty[0].ToString())), ExchangeErrorCategory.Client, null);
}
this.bypassModerationFrom = multiValuedProperty2;
}
if (base.Fields.IsModified(MailEnabledRecipientSchema.BypassModerationFromDLMembers) && this.BypassModerationFromDLMembers != null)
{
MultiValuedProperty <ADObjectId> multiValuedProperty3;
MultiValuedProperty <ADObjectId> multiValuedProperty4;
this.bypassModerationFromDLMembersRecipient = SetMailEnabledRecipientObjectTask <MailContactIdParameter, SyncMailContact, ADContact> .ResolveAndSeparateMessageDeliveryRestrictionRecipientIdentities(this.BypassModerationFromDLMembers, "BypassModerationFromDLMembers", base.TenantGlobalCatalogSession, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADRecipient>), new Task.ErrorLoggerDelegate(base.WriteError), out multiValuedProperty3, out multiValuedProperty4);
if (multiValuedProperty4 != null && multiValuedProperty4.Count > 0)
{
base.ThrowTerminatingError(new RecipientTaskException(Strings.ErrorGroupRecipientNeeded(multiValuedProperty4[0].ToString())), ExchangeErrorCategory.Client, null);
}
this.bypassModerationFromDLMembers = multiValuedProperty3;
}
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFrom) && this.AcceptMessagesOnlyFrom != null && this.AcceptMessagesOnlyFrom.Length != 0)
{
this.acceptMessagesOnlyFrom = new MultiValuedProperty <ADRecipient>();
foreach (DeliveryRecipientIdParameter deliveryRecipientIdParameter in this.AcceptMessagesOnlyFrom)
{
ADRecipient item2 = (ADRecipient)base.GetDataObject <ADRecipient>(deliveryRecipientIdParameter, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(deliveryRecipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(deliveryRecipientIdParameter.ToString())), ExchangeErrorCategory.Client);
this.acceptMessagesOnlyFrom.Add(item2);
}
}
if (base.Fields.IsModified(ADRecipientSchema.AcceptMessagesOnlyFromDLMembers) && this.AcceptMessagesOnlyFromDLMembers != null && this.AcceptMessagesOnlyFromDLMembers.Length != 0)
{
this.acceptMessagesOnlyFromDLMembers = new MultiValuedProperty <ADRecipient>();
foreach (DeliveryRecipientIdParameter deliveryRecipientIdParameter2 in this.AcceptMessagesOnlyFromDLMembers)
{
ADRecipient item3 = (ADRecipient)base.GetDataObject <ADRecipient>(deliveryRecipientIdParameter2, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(deliveryRecipientIdParameter2.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(deliveryRecipientIdParameter2.ToString())), ExchangeErrorCategory.Client);
this.acceptMessagesOnlyFromDLMembers.Add(item3);
}
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFrom) && this.RejectMessagesFrom != null && this.RejectMessagesFrom.Length != 0)
{
this.rejectMessagesFrom = new MultiValuedProperty <ADRecipient>();
foreach (DeliveryRecipientIdParameter deliveryRecipientIdParameter3 in this.RejectMessagesFrom)
{
ADRecipient item4 = (ADRecipient)base.GetDataObject <ADRecipient>(deliveryRecipientIdParameter3, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(deliveryRecipientIdParameter3.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(deliveryRecipientIdParameter3.ToString())), ExchangeErrorCategory.Client);
this.rejectMessagesFrom.Add(item4);
}
}
if (base.Fields.IsModified(ADRecipientSchema.RejectMessagesFromDLMembers) && this.RejectMessagesFromDLMembers != null && this.RejectMessagesFromDLMembers.Length != 0)
{
this.rejectMessagesFromDLMembers = new MultiValuedProperty <ADRecipient>();
foreach (DeliveryRecipientIdParameter deliveryRecipientIdParameter4 in this.RejectMessagesFromDLMembers)
{
ADRecipient item5 = (ADRecipient)base.GetDataObject <ADRecipient>(deliveryRecipientIdParameter4, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(deliveryRecipientIdParameter4.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(deliveryRecipientIdParameter4.ToString())), ExchangeErrorCategory.Client);
this.rejectMessagesFromDLMembers.Add(item5);
}
}
TaskLogger.LogExit();
}
protected override void ResolveLocalSecondaryIdentities()
{
base.ResolveLocalSecondaryIdentities();
SyncDistributionGroup dataObject = (SyncDistributionGroup)this.GetDynamicParameters();
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFrom, this.BypassModerationFrom, dataObject, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual));
base.SetMultiReferenceParameter <DeliveryRecipientIdParameter>(MailEnabledRecipientSchema.BypassModerationFromDLMembers, this.BypassModerationFromDLMembers, dataObject, new GetRecipientDelegate <DeliveryRecipientIdParameter>(this.GetRecipient), new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionGroup));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawAcceptMessagesOnlyFrom", MailEnabledRecipientSchema.AcceptMessagesOnlyFrom, this.RawAcceptMessagesOnlyFrom, "RawAcceptMessagesOnlyFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawBypassModerationFrom", MailEnabledRecipientSchema.BypassModerationFrom, this.RawBypassModerationFrom, "RawBypassModerationFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >("RawRejectMessagesFrom", MailEnabledRecipientSchema.RejectMessagesFrom, this.RawRejectMessagesFrom, "RawRejectMessagesFrom", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <DeliveryRecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateMessageDeliveryRestrictionIndividual)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawGrantSendOnBehalfTo", MailEnabledRecipientSchema.GrantSendOnBehalfTo, this.RawGrantSendOnBehalfTo, "RawGrantSendOnBehalfTo", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(base.ValidateGrantSendOnBehalfTo)));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <ModeratorIDParameter> >("RawModeratedBy", MailEnabledRecipientSchema.ModeratedBy, this.RawModeratedBy, "RawModeratedBy", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <ModeratorIDParameter> >(this.GetRecipient), SyncTaskHelper.ValidateBypassADUser(new ValidateRecipientDelegate(RecipientTaskHelper.ValidateModeratedBy)));
base.SetReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >(ADGroupSchema.RawManagedBy, this.RawManagedBy, dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient));
base.SetMultiReferenceParameter <RecipientWithAdUserIdParameter <RecipientIdParameter> >("RawCoManagedBy", SyncDistributionGroupSchema.CoManagedBy, this.RawCoManagedBy, "RawCoManagedBy", dataObject, new GetRecipientDelegate <RecipientWithAdUserIdParameter <RecipientIdParameter> >(this.GetRecipient), null);
base.SetMultiReferenceParameter <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >("RawMembers", SyncDistributionGroupSchema.Members, this.RawMembers, "RawMembers", dataObject, new GetRecipientDelegate <RecipientWithAdUserGroupIdParameter <RecipientIdParameter> >(this.GetRecipient), null);
}
