internal T ResolveRecipientIdParameter <T>(RecipientIdParameter recipientIdParameter, IRecipientSession recipientSession) where T : ADRecipient, new()
{
if (recipientIdParameter == null)
{
return(default(T));
}
IEnumerable <T> objects = recipientIdParameter.GetObjects <T>(null, recipientSession);
T result = default(T);
using (IEnumerator <T> enumerator = objects.GetEnumerator())
{
if (!enumerator.MoveNext())
{
base.WriteError(new TaskException(Strings.NoRecipientsForRecipientId(recipientIdParameter.ToString())), ExchangeErrorCategory.Client, null);
}
result = enumerator.Current;
if (enumerator.MoveNext())
{
base.WriteError(new TaskException(Strings.MoreThanOneRecipientForRecipientId(recipientIdParameter.ToString())), ExchangeErrorCategory.Client, null);
}
}
if (string.IsNullOrEmpty(result.ExternalDirectoryObjectId))
{
base.WriteError(new TaskException(Strings.NoExternalDirectoryObjectIdForRecipientId(recipientIdParameter.ToString())), ExchangeErrorCategory.Client, null);
}
return(result);
}
internal static QueryFilter ToRecipientTypeDetailsFilter(RecipientTypeDetails[] typeDetailsWithVersionCheck, RecipientTypeDetails[] typeDetailsWithoutVersionCheck, ExchangeObjectVersion minVersion)
{
QueryFilter queryFilter = null;
if (typeDetailsWithVersionCheck != null && minVersion != null)
{
QueryFilter queryFilter2 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADObjectSchema.ExchangeVersion, minVersion);
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(typeDetailsWithVersionCheck);
queryFilter = new AndFilter(new QueryFilter[]
{
queryFilter2,
recipientTypeDetailsFilter
});
}
if (typeDetailsWithoutVersionCheck != null)
{
QueryFilter recipientTypeDetailsFilter2 = RecipientIdParameter.GetRecipientTypeDetailsFilter(typeDetailsWithoutVersionCheck);
queryFilter = ((queryFilter != null) ? new OrFilter(new QueryFilter[]
{
queryFilter,
recipientTypeDetailsFilter2
}) : recipientTypeDetailsFilter2);
}
return(queryFilter);
}
private void ExpandGroupMembership(ReducedRecipient groupRecipient, MultiValuedProperty <BindingMetadata> validatedRecipients)
{
QueryFilter filter = QueryFilter.AndTogether(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.MemberOfGroup, groupRecipient.Guid),
new ComparisonFilter(ComparisonOperator.Equal, SharedPropertyDefinitions.FfoExpansionSizeUpperBoundFilter, this.maxRecipientsLimit)
});
try
{
ADPagedReader <ADRawEntry> adpagedReader = this.recipientSession.FindPagedADRawEntry(null, QueryScope.SubTree, filter, null, 1000, ExchangeValidator.memberOfProperties);
foreach (ADRawEntry adrawEntry in adpagedReader)
{
RecipientIdParameter arg = RecipientIdParameter.Parse(adrawEntry.Id.ObjectGuid.ToString());
ReducedRecipient recipient = this.recipientGetter(arg, this.recipientSession);
this.VerifyAndAddRecipient(recipient, validatedRecipients, true);
}
}
catch (FfoSizeLimitReachedException ex)
{
base.LogOneEntry(ExecutionLog.EventType.Error, "InvalidArgument: {0}, Exception: {1}", new object[]
{
Strings.ErrorMaxMailboxLimitReachedInGroupExpansion(this.maxRecipientsLimit),
ex
});
base.WriteError(new ExValidatorException(Strings.ErrorMaxMailboxLimitReachedInGroupExpansion(this.maxRecipientsLimit), ex), ErrorCategory.InvalidArgument);
}
}
private ADUser ResolveUser(RecipientIdParameter id, out Exception ex)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
ADUser result = null;
ex = null;
try
{
result = (ADUser)this.getAdUser(id, this.adSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(id.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(id.ToString())), ExchangeErrorCategory.Client);
}
catch (ADTransientException ex2)
{
ex = ex2;
}
catch (ADExternalException ex3)
{
ex = ex3;
}
catch (ADOperationException ex4)
{
ex = ex4;
}
catch (InvalidCastException ex5)
{
ex = ex5;
}
return(result);
}
protected QueryFilter ConstructQueryFilterWithCustomFilter(QueryFilter customFilter)
{
List <QueryFilter> list = new List <QueryFilter>();
RecipientType[] recipientTypes = this.RecipientTypes;
List <RecipientTypeDetails> list2 = new List <RecipientTypeDetails>();
if (this.InternalRecipientTypeDetails != null && this.InternalRecipientTypeDetails.Length > 0)
{
foreach (RecipientTypeDetails recipientTypeDetails in this.InternalRecipientTypeDetails)
{
RecipientType recipientType = RecipientTaskHelper.RecipientTypeDetailsToRecipientType(recipientTypeDetails);
if (recipientType != RecipientType.Invalid && Array.IndexOf <RecipientType>(this.RecipientTypes, recipientType) != -1)
{
list2.Add(recipientTypeDetails);
}
else if (base.IsVerboseOn)
{
base.WriteVerbose(Strings.VerboseRecipientTypeDetailsIgnored(recipientTypeDetails.ToString()));
}
}
if (list2.Count == 0)
{
base.WriteError(new ArgumentException(Strings.ErrorRecipientTypeDetailsConflictWithRecipientType), ErrorCategory.InvalidArgument, null);
}
}
QueryFilter internalFilter = base.InternalFilter;
if (internalFilter != null)
{
list.Add(internalFilter);
}
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(list2.ToArray());
if (recipientTypeDetailsFilter != null)
{
list.Add(recipientTypeDetailsFilter);
}
else
{
list.Add(RecipientIdParameter.GetRecipientTypeFilter(recipientTypes));
}
if (this.Organization != null)
{
QueryFilter item = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.OrganizationalUnitRoot, base.CurrentOrganizationId.OrganizationalUnit);
list.Add(item);
}
if (customFilter != null)
{
list.Add(customFilter);
}
if (list.Count != 1)
{
return(new AndFilter(list.ToArray()));
}
return(list[0]);
}
internal static SmtpAddress Lookup(RecipientIdParameter recipId, IRecipientSession recipSession, OrganizationId orgId, bool getRecipientType, out Microsoft.Exchange.Data.Directory.Recipient.RecipientType?recipientType)
{
recipientType = null;
bool flag = SmtpAddress.IsValidSmtpAddress(recipId.RawIdentity);
if (!getRecipientType && flag)
{
return(SmtpAddress.Parse(recipId.RawIdentity));
}
if (flag)
{
SmtpAddress smtpAddress = SmtpAddress.Parse(recipId.RawIdentity);
ADRecipient adrecipientBySmtpAddress = JournalRuleObject.GetADRecipientBySmtpAddress(smtpAddress);
if (adrecipientBySmtpAddress != null)
{
recipientType = new Microsoft.Exchange.Data.Directory.Recipient.RecipientType?(adrecipientBySmtpAddress.RecipientType);
}
return(smtpAddress);
}
IEnumerable <ADRecipient> objects = recipId.GetObjects <ADRecipient>((null == orgId) ? null : orgId.OrganizationalUnit, recipSession ?? DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.IgnoreInvalid, orgId.ToADSessionSettings(), 429, "Lookup", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\SystemConfigurationTasks\\JournalRule\\JournalRuleObject.cs"));
ADRecipient adrecipient = null;
using (IEnumerator <ADRecipient> enumerator = objects.GetEnumerator())
{
if (!enumerator.MoveNext())
{
MimeRecipient mimeRecipient = null;
try
{
mimeRecipient = MimeRecipient.Parse(recipId.RawIdentity, AddressParserFlags.IgnoreComments | AddressParserFlags.AllowSquareBrackets);
}
catch (MimeException)
{
}
if (mimeRecipient == null || string.IsNullOrEmpty(mimeRecipient.Email) || !SmtpAddress.IsValidSmtpAddress(mimeRecipient.Email))
{
throw new RecipientInvalidException(Strings.NoRecipients);
}
return(new SmtpAddress(mimeRecipient.Email));
}
else
{
adrecipient = enumerator.Current;
if (enumerator.MoveNext())
{
throw new RecipientInvalidException(Strings.MoreThanOneRecipient);
}
}
}
if (adrecipient is IADOrgPerson && adrecipient.PrimarySmtpAddress.Equals(SmtpAddress.Empty))
{
throw new RecipientInvalidException(Strings.NoSmtpAddress);
}
recipientType = new Microsoft.Exchange.Data.Directory.Recipient.RecipientType?(adrecipient.RecipientType);
return(adrecipient.PrimarySmtpAddress);
}
private ADObjectId GetRecipientIdentityAndValidateTypeForContacts(RecipientIdParameter recipientIdParameter, Task.ErrorLoggerDelegate errorHandler)
{
ADRecipient adrecipient = (ADRecipient)base.GetDataObject <ADRecipient>(recipientIdParameter, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(recipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(recipientIdParameter.ToString())), ExchangeErrorCategory.Client);
if (RecipientType.UserMailbox != adrecipient.RecipientType && RecipientType.MailUser != adrecipient.RecipientType && RecipientType.MailContact != adrecipient.RecipientType)
{
errorHandler(new RecipientTaskException(Strings.ErrorIndividualRecipientNeeded(recipientIdParameter.ToString())), ExchangeErrorCategory.Client, recipientIdParameter);
return(null);
}
return((ADObjectId)adrecipient.Identity);
}
private ADObjectId GetRecipientIdentityAndValidateTypeForFwd(RecipientIdParameter recipientIdParameter, Task.ErrorLoggerDelegate errorHandler)
{
ADRecipient adrecipient = (ADRecipient)base.GetDataObject <ADRecipient>(recipientIdParameter, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(recipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(recipientIdParameter.ToString())), ExchangeErrorCategory.Client);
if (adrecipient.RecipientType == RecipientType.Invalid || RecipientType.User == adrecipient.RecipientType || RecipientType.Contact == adrecipient.RecipientType || RecipientType.Group == adrecipient.RecipientType || RecipientType.PublicDatabase == adrecipient.RecipientType || RecipientType.SystemAttendantMailbox == adrecipient.RecipientType || RecipientType.SystemMailbox == adrecipient.RecipientType || RecipientType.MicrosoftExchange == adrecipient.RecipientType)
{
errorHandler(new RecipientTaskException(Strings.ErrorInvalidRecipientType(recipientIdParameter.ToString(), adrecipient.RecipientType.ToString())), ExchangeErrorCategory.Client, recipientIdParameter);
return(null);
}
return((ADObjectId)adrecipient.Identity);
}
internal void SetExecutingUser(RecipientIdParameter executingUser)
{
using (new StopwatchPerformanceTracker("GroupMailboxContext.SetExecutingUser", GenericCmdletInfoDataLogger.Instance))
{
Exception ex;
this.ExecutingUser = this.ResolveUser(executingUser, out ex);
if (ex != null)
{
this.errorHandler(new GroupMailboxFailedToResolveExecutingUserException(Strings.WarningUnableToResolveUser(executingUser.ToString(), ex.Message)), ExchangeErrorCategory.Client, null);
}
}
}
internal QueryFilter GetRecipientFilter()
{
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(MailboxAuditLogSearch.SupportedRecipientTypes);
List <QueryFilter> list = new List <QueryFilter>();
DateTime value = base.EndDateUtc.Value;
DateTime value2 = base.StartDateUtc.Value;
if (base.ExternalAccess == null)
{
if (this.LogonTypes != null && this.LogonTypes.Contains("Admin"))
{
QueryFilter item = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastAdminAccess, value2);
list.Add(item);
}
if (this.LogonTypes != null && this.LogonTypes.Contains("Delegate"))
{
QueryFilter item2 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastDelegateAccess, value2);
list.Add(item2);
}
if (this.LogonTypes == null || this.LogonTypes.Count != 1 || !this.LogonTypes[0].Equals("Delegate"))
{
QueryFilter item3 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastExternalAccess, value2);
list.Add(item3);
}
}
else if (base.ExternalAccess.Value)
{
QueryFilter item4 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastExternalAccess, value2);
list.Add(item4);
}
else
{
if (this.LogonTypes != null && this.LogonTypes.Contains("Admin"))
{
QueryFilter item5 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastAdminAccess, value2);
list.Add(item5);
}
if (this.LogonTypes != null && this.LogonTypes.Contains("Delegate"))
{
QueryFilter item6 = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADRecipientSchema.AuditLastDelegateAccess, value2);
list.Add(item6);
}
}
QueryFilter queryFilter = QueryFilter.OrTogether(list.ToArray());
base.QueryComplexity = list.Count;
return(new AndFilter(new QueryFilter[]
{
recipientTypeDetailsFilter,
queryFilter
}));
}
internal override ADRecipient GetRecipient(RecipientIdParameter recipientIdParameter, Task.ErrorLoggerDelegate writeError)
{
bool includeSoftDeletedObjects = base.TenantGlobalCatalogSession.SessionSettings.IncludeSoftDeletedObjects;
if (this.IncludeSoftDeletedObjects.IsPresent)
{
base.TenantGlobalCatalogSession.SessionSettings.IncludeSoftDeletedObjects = true;
}
ADRecipient recipient = base.GetRecipient(recipientIdParameter, writeError);
base.TenantGlobalCatalogSession.SessionSettings.IncludeSoftDeletedObjects = includeSoftDeletedObjects;
return(recipient);
}
internal ADGroup ResolveGroup(RecipientIdParameter id, out Exception exception)
{
if (id == null)
{
throw new ArgumentNullException("id");
}
ADGroup group = null;
exception = GroupMailboxContext.ExecuteADOperationAndHandleException(delegate
{
group = (ADGroup)this.getGroupDataObject(id, this.adSession, this.currentOrganizationId.OrganizationalUnit, null, new LocalizedString?(Strings.ErrorRecipientNotFound((string)id)), new LocalizedString?(Strings.ErrorRecipientNotUnique((string)id)), ExchangeErrorCategory.Client);
});
return(group);
}
private ADObjectId ADObjectIdFromRecipientIdParameter(RecipientIdParameter recipientId, object param)
{
ADRecipient adrecipient = base.GetDataObject <ADRecipient>(recipientId, this.recipientSession, null, new LocalizedString?(Strings.ExceptionUserObjectNotFound(recipientId.ToString())), new LocalizedString?(Strings.ExceptionUserObjectAmbiguous)) as ADRecipient;
if (param != null)
{
RecipientType[] array = param as RecipientType[];
foreach (RecipientType recipientType in array)
{
if (adrecipient.RecipientType == recipientType || RemoteMailbox.IsRemoteMailbox(adrecipient.RecipientTypeDetails))
{
return(adrecipient.Id);
}
}
base.WriteError(new MailboxSearchTaskException(Strings.ErrorInvalidRecipientType(adrecipient.ToString(), adrecipient.RecipientType.ToString())), ErrorCategory.InvalidArgument, null);
}
return(adrecipient.Id);
}
protected override void PrepareRecipientObject(ref ADUser user)
{
TaskLogger.LogEnter();
ProxyAddressCollection emailAddresses = user.EmailAddresses;
base.PrepareRecipientObject(ref user);
if (this.PreserveEmailAddresses)
{
user.EmailAddresses = emailAddresses;
}
if (this.BypassModerationCheck.IsPresent)
{
user.BypassModerationCheck = true;
}
if (base.ParameterSetName == "Archive")
{
if (user.RecipientType == RecipientType.MailUser)
{
this.CreateArchiveIfNecessary(user);
TaskLogger.LogExit();
return;
}
RecipientIdParameter recipientIdParameter = new RecipientIdParameter((ADObjectId)user.Identity);
base.WriteError(new RecipientTaskException(Strings.ErrorInvalidArchiveRecipientType(recipientIdParameter.ToString(), user.RecipientType.ToString())), ErrorCategory.InvalidArgument, recipientIdParameter);
}
if (base.ParameterSetName != "Archive")
{
user.ExternalEmailAddress = this.ExternalEmailAddress;
user.UsePreferMessageFormat = this.UsePreferMessageFormat;
user.MessageFormat = this.MessageFormat;
user.MessageBodyFormat = this.MessageBodyFormat;
user.MacAttachmentFormat = this.MacAttachmentFormat;
user.UseMapiRichTextFormat = UseMapiRichTextFormat.UseDefaultSettings;
user.RecipientDisplayType = new RecipientDisplayType?(RecipientDisplayType.RemoteMailUser);
user.RecipientTypeDetails = RecipientTypeDetails.MailUser;
MailUserTaskHelper.ValidateExternalEmailAddress(user, this.ConfigurationSession, new Task.ErrorLoggerDelegate(base.WriteError), base.ProvisioningCache);
}
if (this.JournalArchiveAddress != SmtpAddress.Empty)
{
user.JournalArchiveAddress = this.JournalArchiveAddress;
}
}
private void WarnForJournalNdrMailboxSetting(TransportConfigContainer originalObject)
{
if (this.DataObject.IsModified(ADAMTransportConfigContainerSchema.JournalingReportNdrTo))
{
SmtpAddress journalingReportNdrTo = this.DataObject.JournalingReportNdrTo;
if (this.DataObject.JournalingReportNdrTo.IsValidAddress)
{
RoutingAddress value = new RoutingAddress(this.DataObject.JournalingReportNdrTo.ToString());
if (value != RoutingAddress.NullReversePath)
{
RecipientIdParameter recipId = new RecipientIdParameter(this.DataObject.JournalingReportNdrTo.ToString());
SmtpAddress smtpAddress;
if (!JournalRuleObject.LookupAndCheckAllowedTypes(recipId, base.TenantGlobalCatalogSession, this.DataObject.OrganizationId, true, out smtpAddress))
{
this.WriteWarning(Strings.JournalNdrMailboxWarning);
}
}
}
}
}
internal static ADUser GetSoftDeletedADUser(OrganizationId organizationId, RecipientIdParameter identity, Task.ErrorLoggerDelegate errorLogger)
{
IRecipientSession sessionForSoftDeletedObjects = SoftDeletedTaskHelper.GetSessionForSoftDeletedObjects(organizationId, null);
IEnumerable <ADUser> enumerable = identity.GetObjects <ADUser>(organizationId.OrganizationalUnit, sessionForSoftDeletedObjects) ?? new List <ADUser>();
ADUser result;
using (IEnumerator <ADUser> enumerator = enumerable.GetEnumerator())
{
if (!enumerator.MoveNext())
{
errorLogger(new RecipientTaskException(Strings.ErrorMailboxNotFound(identity.ToString())), ExchangeErrorCategory.Client, null);
}
result = enumerator.Current;
if (enumerator.MoveNext())
{
errorLogger(new RecipientTaskException(Strings.ErrorMailboxNotUnique(identity.ToString())), ExchangeErrorCategory.Client, null);
}
}
return(result);
}
public string[] Resolve(string identity)
{
RecipientIdParameter recipientIdParameter = new RecipientIdParameter(identity);
IEnumerable <ADRecipient> objects = recipientIdParameter.GetObjects <ADRecipient>(null, this.recipientSession);
if (objects == null)
{
return(null);
}
List <string> list = new List <string>(4);
foreach (ADRecipient adrecipient in objects)
{
list.Add(adrecipient.DisplayName);
list.Add(adrecipient.Alias);
list.Add(adrecipient.LegacyExchangeDN);
list.Add(adrecipient.PrimarySmtpAddress.ToString());
}
return(list.ToArray());
}
public string[] Resolve(string identity)
{
RecipientIdParameter recipientIdParameter = new RecipientIdParameter(identity);
IEnumerable <ADRecipient> objects = recipientIdParameter.GetObjects <ADRecipient>(null, this.recipientSession);
if (objects == null)
{
return(null);
}
List <string> list = new List <string>();
foreach (ADRecipient adrecipient in objects)
{
list.Add(adrecipient.DisplayName);
list.Add(adrecipient.Alias);
list.Add(adrecipient.LegacyExchangeDN);
list.Add(adrecipient.PrimarySmtpAddress.ToString());
}
SearchMailboxCriteria.Tracer.TraceDebug <string, List <string> >((long)this.GetHashCode(), "SearchMailboxCriteria resolving Identity {0} to {1}", identity, list);
return(list.ToArray());
}
protected override void UpdateFilterProperty()
{
base.UpdateFilterProperty();
if (this.MinVersion != null)
{
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADObjectSchema.ExchangeVersion, this.MinVersion);
if (!this.RecipientTypeDetailsWithoutVersionRestriction.IsNullOrEmpty())
{
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(base.RecipientTypeDetailsList);
if (recipientTypeDetailsFilter != null)
{
queryFilter = new AndFilter(new QueryFilter[]
{
recipientTypeDetailsFilter,
queryFilter
});
}
recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(this.RecipientTypeDetailsWithoutVersionRestriction);
queryFilter = new OrFilter(new QueryFilter[]
{
recipientTypeDetailsFilter,
queryFilter
});
base.RecipientTypeDetailsList = null;
}
string text = (string)base["Filter"];
if (!text.IsNullOrBlank())
{
base["Filter"] = string.Empty;
MonadFilter monadFilter = new MonadFilter(text, null, ObjectSchema.GetInstance <ReducedRecipientSchema>());
queryFilter = new AndFilter(new QueryFilter[]
{
monadFilter.InnerFilter,
queryFilter
});
}
base["RecipientPreviewFilter"] = LdapFilterBuilder.LdapFilterFromQueryFilter(queryFilter);
}
}
internal ADUser ResolveUser(RecipientIdParameter id, out Exception exception)
{
this.AddVerboseLog("Start: ResolveUser");
if (id == null)
{
throw new ArgumentNullException("id");
}
ADUser user;
if (this.resolveUserCache.TryGetValue(id.RawIdentity, out user))
{
exception = null;
return(user);
}
exception = GroupMailboxContext.ExecuteADOperationAndHandleException(delegate
{
user = (ADUser)this.getUserDataObject(id, this.adSession, this.currentOrganizationId.OrganizationalUnit, null, new LocalizedString?(Strings.ErrorRecipientNotFound((string)id)), new LocalizedString?(Strings.ErrorRecipientNotUnique((string)id)), ExchangeErrorCategory.Client);
});
Guid guid;
if (exception is ManagementObjectNotFoundException && Guid.TryParse(id.RawIdentity, out guid))
{
GroupMailboxContext.ExecuteADOperationAndHandleException(delegate
{
user = this.adSession.FindADUserByExternalDirectoryObjectId(id.RawIdentity);
});
if (user != null)
{
exception = null;
}
}
if (exception == null && user != null)
{
this.resolveUserCache.Add(id.RawIdentity, user);
}
this.AddVerboseLog("End: ResolveUser");
return(user);
}
private MultiValuedProperty <BindingMetadata> ValidateRecipientsImpl(IEnumerable <string> recipients)
{
MultiValuedProperty <BindingMetadata> multiValuedProperty = new MultiValuedProperty <BindingMetadata>();
bool flag = false;
this.warnedSkipInvalidTypeInGroup = false;
if (recipients.Count <string>() > this.maxRecipientsLimit)
{
base.LogOneEntry(ExecutionLog.EventType.Error, "InvalidArgument: {0}", new object[]
{
Strings.ErrorMaxMailboxLimit(this.maxRecipientsLimit, recipients.Count <string>())
});
base.WriteError(new ExValidatorException(Strings.ErrorMaxMailboxLimit(this.maxRecipientsLimit, recipients.Count <string>())), ErrorCategory.InvalidArgument);
}
else
{
foreach (string text in recipients)
{
if (SourceValidator.IsWideScope(text))
{
base.LogOneEntry(ExecutionLog.EventType.Verbose, "Skipping validation for wide scoped value '{0}", new object[]
{
text
});
multiValuedProperty.Add(new BindingMetadata(text, text, text, SourceValidator.GetBindingType(text)));
}
else
{
RecipientIdParameter recipientIdParameter = RecipientIdParameter.Parse(text);
ReducedRecipient reducedRecipient = this.recipientGetter(recipientIdParameter, this.recipientSession);
if (ExchangeValidator.IsMembershipGroup(reducedRecipient) && this.allowGroups)
{
if (!flag)
{
if (base.ShouldContinue(Strings.ShouldExpandGroups))
{
flag = true;
base.LogOneEntry(ExecutionLog.EventType.Information, "Got confirmation to expand groups", new object[0]);
}
else
{
base.LogOneEntry(ExecutionLog.EventType.Error, "User selected not to expand groups. {0}", new object[]
{
Strings.GroupsIsNotAllowedForHold(recipientIdParameter.RawIdentity)
});
base.WriteError(new ExValidatorException(Strings.GroupsIsNotAllowedForHold(recipientIdParameter.RawIdentity)), ErrorCategory.InvalidArgument);
}
}
if (flag)
{
this.ExpandGroupMembership(reducedRecipient, multiValuedProperty);
}
}
else
{
this.VerifyAndAddRecipient(reducedRecipient, multiValuedProperty, false);
}
}
}
}
return(multiValuedProperty);
}
internal static bool LookupAndCheckAllowedTypes(RecipientIdParameter recipId, IRecipientSession recipSession, OrganizationId orgId, bool isNonGccInDc, out SmtpAddress address)
{
Microsoft.Exchange.Data.Directory.Recipient.RecipientType?recipientType;
address = JournalRuleObject.Lookup(recipId, recipSession, orgId, isNonGccInDc && JournalRuleObject.isJournalAddressCheckEnabled, out recipientType);
return(!isNonGccInDc || !JournalRuleObject.isJournalAddressCheckEnabled || recipientType == null || !(recipientType != Microsoft.Exchange.Data.Directory.Recipient.RecipientType.MailUser) || !(recipientType != Microsoft.Exchange.Data.Directory.Recipient.RecipientType.MailContact));
}
private static SmtpAddress ResolveRecipientIdParameter(IRecipientSession recipientSession, RecipientIdParameter recipientIdParameter, out LocalizedException resolutionError)
{
resolutionError = null;
if (SmtpAddress.IsValidSmtpAddress(recipientIdParameter.RawIdentity))
{
return(SmtpAddress.Parse(recipientIdParameter.RawIdentity));
}
IEnumerable <ADRecipient> objects = recipientIdParameter.GetObjects <ADRecipient>(null, recipientSession);
ADRecipient adrecipient = null;
using (IEnumerator <ADRecipient> enumerator = objects.GetEnumerator())
{
if (!enumerator.MoveNext())
{
resolutionError = new NoRecipientsForRecipientIdException(recipientIdParameter.ToString());
return(SmtpAddress.Empty);
}
adrecipient = enumerator.Current;
if (enumerator.MoveNext())
{
resolutionError = new MoreThanOneRecipientForRecipientIdException(recipientIdParameter.ToString());
return(SmtpAddress.Empty);
}
}
if (SmtpAddress.Empty.Equals(adrecipient.PrimarySmtpAddress))
{
resolutionError = new NoSmtpAddressForRecipientIdException(recipientIdParameter.ToString());
return(SmtpAddress.Empty);
}
return(adrecipient.PrimarySmtpAddress);
}
internal virtual ADRecipient GetRecipient(RecipientIdParameter recipientIdParameter, Task.ErrorLoggerDelegate writeError)
{
return((ADRecipient)base.GetDataObject <ADRecipient>(recipientIdParameter, base.TenantGlobalCatalogSession, null, new LocalizedString?(Strings.ErrorRecipientNotFound(recipientIdParameter.ToString())), new LocalizedString?(Strings.ErrorRecipientNotUnique(recipientIdParameter.ToString())), ExchangeErrorCategory.Client));
}
protected void ResolveDatabaseAndServer()
{
DatabaseIdParameter databaseIdParameter = this.Database;
ServerIdParameter serverIdParameter = this.Server ?? new ServerIdParameter();
ActiveManager activeManagerInstance = ActiveManager.GetActiveManagerInstance();
if (this.Identity != null)
{
bool flag = false;
if (this.isRunningLogonStatisticsTask)
{
TIdentity tidentity = this.Identity;
IEnumerable <Database> objects = tidentity.GetObjects <Database>(null, base.GlobalConfigSession);
foreach (Database item in objects)
{
this.databases.Add(item);
}
if (this.databases.Count > 0)
{
if (this.databases[0].Server == null)
{
string name = typeof(Database).Name;
TIdentity tidentity2 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(name, tidentity2.ToString(), DatabaseSchema.Server.Name)), ErrorCategory.InvalidArgument, this.Identity);
}
DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(this.databases[0].Guid);
serverIdParameter = ServerIdParameter.Parse(serverForDatabase.ServerFqdn);
if (string.IsNullOrEmpty(this.databases[0].ExchangeLegacyDN))
{
string name2 = typeof(Database).Name;
TIdentity tidentity3 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(name2, tidentity3.ToString(), DatabaseSchema.ExchangeLegacyDN.Name)), ErrorCategory.InvalidArgument, this.Identity);
}
this.identity = new MailboxId(this.databases[0].ExchangeLegacyDN);
flag = true;
}
}
if (!flag)
{
IIdentityParameter id = this.Identity;
IConfigDataProvider session = this.readOnlyRecipientSession;
ObjectId rootID = null;
TIdentity tidentity4 = this.Identity;
LocalizedString? notFoundError = new LocalizedString?(Strings.ErrorMailboxNotFound(tidentity4.ToString()));
TIdentity tidentity5 = this.Identity;
ADRecipient adrecipient = (ADRecipient)base.GetDataObject <ADRecipient>(id, session, rootID, notFoundError, new LocalizedString?(Strings.ErrorMailboxNotUnique(tidentity5.ToString())));
Guid guid = Guid.Empty;
string mailboxExchangeLegacyDn = null;
ADObjectId adobjectId = null;
if (string.IsNullOrEmpty(adrecipient.LegacyExchangeDN))
{
string name3 = typeof(ADRecipient).Name;
TIdentity tidentity6 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(name3, tidentity6.ToString(), ADRecipientSchema.LegacyExchangeDN.Name)), ErrorCategory.InvalidArgument, this.Identity);
}
ADUser aduser = adrecipient as ADUser;
ADSystemMailbox adsystemMailbox = adrecipient as ADSystemMailbox;
ADSystemAttendantMailbox adsystemAttendantMailbox = adrecipient as ADSystemAttendantMailbox;
ADPublicDatabase adpublicDatabase = adrecipient as ADPublicDatabase;
if (aduser != null)
{
if (this.isRunningMailboxStatisticsTask && aduser.RecipientTypeDetails == RecipientTypeDetails.AuditLogMailbox && !this.GetAuditLogMailboxStatistics())
{
TIdentity tidentity7 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.RecipientNotFoundException(tidentity7.ToString())), ErrorCategory.InvalidArgument, null);
}
bool archiveMailboxStatistics = this.GetArchiveMailboxStatistics();
if (aduser.RecipientType == RecipientType.MailUser && !archiveMailboxStatistics)
{
base.WriteError(new MdbAdminTaskException(Strings.RecipientTypeNotValid(aduser.ToString())), (ErrorCategory)1003, this.Identity);
}
RecipientIdParameter recipientIdParameter = this.Identity as RecipientIdParameter;
if (this.isRunningMailboxStatisticsTask && recipientIdParameter != null && recipientIdParameter.RawMailboxGuidInvolvedInSearch != Guid.Empty && aduser.MailboxLocations != null)
{
IMailboxLocationInfo mailboxLocation = aduser.MailboxLocations.GetMailboxLocation(recipientIdParameter.RawMailboxGuidInvolvedInSearch);
if (mailboxLocation != null)
{
guid = mailboxLocation.MailboxGuid;
adobjectId = mailboxLocation.DatabaseLocation;
}
}
if (guid == Guid.Empty || adobjectId == null)
{
if (archiveMailboxStatistics)
{
if (aduser.ArchiveGuid != Guid.Empty)
{
if (aduser.ArchiveDomain != null)
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorRemoteArchiveNoStats(aduser.ToString())), (ErrorCategory)1003, this.Identity);
}
else
{
guid = aduser.ArchiveGuid;
adobjectId = (aduser.ArchiveDatabase ?? aduser.Database);
}
}
else
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorArchiveNotEnabled(aduser.ToString())), ErrorCategory.InvalidArgument, this.Identity);
}
}
else
{
guid = aduser.ExchangeGuid;
adobjectId = aduser.Database;
}
}
mailboxExchangeLegacyDn = aduser.LegacyExchangeDN;
}
else if (adsystemMailbox != null)
{
guid = adsystemMailbox.ExchangeGuid;
mailboxExchangeLegacyDn = adsystemMailbox.LegacyExchangeDN;
adobjectId = adsystemMailbox.Database;
}
else if (adsystemAttendantMailbox != null)
{
guid = adsystemAttendantMailbox.Guid;
mailboxExchangeLegacyDn = adsystemAttendantMailbox.LegacyExchangeDN;
adobjectId = adsystemAttendantMailbox.Database;
}
else if (adpublicDatabase != null)
{
mailboxExchangeLegacyDn = adpublicDatabase.LegacyExchangeDN;
adobjectId = (ADObjectId)adpublicDatabase.Identity;
}
if (adobjectId == null)
{
string name4 = adrecipient.GetType().Name;
TIdentity tidentity8 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(name4, tidentity8.ToString(), IADMailStorageSchema.Database.Name)), ErrorCategory.InvalidArgument, adrecipient);
}
databaseIdParameter = new DatabaseIdParameter(adobjectId);
if (this.isRunningLogonStatisticsTask)
{
this.identity = new MailboxId(mailboxExchangeLegacyDn);
}
else
{
this.identity = new MailboxId(MapiTaskHelper.ConvertDatabaseADObjectIdToDatabaseId(adobjectId), guid);
}
}
}
if (databaseIdParameter != null)
{
databaseIdParameter.AllowLegacy = true;
LocalizedString empty = LocalizedString.Empty;
LocalizedString empty2 = LocalizedString.Empty;
Database database;
if (this.isRunningLogonStatisticsTask)
{
database = (Database)base.GetDataObject <Database>(databaseIdParameter, base.GlobalConfigSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(databaseIdParameter.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(databaseIdParameter.ToString())));
}
else
{
database = (MailboxDatabase)base.GetDataObject <MailboxDatabase>(databaseIdParameter, base.GlobalConfigSession, null, new LocalizedString?(Strings.ErrorMailboxDatabaseNotFound(databaseIdParameter.ToString())), new LocalizedString?(Strings.ErrorMailboxDatabaseNotUnique(databaseIdParameter.ToString())));
}
if (database.Server == null)
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(this.isRunningLogonStatisticsTask ? typeof(Database).Name : typeof(MailboxDatabase).Name, databaseIdParameter.ToString(), DatabaseSchema.Server.Name)), ErrorCategory.InvalidArgument, database);
}
this.databases = new List <Database>(new Database[]
{
database
});
if (this.CopyOnServer != null)
{
serverIdParameter = this.CopyOnServer;
}
else
{
DatabaseLocationInfo serverForDatabase = activeManagerInstance.GetServerForDatabase(database.Guid);
serverIdParameter = ServerIdParameter.Parse(serverForDatabase.ServerFqdn);
}
}
if (this.Server != null)
{
serverIdParameter = this.Server;
this.server = MapiTaskHelper.GetMailboxServer(this.Server, base.GlobalConfigSession, new Task.ErrorLoggerDelegate(base.WriteError));
}
else
{
this.server = (Server)base.GetDataObject <Server>(serverIdParameter, base.GlobalConfigSession, null, new LocalizedString?((this.Identity == null && this.Database == null) ? Strings.ErrorLocalMachineIsNotExchangeServer : Strings.ErrorServerNotFound(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString())));
if (!this.server.IsExchange2007OrLater || !this.server.IsMailboxServer)
{
if (this.Identity != null)
{
TIdentity tidentity9 = this.Identity;
base.WriteError(new MdbAdminTaskException(Strings.ErrorMailboxInNonMailboxServer(tidentity9.ToString())), ErrorCategory.InvalidArgument, this.server);
}
if (this.Database != null)
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorDatabaseInNonMailboxServer(this.Database.ToString())), ErrorCategory.InvalidArgument, this.server);
}
base.WriteError(new MdbAdminTaskException(Strings.ErrorLocalServerIsNotMailboxServer), ErrorCategory.InvalidArgument, this.server);
}
}
if (string.IsNullOrEmpty(this.server.ExchangeLegacyDN))
{
base.WriteError(new MdbAdminTaskException(Strings.ErrorInvalidObjectMissingCriticalProperty(typeof(Server).Name, serverIdParameter.ToString(), ServerSchema.ExchangeLegacyDN.Name)), ErrorCategory.InvalidArgument, this.Identity);
}
if (this.databases.Count == 0)
{
if (this.isRunningLogonStatisticsTask)
{
this.FilterActiveDatabases(activeManagerInstance, this.server.GetDatabases());
return;
}
this.FilterActiveDatabases(activeManagerInstance, this.server.GetMailboxDatabases());
}
}
private void ReportResolveUserWarning(RecipientIdParameter id, Exception ex)
{
this.warningHandler(Strings.WarningUnableToResolveUser(id.ToString(), ex.Message));
}
private static NewExchangeNotification.LookupResult LookupSmtpAddressAndLanguage(IRecipientSession recipientSession, RecipientIdParameter recipientIdParameter)
{
IEnumerable <ADRecipient> objects = recipientIdParameter.GetObjects <ADRecipient>(null, recipientSession);
ADRecipient adrecipient = null;
using (IEnumerator <ADRecipient> enumerator = objects.GetEnumerator())
{
if (!enumerator.MoveNext())
{
if (SmtpAddress.IsValidSmtpAddress(recipientIdParameter.RawIdentity))
{
return(new NewExchangeNotification.LookupResult
{
Success = true,
SmtpAddress = SmtpAddress.Parse(recipientIdParameter.RawIdentity),
Languages = new CultureInfo[0]
});
}
return(new NewExchangeNotification.LookupResult
{
Success = false,
ErrorMessage = Strings.NoRecipientsForRecipientId(recipientIdParameter.ToString())
});
}
else
{
adrecipient = enumerator.Current;
if (enumerator.MoveNext())
{
return(new NewExchangeNotification.LookupResult
{
Success = false,
ErrorMessage = Strings.MoreThanOneRecipientForRecipientId(recipientIdParameter.ToString())
});
}
}
}
if (SmtpAddress.Empty.Equals(adrecipient.PrimarySmtpAddress))
{
return(new NewExchangeNotification.LookupResult
{
Success = false,
ErrorMessage = Strings.NoSmtpAddressForRecipientId(recipientIdParameter.ToString())
});
}
IADOrgPerson iadorgPerson = adrecipient as IADOrgPerson;
if (iadorgPerson == null)
{
return(new NewExchangeNotification.LookupResult
{
Success = true,
SmtpAddress = adrecipient.PrimarySmtpAddress,
Languages = new CultureInfo[0]
});
}
return(new NewExchangeNotification.LookupResult
{
Success = true,
SmtpAddress = adrecipient.PrimarySmtpAddress,
Languages = iadorgPerson.Languages
});
}
private void ReportResolveOwnerError(RecipientIdParameter id, Exception ex)
{
this.errorHandler(new GroupMailboxFailedToResolveOwnerException(Strings.ErrorUnableToResolveOwner(id.ToString(), ex.Message)), ExchangeErrorCategory.Client, null);
}
internal static LocalizedException SetUserInformation(TestCasConnectivity.TestCasConnectivityRunInstance instance, IConfigDataProvider session, ref ADUser user)
{
if (session == null)
{
throw new LocalizedException(Strings.ErrorNullParameter("session"));
}
if (instance == null)
{
throw new LocalizedException(Strings.ErrorNullParameter("instance"));
}
IRecipientSession recipientSession = session as IRecipientSession;
if (recipientSession == null)
{
throw new LocalizedException(Strings.ErrorNullParameter("recipientSession"));
}
if (!string.IsNullOrEmpty(instance.credentials.Domain) && instance.credentials.UserName.IndexOf('@') == -1)
{
WindowsIdentity windowsIdentity = null;
string text = instance.credentials.UserName + "@" + instance.credentials.Domain;
try
{
windowsIdentity = new WindowsIdentity(text);
}
catch (SecurityException ex)
{
return(new CasHealthUserNotFoundException(text, ex.Message));
}
using (windowsIdentity)
{
user = (recipientSession.FindBySid(windowsIdentity.User) as ADUser);
if (user == null)
{
return(new AdUserNotFoundException(text, string.Empty));
}
goto IL_174;
}
}
user = null;
RecipientIdParameter recipientIdParameter = RecipientIdParameter.Parse(instance.credentials.UserName);
IEnumerable <ADUser> objects = recipientIdParameter.GetObjects <ADUser>(null, recipientSession);
if (objects != null)
{
IEnumerator <ADUser> enumerator = objects.GetEnumerator();
if (enumerator != null && enumerator.MoveNext())
{
user = enumerator.Current;
}
if (enumerator.MoveNext())
{
user = null;
return(new AdUserNotUniqueException(instance.credentials.UserName));
}
}
if (user == null)
{
return(new AdUserNotFoundException(instance.credentials.UserName, string.Empty));
}
IL_174:
return(null);
}