public static LocalizedString AutoProvisionConfirmation(PimSubscriptionProxy subscription)
{
return(new LocalizedString("AutoProvisionConfirmation", Strings.ResourceManager, new object[]
{
subscription
}));
}
public IConfigurable Read <T>(ObjectId identity) where T : IConfigurable, new()
{
AggregationSubscriptionIdentity aggregationSubscriptionIdentity = (AggregationSubscriptionIdentity)identity;
try
{
using (MailboxSession mailboxSession = this.OpenMailboxSession(aggregationSubscriptionIdentity))
{
bool upgradeIfRequired = this.ShouldUpgradeIfRequired();
PimAggregationSubscription pimAggregationSubscription = (PimAggregationSubscription)SubscriptionManager.GetSubscription(mailboxSession, aggregationSubscriptionIdentity.SubscriptionId, upgradeIfRequired);
PimSubscriptionProxy pimSubscriptionProxy = pimAggregationSubscription.CreateSubscriptionProxy();
if (this.loadReport)
{
ReportData reportData = SkippedItemUtilities.GetReportData(aggregationSubscriptionIdentity.SubscriptionId);
reportData.Load(mailboxSession.Mailbox.MapiStore);
pimSubscriptionProxy.Report = reportData.ToReport();
}
return(pimSubscriptionProxy);
}
}
catch (LocalizedException ex)
{
CommonLoggingHelper.SyncLogSession.LogError((TSLID)1365UL, AggregationTaskUtils.Tracer, "Read: {0} hit exception: {1}.", new object[]
{
aggregationSubscriptionIdentity,
ex
});
}
return(null);
}
protected override IConfigurable PrepareDataObject()
{
TaskLogger.LogEnter();
IConfigurable configurable = this.ResolveDataObject();
if (base.HasErrors)
{
return(null);
}
this.ValidateWithDataObject(configurable);
this.StampChangesOn(configurable);
if (base.HasErrors)
{
return(null);
}
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)configurable;
pimSubscriptionProxy.ObjectState = ObjectState.Changed;
SendAsManager sendAsManager = new SendAsManager();
sendAsManager.ResetVerificationEmailData(pimSubscriptionProxy.Subscription);
pimSubscriptionProxy.SendAsCheckNeeded = this.SendAsCheckNeeded();
TaskLogger.LogExit();
return(pimSubscriptionProxy);
}
private void UpdateAggregationSubscription(PimSubscriptionProxy pimSubscriptionProxy)
{
PimAggregationSubscription subscription = pimSubscriptionProxy.Subscription;
try
{
using (MailboxSession mailboxSession = this.OpenMailboxSession(subscription.SubscriptionIdentity))
{
IList <AggregationSubscription> allSubscriptions = this.GetAllSubscriptions();
this.aggregationSubscriptionConstraintChecker.CheckUpdateSubscriptionConstraints(subscription, allSubscriptions);
DelayedEmailSender delayedEmailSender = null;
if (pimSubscriptionProxy.SendAsCheckNeeded)
{
delayedEmailSender = this.SetAppropriateSendAsState(subscription);
}
SubscriptionManager.SetSubscriptionAndSyncNow(mailboxSession, subscription);
if (pimSubscriptionProxy.SendAsCheckNeeded)
{
this.PostSaveSendAsStateProcessing(subscription, delayedEmailSender, mailboxSession);
}
}
}
catch (LocalizedException ex)
{
CommonLoggingHelper.SyncLogSession.LogError((TSLID)1246UL, AggregationTaskUtils.Tracer, "UpdateAggregationSubscription: {0} hit exception: {1}.", new object[]
{
subscription.Name,
ex
});
throw new FailedSetAggregationSubscriptionException(subscription.Name, ex);
}
}
protected override void WriteResult(IConfigurable dataObject)
{
PimSubscriptionProxy pimSubscriptionProxy = dataObject as PimSubscriptionProxy;
if (pimSubscriptionProxy != null)
{
pimSubscriptionProxy.NeedSuppressingPiiData = base.NeedSuppressingPiiData;
}
base.WriteResult(dataObject);
}
protected override IConfigurable PrepareDataObject()
{
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)base.PrepareDataObject();
this.EnsureUserDisplayName();
pimSubscriptionProxy.Name = this.Name;
pimSubscriptionProxy.DisplayName = this.DisplayName;
pimSubscriptionProxy.EmailAddress = this.EmailAddress;
pimSubscriptionProxy.AggregationType = this.AggregationType;
pimSubscriptionProxy.SendAsCheckNeeded = true;
return(pimSubscriptionProxy);
}
internal static void ValidateEmailAddress(IConfigDataProvider dataProvider, PimSubscriptionProxy subscriptionProxy, Task.TaskErrorLoggingDelegate taskErrorLoggingDelegate)
{
if (subscriptionProxy.AggregationType != AggregationType.Migration)
{
ADUser aduser = ((AggregationSubscriptionDataProvider)dataProvider).ADUser;
string text = subscriptionProxy.EmailAddress.ToString();
if (AggregationTaskUtils.IsUserProxyAddress(aduser, text))
{
taskErrorLoggingDelegate(new LocalizedException(Strings.SubscriptionInvalidEmailAddress(text)), ErrorCategory.InvalidArgument, null);
}
}
}
protected virtual void ValidateWithDataObject(IConfigurable dataObject)
{
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)dataObject;
if (this.EnablePoisonSubscription && pimSubscriptionProxy.Status != AggregationStatus.Poisonous)
{
this.WriteDebugInfoAndError(new LocalizedException(Strings.SubscriptionCannotBeEnabled), ErrorCategory.InvalidArgument, null);
}
if ((pimSubscriptionProxy.Status == AggregationStatus.Poisonous && !this.EnablePoisonSubscription) || pimSubscriptionProxy.Status == AggregationStatus.InvalidVersion)
{
this.WriteDebugInfoAndError(new LocalizedException(Strings.SubscriptionCannotBeChanged), ErrorCategory.InvalidArgument, null);
}
}
protected override IConfigurable PrepareDataObject()
{
IConfigurable configurable = base.PrepareDataObject();
if (this.ValidateSecret == null && this.ResendVerification == false)
{
return(configurable);
}
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)configurable;
AggregationSubscriptionDataProvider dataProvider = (AggregationSubscriptionDataProvider)base.DataSession;
AggregationTaskUtils.ProcessSendAsSpecificParameters(pimSubscriptionProxy, this.ValidateSecret, this.ResendVerification, dataProvider, new Task.TaskErrorLoggingDelegate(base.WriteDebugInfoAndError));
base.WriteDebugInfo();
return(pimSubscriptionProxy);
}
private void NewAggregationSubscription(PimSubscriptionProxy pimSubscriptionProxy)
{
PimAggregationSubscription subscription = pimSubscriptionProxy.Subscription;
ExchangePrincipal exchangePrincipal = this.primaryExchangePrincipal;
IList <AggregationSubscription> allSubscriptions = this.GetAllSubscriptions();
int userMaximumSubscriptionAllowed = this.GetUserMaximumSubscriptionAllowed();
this.aggregationSubscriptionConstraintChecker.CheckNewSubscriptionConstraints(subscription, allSubscriptions, userMaximumSubscriptionAllowed);
bool flag = false;
try
{
DelayedEmailSender delayedEmailSender = null;
if (pimSubscriptionProxy.SendAsCheckNeeded)
{
delayedEmailSender = this.SetAppropriateSendAsState(subscription);
}
flag = true;
using (MailboxSession mailboxSession = this.OpenMailboxSession(exchangePrincipal))
{
SubscriptionManager.CreateSubscription(mailboxSession, subscription);
if (pimSubscriptionProxy.SendAsCheckNeeded)
{
this.PostSaveSendAsStateProcessing(subscription, delayedEmailSender, mailboxSession);
}
}
}
catch (LocalizedException ex)
{
if (!flag)
{
CommonLoggingHelper.SyncLogSession.LogError((TSLID)1504UL, AggregationTaskUtils.Tracer, "NewAggregationSubscription: {0}. Failed to set send as state with exception: {1}.", new object[]
{
subscription.Name,
ex
});
}
else
{
CommonLoggingHelper.SyncLogSession.LogError((TSLID)1505UL, AggregationTaskUtils.Tracer, "NewAggregationSubscription: {0}. Failed to open mailbox session with exception: {1}.", new object[]
{
subscription.Name,
ex
});
}
throw new FailedCreateAggregationSubscriptionException(subscription.Name, ex);
}
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter(new object[]
{
this.Identity
});
try
{
if (this.identityDefined && this.Identity.IsUniqueIdentity)
{
TSubscription tsubscription = (TSubscription)((object)base.GetDataObject(this.Identity));
PimSubscriptionProxy pimSubscriptionProxy = tsubscription as PimSubscriptionProxy;
if (pimSubscriptionProxy != null)
{
pimSubscriptionProxy.SetDebug(base.IsDebugOn || base.IsVerboseOn);
}
this.WriteResult(tsubscription);
}
else
{
LocalizedString? localizedString;
IEnumerable <TSubscription> dataObjects = base.GetDataObjects(this.Identity, base.OptionalIdentityData, out localizedString);
foreach (TSubscription tsubscription2 in dataObjects)
{
PimSubscriptionProxy pimSubscriptionProxy2 = tsubscription2 as PimSubscriptionProxy;
if (pimSubscriptionProxy2 != null)
{
pimSubscriptionProxy2.SetDebug(base.IsDebugOn || base.IsVerboseOn);
}
}
this.WriteResult <TSubscription>(dataObjects);
if (!base.HasErrors && base.WriteObjectCount == 0U && localizedString != null)
{
this.WriteDebugInfoAndError(new ManagementObjectNotFoundException(localizedString.Value), ErrorCategory.InvalidData, null);
}
}
}
finally
{
this.WriteDebugInfo();
}
TaskLogger.LogExit();
}
private PimSubscriptionProxy[] GetSubscriptions(AggregationSubscriptionQueryFilter queryFilter)
{
List <PimSubscriptionProxy> list = new List <PimSubscriptionProxy>(3);
IList <AggregationSubscription> allSubscriptions = this.GetAllSubscriptions();
if (allSubscriptions != null)
{
foreach (AggregationSubscription aggregationSubscription in allSubscriptions)
{
PimAggregationSubscription pimAggregationSubscription = (PimAggregationSubscription)aggregationSubscription;
if (queryFilter == null || queryFilter.Match(pimAggregationSubscription))
{
PimSubscriptionProxy pimSubscriptionProxy = pimAggregationSubscription.CreateSubscriptionProxy();
if (this.loadReport && this.reports.ContainsKey(aggregationSubscription.SubscriptionGuid))
{
pimSubscriptionProxy.Report = this.reports[aggregationSubscription.SubscriptionGuid];
}
list.Add(pimSubscriptionProxy);
}
}
}
return(list.ToArray());
}
protected override void StampChangesOn(IConfigurable dataObject)
{
TaskLogger.LogEnter();
PimSubscriptionProxy pimSubscriptionProxy = (PimSubscriptionProxy)dataObject;
if (base.Fields.IsModified("DisplayName"))
{
pimSubscriptionProxy.DisplayName = this.DisplayName;
}
SubscriptionStateTransitionHelper subscriptionStateTransitionHelper = new SubscriptionStateTransitionHelper(pimSubscriptionProxy.Subscription);
if (this.DisableAsPoison)
{
subscriptionStateTransitionHelper.DisableAsPoisonous();
}
else if (this.EnablePoisonSubscription)
{
if (this.Enabled)
{
subscriptionStateTransitionHelper.EnableFromPoison();
}
else
{
subscriptionStateTransitionHelper.Disable();
}
}
else if (this.Enabled)
{
subscriptionStateTransitionHelper.Enable();
}
else
{
subscriptionStateTransitionHelper.Disable();
}
TaskLogger.LogExit();
}
internal static void ProcessSendAsSpecificParameters(PimSubscriptionProxy subscriptionProxy, string validateSecret, bool resendVerification, AggregationSubscriptionDataProvider dataProvider, Task.TaskErrorLoggingDelegate taskErrorLoggingDelegate)
{
SyncUtilities.ThrowIfArgumentNull("subscriptionProxy", subscriptionProxy);
SyncUtilities.ThrowIfArgumentNull("dataProvider", dataProvider);
SyncUtilities.ThrowIfArgumentNull("taskErrorLoggingDelegate", taskErrorLoggingDelegate);
SendAsManager sendAsManager = new SendAsManager();
if (validateSecret != null)
{
if (sendAsManager.ValidateSharedSecret(subscriptionProxy.Subscription, validateSecret))
{
AggregationTaskUtils.EnableAlwaysShowFrom(dataProvider.SubscriptionExchangePrincipal);
}
else
{
taskErrorLoggingDelegate(new ValidateSecretFailureException(), (ErrorCategory)1003, subscriptionProxy);
}
}
if (resendVerification)
{
IEmailSender emailSender = subscriptionProxy.Subscription.CreateEmailSenderFor(dataProvider.ADUser, dataProvider.SubscriptionExchangePrincipal);
sendAsManager.ResendVerificationEmail(subscriptionProxy.Subscription, emailSender);
}
}
public void Save(IConfigurable instance)
{
PimSubscriptionProxy pimSubscriptionProxy = instance as PimSubscriptionProxy;
switch (pimSubscriptionProxy.ObjectState)
{
case ObjectState.New:
this.NewAggregationSubscription(pimSubscriptionProxy);
return;
case ObjectState.Unchanged:
return;
case ObjectState.Changed:
this.UpdateAggregationSubscription(pimSubscriptionProxy);
return;
case ObjectState.Deleted:
throw new InvalidOperationException("Calling Save() on a deleted object is not permitted. Delete() should be used instead.");
default:
return;
}
}
public AggregationSubscriptionIdParameter(PimSubscriptionProxy subscriptionProxy) : this(subscriptionProxy.Identity)
{
}
public SubscriptionItem(PimSubscriptionProxy subscription) : base(subscription.EmailAddress.ToString(), subscription.Subscription.SubscriptionIdentity.ToString())
{
this.IsValid = subscription.IsValid;
}
public PimSubscriptionRow(PimSubscriptionProxy subscription) : base(((AggregationSubscriptionIdentity)subscription.Identity).ToIdentity(subscription.EmailAddress.ToString()), subscription)
{
this.PimSubscriptionProxy = subscription;
}
public PimSubscription(PimSubscriptionProxy subscription) : base(subscription)
{
}
public virtual void Delete(IConfigurable instance)
{
PimSubscriptionProxy pimSubscriptionProxy = instance as PimSubscriptionProxy;
this.RemoveAggregationSubscription(pimSubscriptionProxy.Subscription);
}
public CacheIdParameter(PimSubscriptionProxy subscriptionProxy) : this(subscriptionProxy.Subscription.AdUserId)
{
}
