public SearchHL7ADTEventArgs(bool fullSequences,
ComparisonFilter messageTimeStampComparisonFilter,
DateTime messageTimeStamp,
ComparisonFilter messageTimeStampComparisonFilter2,
DateTime messageTimeStamp2,
ComparisonFilter eventTimeStampComparisonFilter,
DateTime eventTimeStamp,
ComparisonFilter eventTimeStampComparisonFilter2,
DateTime eventTimeStamp2,
string[] containingEventTypes,
string containingText,
decimal[] visitNumbers,
IList<string> searchDals,
string biztalk,
bool biztalkShowOnlyLast100HL7s)
: base(searchDals, biztalk, biztalkShowOnlyLast100HL7s)
{
FullSequences = fullSequences;
MessageTimeStampComparisonFilter = messageTimeStampComparisonFilter;
MessageTimeStamp = messageTimeStamp;
MessageTimeStampComparisonFilter2 = messageTimeStampComparisonFilter2;
MessageTimeStamp2 = messageTimeStamp2;
EventTimeStampComparisonFilter = eventTimeStampComparisonFilter;
EventTimeStamp = eventTimeStamp;
EventTimeStampComparisonFilter2 = eventTimeStampComparisonFilter2;
EventTimeStamp2 = eventTimeStamp2;
ContainingEventTypes = containingEventTypes;
ContainingText = containingText;
VisitNumbers = visitNumbers;
}
public void Recompare(ComparisonFilter filter)
{
foreach (AssemblyGroup group in _groups)
{
group.PerformCompare(filter);
}
}
public void Filters_ChangedOnly_ParentRemovedByChild()
{
ComparisonFilter filter = new ComparisonFilter();
filter.ChangedItemsOnly = true;
filter.IgnoreAssemblyAttributeChanges = true;
DoCompareAndVerifyRemoved(filter, "Attributes");
}
protected override void ApplyFilterInstance(ComparisonFilter filter)
{
base.ApplyFilterInstance(filter);
if (!filter.CompareMethodImplementations)
{
_changeThisInstance &= ~ChangeType.ImplementationChanged;
}
}
protected override void ApplyFilterInstance(ComparisonFilter filter)
{
base.ApplyFilterInstance(filter);
if ((filter.IgnoreAssemblyAttributeChanges) && (this.Parent.GetType() == typeof(AttributesDetail)) && (this.Parent.Parent.GetType() == typeof(AssemblyDetail)))
{
_changeThisInstance = ChangeType.None;
}
}
internal void LoadFilter(ComparisonFilter cf)
{
cbChangedOnly.Checked = cf.ChangedItemsOnly;
cbPublic.Checked = cf.IncludePublic;
cbProtected.Checked = cf.IncludeProtected;
cbInternal.Checked = cf.IncludeInternal;
cbPrivate.Checked = cf.IncludePrivate;
cbIgnoreAssemAttrs.Checked = cf.IgnoreAssemblyAttributeChanges;
cbCompareImplementation.Checked = cf.CompareMethodImplementations;
}
internal void SaveFilter(ComparisonFilter cf)
{
cf.ChangedItemsOnly = cbChangedOnly.Checked;
cf.IncludePublic = cbPublic.Checked;
cf.IncludeProtected = cbProtected.Checked;
cf.IncludeInternal = cbInternal.Checked;
cf.IncludePrivate = cbPrivate.Checked;
cf.IgnoreAssemblyAttributeChanges = cbIgnoreAssemAttrs.Checked;
cf.CompareMethodImplementations = cbCompareImplementation.Checked;
}
public SearchHL7MFNEventArgs(ComparisonFilter messageTimeStampComparisonFilter,
DateTime messageTimeStamp,
decimal[] doctorNumbers,
IList<string> searchDals,
string biztalk,
bool biztalkShowOnlyLast100HL7s)
: base(searchDals, biztalk, biztalkShowOnlyLast100HL7s)
{
MessageTimeStampComparisonFilter = messageTimeStampComparisonFilter;
MessageTimeStamp = messageTimeStamp;
DoctorNumbers = doctorNumbers;
}
protected override void InternalValidate()
{
OptionalIdentityData optionalIdentityData = new OptionalIdentityData();
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.RecipientType, RecipientType.UserMailbox);
QueryFilter queryFilter2 = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.RecipientTypeDetails, RecipientTypeDetails.TeamMailbox);
queryFilter = new AndFilter(new QueryFilter[]
{
queryFilter,
queryFilter2
});
if (base.ParameterSetName != "TeamMailboxITPro")
{
ADObjectId propertyValue = null;
if (!base.TryGetExecutingUserId(out propertyValue))
{
base.WriteError(new InvalidOperationException(Strings.CouldNotGetExecutingUser), ErrorCategory.InvalidOperation, null);
}
QueryFilter queryFilter3 = new ComparisonFilter(ComparisonOperator.Equal, ADMailboxRecipientSchema.DelegateListLink, propertyValue);
queryFilter = new AndFilter(new QueryFilter[]
{
queryFilter,
queryFilter3
});
if (this.additionalConstrainedIdentity != null)
{
queryFilter3 = new ComparisonFilter(ComparisonOperator.Equal, ADMailboxRecipientSchema.DelegateListLink, this.additionalConstrainedIdentity);
queryFilter = new AndFilter(new QueryFilter[]
{
queryFilter,
queryFilter3
});
}
}
optionalIdentityData.AdditionalFilter = queryFilter;
LocalizedString? localizedString = null;
IEnumerable <ADUser> dataObjects = base.GetDataObjects <ADUser>(this.Identity, base.DataSession, null, optionalIdentityData, out localizedString);
foreach (ADUser aduser in dataObjects)
{
ExchangePrincipal value = ExchangePrincipal.FromADUser(((IRecipientSession)base.DataSession).SessionSettings, aduser, RemotingOptions.AllowCrossSite);
this.tmPrincipals.Add(aduser, value);
}
if (this.tmPrincipals.Count == 0)
{
base.WriteError(new InvalidOperationException(Strings.CouldNotLocateAnyTeamMailbox), ErrorCategory.InvalidOperation, null);
}
}
private SupervisionTransportRule LoadRule(string ruleName, ADObjectId supervisionTransportRuleCollectionId)
{
QueryFilter ruleFilter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Name, ruleName);
List <SupervisionTransportRule> supervisionRulesWithFilter = this.GetSupervisionRulesWithFilter(supervisionTransportRuleCollectionId, ruleFilter);
if (supervisionRulesWithFilter.Count == 0)
{
Dictionary <string, string> ruleNames = GetSupervisionPolicy.GetRuleNames();
base.WriteError(new SupervisionPoliciesNotFoundException(Strings.SupervisionPoliciesNotFound(ruleNames[ruleName])), (ErrorCategory)1003, ruleName);
}
else if (supervisionRulesWithFilter.Count > 1)
{
base.WriteError(new ManagementObjectAmbiguousException(Strings.SupervisionPolicyAmbiguous), (ErrorCategory)1003, null);
}
return(supervisionRulesWithFilter[0]);
}
internal IEnumerable <TenantIPInfo> FindPagedTenantIPs(ref string pageCookie, int pageSize)
{
List <TenantIPInfo> list = new List <TenantIPInfo>();
string text = pageCookie ?? string.Empty;
foreach (object propertyValue in ((IPartitionedDataProvider)this.WebStoreDataProvider).GetAllPhysicalPartitions())
{
QueryFilter baseQueryFilter = new ComparisonFilter(ComparisonOperator.Equal, DalHelper.PhysicalInstanceKeyProp, propertyValue);
QueryFilter pagingQueryFilter = PagingHelper.GetPagingQueryFilter(baseQueryFilter, text);
list.AddRange(this.WebStoreDataProvider.FindPaged <TenantIPInfo>(pagingQueryFilter, null, false, null, pageSize));
bool flag = true;
text = PagingHelper.GetProcessedCookie(pagingQueryFilter, out flag);
}
pageCookie = text;
return(list);
}
private static QueryFilter GetOrganizationMailboxQueryFilterForLocalServer()
{
Server server = LocalServer.GetServer();
Database[] databases = server.GetDatabases();
if (databases.Length > 0)
{
QueryFilter[] array = new QueryFilter[databases.Length];
for (int i = 0; i < databases.Length; i++)
{
array[i] = new ComparisonFilter(ComparisonOperator.Equal, ADMailboxRecipientSchema.Database, databases[i].Id);
}
return(QueryFilter.OrTogether(array));
}
return(new ComparisonFilter(ComparisonOperator.Equal, ADMailboxRecipientSchema.ServerName, server.Name));
}
internal static QueryFilter SmartIdFilterToNativeIdFilter(SinglePropertyFilter filter, SmartPropertyDefinition smartProperty, PropertyDefinition nativeProperty)
{
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter == null || !comparisonFilter.Property.Equals(smartProperty))
{
throw smartProperty.CreateInvalidFilterConversionException(filter);
}
if (comparisonFilter.ComparisonOperator != ComparisonOperator.Equal && comparisonFilter.ComparisonOperator != ComparisonOperator.NotEqual)
{
throw smartProperty.CreateInvalidFilterConversionException(filter);
}
StoreId id = (StoreId)comparisonFilter.PropertyValue;
return(new ComparisonFilter(comparisonFilter.ComparisonOperator, nativeProperty, StoreId.GetStoreObjectId(id).ProviderLevelItemId));
}
internal override QueryFilter SmartFilterToNativeFilter(SinglePropertyFilter filter)
{
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter != null)
{
return(new ComparisonFilter(comparisonFilter.ComparisonOperator, this.backingPropertyDefinition, ((StoreObjectId)comparisonFilter.PropertyValue).GetBytes()));
}
ExistsFilter existsFilter = filter as ExistsFilter;
if (existsFilter != null)
{
return(new ExistsFilter(this.backingPropertyDefinition));
}
throw base.CreateInvalidFilterConversionException(filter);
}
internal static QueryFilter DivergenceTimestampFilterBuilder(SinglePropertyFilter filter)
{
if (!(filter is ComparisonFilter))
{
throw new ADFilterException(DirectoryStrings.ExceptionUnsupportedFilterForProperty(filter.Property.Name, filter.GetType(), typeof(ComparisonFilter)));
}
ComparisonFilter comparisonFilter = (ComparisonFilter)filter;
if (ComparisonOperator.Like == comparisonFilter.ComparisonOperator || ComparisonOperator.IsMemberOf == comparisonFilter.ComparisonOperator)
{
throw new ADFilterException(DirectoryStrings.ExceptionUnsupportedOperatorForProperty(comparisonFilter.Property.Name, comparisonFilter.ComparisonOperator.ToString()));
}
long num = ((DateTime)comparisonFilter.PropertyValue).ToFileTimeUtc();
return(new ComparisonFilter(comparisonFilter.ComparisonOperator, FailedMSOSyncObjectSchema.DivergenceTimestampRaw, num));
}
internal static IList <IStorePropertyBag> FetchAllConfigurations(IFolder folder, SortBy[] sorts, int maxRow, params PropertyDefinition[] columns)
{
List <IStorePropertyBag> list = new List <IStorePropertyBag>();
SortBy[] array;
if (sorts == null)
{
array = new SortBy[]
{
new SortBy(InternalSchema.ItemClass, SortOrder.Ascending)
};
}
else
{
array = new SortBy[sorts.Length + 1];
array[0] = new SortBy(InternalSchema.ItemClass, SortOrder.Ascending);
Array.Copy(sorts, 0, array, 1, sorts.Length);
}
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, InternalSchema.ItemClass, "IPM.Configuration.");
IList <IStorePropertyBag> result;
using (IQueryResult queryResult = folder.IItemQuery(ItemQueryType.Associated, null, array, columns))
{
queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter);
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(10000);
bool flag = false;
while (!flag && propertyBags.Length > 0)
{
for (int i = 0; i < propertyBags.Length; i++)
{
string text = propertyBags[i].TryGetProperty(InternalSchema.ItemClass) as string;
if (text != null)
{
if (!text.StartsWith("IPM.Configuration.") || list.Count > maxRow)
{
flag = true;
break;
}
list.Add(propertyBags[i]);
}
}
propertyBags = queryResult.GetPropertyBags(10000);
}
result = list;
}
return(result);
}
private MultiValuedProperty <ComparisonFilter> SplitQueryFilter(QueryFilter filter)
{
MultiValuedProperty <ComparisonFilter> multiValuedProperty = new MultiValuedProperty <ComparisonFilter>();
if (filter == null)
{
return(multiValuedProperty);
}
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
AndFilter andFilter = filter as AndFilter;
if (comparisonFilter != null)
{
multiValuedProperty.Add(comparisonFilter);
}
else if (andFilter != null)
{
Stack <AndFilter> stack = new Stack <AndFilter>();
stack.Push(andFilter);
while (stack.Count != 0)
{
AndFilter andFilter2 = stack.Pop();
foreach (QueryFilter queryFilter in andFilter2.Filters)
{
ComparisonFilter comparisonFilter2 = queryFilter as ComparisonFilter;
AndFilter andFilter3 = queryFilter as AndFilter;
if (comparisonFilter2 != null)
{
multiValuedProperty.Add(comparisonFilter2);
}
else if (andFilter3 != null)
{
stack.Push(andFilter3);
}
else
{
this.cmdlet.WriteError(new LocalizedException(Strings.GetQueueDigestInvalidFilter(queryFilter.ToString())), ErrorCategory.InvalidArgument, null);
}
}
}
}
else
{
this.cmdlet.WriteError(new LocalizedException(Strings.GetQueueDigestInvalidFilter(filter.ToString())), ErrorCategory.InvalidArgument, null);
}
return(multiValuedProperty);
}
protected override bool ConfirmOperation(WorkUnitCollectionEventArgs inputArgs)
{
QueueViewerQueuesResultPane queueViewerQueuesResultPane = base.DataListViewResultPane as QueueViewerQueuesResultPane;
QueueIdentity queueIdentity = QueueIdentity.Parse(queueViewerQueuesResultPane.SelectedIdentity.ToString());
string message = base.SingleSelectionConfirmation(queueIdentity.ToString());
bool flag = DialogResult.Yes == queueViewerQueuesResultPane.ShowMessage(message, MessageBoxButtons.YesNo);
if (flag)
{
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.Equal, ExtensibleMessageInfoSchema.Queue, queueIdentity);
base.Parameters.Remove("Filter");
base.Parameters.AddWithValue("Filter", queryFilter.GenerateInfixString(FilterLanguage.Monad));
base.Parameters.Remove("Server");
base.Parameters.AddWithValue("Server", queueViewerQueuesResultPane.ServerName);
}
return(flag);
}
internal static QueryFilter ConversationIdBasedSmartFilterToNativeFilter(this SmartPropertyDefinition conversationIdSmartPropertyDefinition, SinglePropertyFilter filter, PropertyDefinition conversationIdNativePropertyDefinition)
{
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter != null)
{
ConversationId conversationId = (ConversationId)comparisonFilter.PropertyValue;
return(new ComparisonFilter(comparisonFilter.ComparisonOperator, conversationIdNativePropertyDefinition, conversationId.GetBytes()));
}
ExistsFilter existsFilter = filter as ExistsFilter;
if (existsFilter != null)
{
return(new ExistsFilter(conversationIdNativePropertyDefinition));
}
throw conversationIdSmartPropertyDefinition.CreateInvalidFilterConversionException(filter);
}
protected QueryFilter SinglePropertySmartFilterToNativeFilter(QueryFilter filter, PropertyDefinition nativeProperty)
{
MultivaluedInstanceComparisonFilter multivaluedInstanceComparisonFilter = filter as MultivaluedInstanceComparisonFilter;
if (multivaluedInstanceComparisonFilter != null)
{
return(new MultivaluedInstanceComparisonFilter(multivaluedInstanceComparisonFilter.ComparisonOperator, nativeProperty, multivaluedInstanceComparisonFilter.PropertyValue));
}
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter != null)
{
return(new ComparisonFilter(comparisonFilter.ComparisonOperator, nativeProperty, comparisonFilter.PropertyValue));
}
ExistsFilter existsFilter = filter as ExistsFilter;
if (existsFilter != null)
{
return(new ExistsFilter(nativeProperty));
}
TextFilter textFilter = filter as TextFilter;
if (textFilter != null)
{
return(new TextFilter(nativeProperty, textFilter.Text, textFilter.MatchOptions, textFilter.MatchFlags));
}
BitMaskFilter bitMaskFilter = filter as BitMaskFilter;
if (bitMaskFilter != null)
{
return(new BitMaskFilter(nativeProperty, bitMaskFilter.Mask, bitMaskFilter.IsNonZero));
}
BitMaskAndFilter bitMaskAndFilter = filter as BitMaskAndFilter;
if (bitMaskAndFilter != null)
{
return(new BitMaskAndFilter(nativeProperty, bitMaskAndFilter.Mask));
}
BitMaskOrFilter bitMaskOrFilter = filter as BitMaskOrFilter;
if (bitMaskOrFilter != null)
{
return(new BitMaskOrFilter(nativeProperty, bitMaskOrFilter.Mask));
}
throw this.CreateInvalidFilterConversionException(filter);
}
public static IADDatabase[] GetAllDatabases(IFindAdObject <IADDatabase> databaseLookup, IADServer server)
{
List <IADDatabase> list = new List <IADDatabase>(20);
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Name, server.Name);
IADDatabaseCopy[] array = databaseLookup.AdSession.Find <IADDatabaseCopy>(null, QueryScope.SubTree, filter, null, 0);
foreach (IADDatabaseCopy iaddatabaseCopy in array)
{
ADObjectId parent = iaddatabaseCopy.Id.Parent;
IADDatabase iaddatabase = databaseLookup.ReadAdObjectByObjectId(parent);
if (iaddatabase != null)
{
list.Add(iaddatabase);
}
}
return((list.Count <IADDatabase>() > 0) ? list.ToArray() : null);
}
private static ADRecipient GetADRecipientBySmtpAddress(SmtpAddress smtpAddress)
{
try
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, true, ConsistencyMode.IgnoreInvalid, null, ADSessionSettings.FromTenantAcceptedDomain(smtpAddress.Domain), 802, "GetADRecipientBySmtpAddress", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\SystemConfigurationTasks\\JournalRule\\JournalRuleObject.cs");
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.PrimarySmtpAddress, smtpAddress.ToString());
ADRecipient[] array = tenantOrRootOrgRecipientSession.Find <ADRecipient>(null, QueryScope.SubTree, filter, null, 1);
if (array != null && array.Length > 0)
{
return(array[0]);
}
}
catch (CannotResolveTenantNameException)
{
}
return(null);
}
// Token: 0x060003D1 RID: 977 RVA: 0x0001B3D8 File Offset: 0x000195D8
private void CollectItemsToMoveByDefault(MailboxSession session)
{
if (base.MailboxDataForTags.ElcUserTagInformation.MinDefaultMovePeriod == null)
{
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: MinDefaultMovePeriod is null. No move to archive default tag found.", this);
return;
}
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer, EnhancedTimeSpan>((long)this.GetHashCode(), "{0}: MinDefaultMovePeriod is {1}. About to collect items to move based on default archive tag.", this, base.MailboxDataForTags.ElcUserTagInformation.MinDefaultMovePeriod.Value);
PropertyIndexHolder propertyIndexHolder = new PropertyIndexHolder(ExpirationTagEnforcer.DefaultMoveQueryColumns);
base.Assistant.ThrowIfShuttingDown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
using (Folder noArchiveTagSearchFolder = new SearchFolderManager(base.MailboxDataForTags.MailboxSession).GetNoArchiveTagSearchFolder())
{
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer, int>((long)this.GetHashCode(), "{0}: Created the noArchiveTagSearchFolder. Item count: {1}", this, noArchiveTagSearchFolder.ItemCount);
if (noArchiveTagSearchFolder.ItemCount <= 0)
{
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: The search folder is empty. There are no items without an archive tag. Quit.", this);
}
else
{
using (QueryResult queryResult = noArchiveTagSearchFolder.ItemQuery(ItemQueryType.None, null, new SortBy[]
{
new SortBy(ItemSchema.ReceivedTime, SortOrder.Descending)
}, ExpirationTagEnforcer.DefaultMoveQueryColumns))
{
ComparisonFilter seekFilter = new ComparisonFilter(ComparisonOperator.LessThanOrEqual, ItemSchema.ReceivedTime, base.MailboxDataForTags.UtcNow.Subtract(base.MailboxDataForTags.ElcUserTagInformation.MinDefaultMovePeriod.Value));
if (queryResult.SeekToCondition(SeekReference.OriginBeginning, seekFilter))
{
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: Found at least one item that satifies the age and archive tag criteria.", this);
foreach (object[] array in queryResult.Enumerator(100))
{
if (array[propertyIndexHolder.RetentionDateIndex] != null && array[propertyIndexHolder.RetentionDateIndex] is ExDateTime && ((ExDateTime)array[propertyIndexHolder.RetentionDateIndex]).UniversalTime < base.MailboxDataForTags.UtcNow.Date)
{
ExpirationTagEnforcer.Tracer.TraceDebug <ExpirationTagEnforcer>((long)this.GetHashCode(), "{0}: Both retention date and archive date of the item have passed. Then the retention date wins. Skip adding the item to MTA list", this);
}
else
{
this.EvaluateAndEnlistItem(array, propertyIndexHolder);
}
}
}
}
base.Assistant.ThrottleStoreCallAndCheckForShutdown(base.MailboxDataForTags.MailboxSession.MailboxOwner);
}
}
}
internal static string FindUniqueSamAccountName(IRecipientSession session, ADObjectId dom, string samOrig)
{
string suffix = "";
for (int i = 1; i < 100; i++)
{
string text = InitializeExchangeUniversalGroups.Concat(samOrig, suffix, 256);
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, IADSecurityPrincipalSchema.SamAccountName, text);
ADRawEntry[] array = session.Find(dom, QueryScope.SubTree, filter, null, 1);
if (array.Length == 0)
{
return(text);
}
suffix = i.ToString();
}
return(InitializeExchangeUniversalGroups.Concat(samOrig, Guid.NewGuid().ToString("N"), 256));
}
internal static ADRecipient FindMailboxByLegacyDN(string legacyDN, IRecipientSession globalCatalogSession)
{
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.LegacyExchangeDN, legacyDN);
QueryFilter queryFilter2 = new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.RecipientType, RecipientType.UserMailbox);
AndFilter filter = new AndFilter(new QueryFilter[]
{
queryFilter2,
queryFilter
});
ADRecipient[] array = globalCatalogSession.Find(null, QueryScope.SubTree, filter, null, 1);
if (array != null && array.Length > 0)
{
return(array[0]);
}
return(null);
}
private void RollBackDivergences(bool isCompanyStream, DateTime latestCookieTimestamp)
{
ComparisonFilter comparisonFilter = new ComparisonFilter(isCompanyStream ? ComparisonOperator.Equal : ComparisonOperator.NotEqual, FailedMSOSyncObjectSchema.ExternalDirectoryObjectClass, DirectoryObjectClass.Company);
ComparisonFilter comparisonFilter2 = new ComparisonFilter(ComparisonOperator.GreaterThan, FailedMSOSyncObjectSchema.DivergenceTimestamp, latestCookieTimestamp);
ComparisonFilter comparisonFilter3 = new ComparisonFilter(ComparisonOperator.Equal, FailedMSOSyncObjectSchema.IsIncrementalOnly, true);
IEnumerable <FailedMSOSyncObject> enumerable = this.forwardSyncDataAccessHelper.FindDivergence(new AndFilter(new QueryFilter[]
{
comparisonFilter,
comparisonFilter2,
comparisonFilter3
}));
foreach (FailedMSOSyncObject divergence in enumerable)
{
this.forwardSyncDataAccessHelper.DeleteDivergence(divergence);
}
}
private List<IFilter> CreateFilters(string match, ComparisonOperation comparisonOperation, int columnIndex) {
IPreprocessingData preprocessingData = Content.PreprocessingData;
IStringConvertibleValue value;
if (preprocessingData.VariableHasType<double>(columnIndex)) {
value = new DoubleValue();
} else if (preprocessingData.VariableHasType<String>(columnIndex)) {
value = new StringValue();
} else if (preprocessingData.VariableHasType<DateTime>(columnIndex)) {
value = new DateTimeValue();
} else {
throw new ArgumentException("unsupported type");
}
value.SetValue(match);
var comparisonFilter = new ComparisonFilter(preprocessingData, GetConstraintOperation(comparisonOperation), value, true);
comparisonFilter.ConstraintColumn = columnIndex;
return new List<Filter.IFilter>() { comparisonFilter };
}
public void PerformCompare(ComparisonFilter filter)
{
for (int i = 1; i < _assemblies.Count; i++)
{
_assemblies[i].PerformCompare(_assemblies[i - 1]);
_assemblies[i].ApplyFilter(filter);
}
_change = ChangeType.None;
foreach (AssemblyDetail ad in _assemblies)
{
if (ChangeTypeUtil.HasBreaking(ad.Change))
{
_change = ChangeType.MembersChangedBreaking;
break;
}
else if (ChangeTypeUtil.HasNonBreaking(ad.Change))
{
_change = ChangeType.MembersChangedNonBreaking;
}
}
}
public void Filters_ChangedOnly_Nested_Child()
{
ComparisonFilter filter = new ComparisonFilter();
filter.ChangedItemsOnly = true;
DoCompareAndVerifyStillPresent(filter, "BitDiffer.Tests.Subject", "ParentClassPublicGrandchildChanges", "NestedPublicClass");
}
private bool FilterMatches(ComparisonFilter filter, Visibility visibility)
{
switch (visibility)
{
case Visibility.Public: return filter.IncludePublic;
case Visibility.Exported: return filter.IncludePublic;
case Visibility.Internal: return filter.IncludeInternal;
case Visibility.Private: return filter.IncludePrivate;
case Visibility.Protected: return filter.IncludeProtected;
case Visibility.ProtectedInternal: return filter.IncludeProtected || filter.IncludeInternal;
case Visibility.ProtectedPrivate: return filter.IncludePrivate || filter.IncludeProtected;
default: return false;
}
}
protected override void ApplyFilterInstance(ComparisonFilter filter)
{
base.ApplyFilterInstance(filter);
if (!filter.IncludePublic || !filter.IncludeProtected || !filter.IncludePrivate || !filter.IncludeInternal)
{
if (FilterMatches(filter, _visibility))
{
SetFilterStatus(FilterStatus.Include);
}
else
{
if (this.NavigateBackward == null)
{
SetFilterStatus(FilterStatus.ExcludeBlock);
}
else
{
Visibility priorVisibility = ((MemberDetail)this.NavigateBackward).Visibility;
if (FilterMatches(filter, priorVisibility))
{
SetFilterStatus(FilterStatus.Include);
}
else
{
SetFilterStatus(FilterStatus.ExcludeBlock);
}
}
}
}
}
private static AssemblyComparison DoCompare(ComparisonFilter filter)
{
AssemblyComparison ac = new AssemblyComparer().CompareAssemblyFiles(DiffConfig.Default, filter, Subjects.One, Subjects.Two);
Assert.AreEqual(1, ac.Groups.Count);
Assert.AreEqual(2, ac.Groups[0].Assemblies.Count);
return ac;
}
public void Filters_ChangedOnly_Removed()
{
ComparisonFilter filter = new ComparisonFilter();
filter.ChangedItemsOnly = true;
DoCompareAndVerifyRemoved(filter, "BitDiffer.Tests.Subject", "BasicClass", "_privateField");
}
public void Filters_TextFilter_NoMatches()
{
ComparisonFilter filter = new ComparisonFilter();
filter.TextFilter = "bogus";
AssemblyComparison ac = DoCompare(ComparisonFilter.Default);
Assert.AreEqual(true, ac.Groups[0].Assemblies[1].FilterChildren<ICanAlign>().GetEnumerator().MoveNext());
ac.Recompare(filter);
Assert.AreEqual(false, ac.Groups[0].Assemblies[1].FilterChildren<ICanAlign>().GetEnumerator().MoveNext());
}
public void Filters_TextFilter_StillPresent()
{
ComparisonFilter filter = new ComparisonFilter();
filter.TextFilter = "_privateField";
DoCompareAndVerifyStillPresent(filter, "BitDiffer.Tests.Subject", "BasicClass", "_privateField");
}
public void Filters_ChangedOnly_Nested_Parent()
{
ComparisonFilter filter = new ComparisonFilter();
filter.ChangedItemsOnly = true;
DoCompareAndVerifyRemoved(filter, "BitDiffer.Tests.Subject", "ParentClass");
}
public void Filters_IgnoreAssemAttributes()
{
ComparisonFilter filter = new ComparisonFilter();
filter.IgnoreAssemblyAttributeChanges = true;
DoCompareAndVerifyChange(filter, ChangeType.DeclarationChangedNonBreaking, ChangeType.None, "Attributes", "System.Reflection.AssemblyDescriptionAttribute");
}
public void Filters_IgnoreAssemAttributes_OtherAttersNotAffected()
{
ComparisonFilter filter = new ComparisonFilter();
filter.IgnoreAssemblyAttributeChanges = true;
DoCompareAndVerifyChange(filter, ChangeType.DeclarationChangedNonBreaking, ChangeType.DeclarationChangedNonBreaking, "BitDiffer.Tests.Subject", "BasicClass", "MethodAttributeChanges", "System.ComponentModel.DescriptionAttribute");
}
public AssemblyComparison CompareAssemblyFiles(DiffConfig config, ComparisonFilter filter, params string[] assemblyFiles)
{
_config = config;
_filter = filter;
if (_progress != null)
{
_progress.SetMaxRange(assemblyFiles.Length);
}
if (assemblyFiles.Length == 0)
{
return null;
}
AppDomainIsolationLevel level = _config.IsolationLevel;
if (level == AppDomainIsolationLevel.AutoDetect)
{
level = IsolationDetector.AutoDetectIsolationLevelFiles(assemblyFiles);
}
AssemblyManager manager = AssemblyManagerFactory.Create(level);
AssemblyComparison ac = new AssemblyComparison();
ac.Groups.Add(DoCompareFiles(manager, assemblyFiles));
manager.AllExtractionsComplete();
return ac;
}
public AssemblyComparison CompareAssemblyDirectories(bool recurse, DiffConfig config, ComparisonFilter filter, params string[] assemblyDirectories)
{
_config = config;
_filter = filter;
int totalFiles = 0;
List<List<ICanAlign>> allEntries = new List<List<ICanAlign>>();
SearchOption option = recurse ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly;
foreach (string dir in assemblyDirectories)
{
List<ICanAlign> entry = new List<ICanAlign>();
entry.AddRange(AssemblyDirectoryEntry.From(dir, Directory.GetFiles(dir, "*.dll", option)));
entry.AddRange(AssemblyDirectoryEntry.From(dir, Directory.GetFiles(dir, "*.exe", option)));
totalFiles += entry.Count;
allEntries.Add(entry);
}
if (allEntries.Count == 0)
{
return null;
}
AppDomainIsolationLevel level = _config.IsolationLevel;
if (level == AppDomainIsolationLevel.AutoDetect)
{
level = IsolationDetector.AutoDetectIsolationLevelDirs(assemblyDirectories);
}
ListOperations.AlignListsNoParent(allEntries.ToArray());
AssemblyManager manager = AssemblyManagerFactory.Create(level);
AssemblyComparison ac = new AssemblyComparison();
if (_progress != null)
{
_progress.SetMaxRange(totalFiles);
}
for (int j = 0; j < allEntries[0].Count; j++)
{
List<string> thisRun = new List<string>();
for (int i = 0; i < allEntries.Count; i++)
{
if (allEntries[i][j].Status == Status.Present)
{
thisRun.Add(((AssemblyDirectoryEntry)allEntries[i][j]).Path);
}
}
ac.Groups.Add(DoCompareFiles(manager, thisRun.ToArray()));
}
manager.AllExtractionsComplete();
return ac;
}
public void Filters_PublicOnly_Removed()
{
ComparisonFilter filter = new ComparisonFilter();
filter.IncludeProtected = false;
filter.IncludeInternal = false;
filter.IncludePrivate = false;
DoCompareAndVerifyRemoved(filter, "BitDiffer.Tests.Subject", "BasicClass", "_privateField");
}
public void Filters_ChangedOnly_ParentChangedByChild()
{
ComparisonFilter filter = new ComparisonFilter();
filter.IgnoreAssemblyAttributeChanges = true;
DoCompareAndVerifyChange(filter, ChangeType.MembersChangedNonBreaking, ChangeType.None, "Attributes");
}
private static void DoCompareAndVerifyChange(ComparisonFilter filter, ChangeType withoutFilter, ChangeType withFilter, params string[] names)
{
AssemblyComparison ac = DoCompare(ComparisonFilter.Default);
Assert.AreEqual(withoutFilter, FindInAssembly(ac, names).Change);
ac.Recompare(filter);
Assert.AreEqual(withFilter, FindInAssembly(ac, names).Change);
}
public void Filters_TextFilter_Removed_Sibling()
{
ComparisonFilter filter = new ComparisonFilter();
filter.TextFilter = "_privateField";
DoCompareAndVerifyRemoved(filter, "BitDiffer.Tests.Subject", "BasicClass", "_publicField");
}
private void FilterResultSet(AssemblyComparison ac, ComparisonFilter filter)
{
if (ac == null || filter == null)
{
return;
}
if (filter.ChangedItemsOnly)
{
var removeList = ac.Groups.ToList().Where(g => g.Change == ChangeType.None && !g.HasErrors);
removeList.ToList().ForEach(i => ac.Groups.Remove(i));
}
}
public void Filters_TextFilter_Removed_Child()
{
ComparisonFilter filter = new ComparisonFilter();
filter.TextFilter = "Basic"; // This will keep basic class itself but remove it's children
DoCompareAndVerifyRemoved(filter, "BitDiffer.Tests.Subject", "BasicClass", "_privateField");
}
public void Filters_ChangedOnly_StillPresent()
{
ComparisonFilter filter = new ComparisonFilter();
filter.ChangedItemsOnly = true;
DoCompareAndVerifyStillPresent(filter, "BitDiffer.Tests.Subject", "BasicClass", "PublicEventDeclChange");
}
private static void DoCompareAndVerifyStillPresent(ComparisonFilter filter, params string[] names)
{
AssemblyComparison ac = DoCompare(ComparisonFilter.Default);
Assert.AreEqual(Status.Present, FindInAssembly(ac, names).Status);
ac.Recompare(filter);
Assert.AreEqual(Status.Present, FindInAssembly(ac, names).Status);
}
public void Filters_MethodImpl()
{
ComparisonFilter filter = new ComparisonFilter();
filter.CompareMethodImplementations = false;
DoCompareAndVerifyChange(filter, ChangeType.ImplementationChanged, ChangeType.None, "BitDiffer.Tests.Subject", "BasicClass", "MethodBodyChanges");
}
