// Token: 0x06000093 RID: 147 RVA: 0x00003EE8 File Offset: 0x000020E8 public TreeNode CreateSubtree() { ScopeNode scopeNode = null; RangeNode <long> rangeNode = new RangeNode <long>(); rangeNode.StartInclusive = new bool?(true); rangeNode.Start = this.CountMinimum; rangeNode.EndInclusive = new bool?(true); rangeNode.End = this.CountMaximum; ScopeNode scopeNode2 = new ScopeNode("ClassificationCount"); scopeNode2.FirstChild = rangeNode; if (!this.isDefaultConfidenceRange) { RangeNode <long> rangeNode2 = new RangeNode <long>(); rangeNode2.StartInclusive = new bool?(true); rangeNode2.Start = this.ConfidenceMinimum; rangeNode2.EndInclusive = new bool?(true); rangeNode2.End = this.ConfidenceMaximum; scopeNode = new ScopeNode("ClassificationConfidence"); scopeNode.FirstChild = rangeNode2; } TreeNode treeNode; if (this.isDefaultConfidenceRange) { treeNode = scopeNode2; } else if (this.isDefaultCountRange) { treeNode = scopeNode; } else { AndNode andNode = new AndNode(); andNode.AddNode(scopeNode2); andNode.AddNode(scopeNode); treeNode = andNode; } if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(6121180U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "ClassificationDecoding.CreateSubtree :: subtree={0}; Result of transforming the query.", new object[] { treeNode }); } return(treeNode); }
// Token: 0x06000017 RID: 23 RVA: 0x000027A4 File Offset: 0x000009A4 public void SetClassificationResults(ICAClassificationResultCollection results) { if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(4850008U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "FASTClassificationItem.SetClassificationResults :: saving results for [{0}]", new object[] { this.ItemId }); } IUpdateableBucketField updateableBucketField = this.record[this.managedPropertiesPosition] as IUpdateableBucketField; if (updateableBucketField != null) { if (this.persistClassificationData) { updateableBucketField.AddField(this.lastScanPropertyName, StandardFields.GetStandardDateTimeField(new DateTime?(DateTime.UtcNow)), BuiltInTypes.DateTimeType); } ICollection <long?> collection = new List <long?>(); ICollection <long?> collection2 = new List <long?>(); ICollection <string> collection3 = new List <string>(); HashSet <long> hashSet = new HashSet <long>(); if (results != null && results.Count > 0) { this.resultCount = results.Count; for (int i = 0; i < this.resultCount; i++) { ICAClassificationResult icaclassificationResult = results[i + 1]; if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(4850009U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "FASTClassificationItem.SetClassificationResults :: Results Found :: package={0} ruleId={1}", new object[] { icaclassificationResult.RulePackageID, icaclassificationResult.ID }); } long?resultBase = this.ruleStore.GetResultBase(icaclassificationResult.RulePackageID, icaclassificationResult.ID); if (resultBase == null) { ULS.SendTraceTag(6038295U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 50, "FASTClassificationItem.SetClassificationResults :: Unkwown rule ID in result (should not happen). :: package={0} ruleId={1}", new object[] { icaclassificationResult.RulePackageID, icaclassificationResult.ID }); } else { long value = resultBase.Value; if (!hashSet.Add(value)) { ULS.SendTraceTag(5833436U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 50, "FASTClassificationItem.SetClassificationResults :: Duplicate rule entry is being ignored. Duplicate rule entries should not happen. :: package={0} ruleId={1}", new object[] { icaclassificationResult.RulePackageID, icaclassificationResult.ID }); } else { long value2 = value + (long)((int)icaclassificationResult.GetAttributeValue("BD770258-EA9C-4162-B79C-7AD408EC7CD5")); long value3 = value + (long)((int)icaclassificationResult.GetAttributeValue("AFF85B32-1BA9-4EDE-9286-F08A7EE5A421")); collection.Add(new long?(value2)); collection2.Add(new long?(value3)); collection3.Add(icaclassificationResult.ID); } } } if (this.persistClassificationData && this.resultCount > 0) { if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(4850010U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "FASTClassificationItem.SetClassificationResults :: Updating managed properties"); } IUpdateableListField <long?> updateableListField = (IUpdateableListField <long?>)StandardFields.ListDescriptor <long?>(BuiltInTypes.Int64Type).CreateField(); updateableListField.Value = collection; updateableBucketField.AddField(this.countPropertyName, updateableListField, BuiltInTypes.ListType(BuiltInTypes.Int64Type)); updateableListField = (IUpdateableListField <long?>)StandardFields.ListDescriptor <long?>(BuiltInTypes.Int64Type).CreateField(); updateableListField.Value = collection2; updateableBucketField.AddField(this.confidencePropertyName, updateableListField, BuiltInTypes.ListType(BuiltInTypes.Int64Type)); IUpdateableListField <string> updateableListField2 = (IUpdateableListField <string>)StandardFields.ListDescriptor <string>(BuiltInTypes.StringType).CreateField(); updateableListField2.Value = collection3; updateableBucketField.AddField(this.typePropertyName, updateableListField2, BuiltInTypes.ListType(BuiltInTypes.StringType)); } } } }
// Token: 0x060000BF RID: 191 RVA: 0x00004FEC File Offset: 0x000031EC protected override TreeNode ProcessScopeSubQueryTree(TreeNode scopeSubQueryTree) { if (scopeSubQueryTree == null) { throw new ArgumentNullException("scopeSubQueryTree"); } ScopeNode scopeNode = scopeSubQueryTree as ScopeNode; if (scopeNode == null || scopeNode.Scope == null) { ULS.SendTraceTag(5884049U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 20, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: argument={0}; Erroneously entered ProcessScopeSubQueryTree with an argument that is not a ScopeNode. This should not have happened because the scopes of the associated operator should prevent it.", new object[] { scopeSubQueryTree.ToString() }); return(base.ProcessScopeSubQueryTree(scopeSubQueryTree)); } if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(5884050U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: scope={0}; Processing a tree (or subtree) for data loss prevention translation from a virtual property to the actual index property.", new object[] { scopeNode.Scope }); } string scope = scopeNode.Scope; if (string.Equals("SensitiveType", scope, StringComparison.OrdinalIgnoreCase)) { BoundaryNode boundaryNode = scopeNode.Node as BoundaryNode; StringNode stringNode; TokenNode tokenNode; if (boundaryNode != null) { if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(6038296U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: Boundary operator mode:{0}; Processing a boundary node in the query tree." + boundaryNode.BoundaryMode); } if (boundaryNode.BoundaryMode != 2 && boundaryNode.BoundaryMode != null) { ULS.SendTraceTag(5884051U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 50, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: Unexpected boundary operator mode. For 'SensitiveType' queries, only equality is legal. Boundary operator mode: " + boundaryNode.BoundaryMode); return(base.ProcessScopeSubQueryTree(scopeSubQueryTree)); } stringNode = (boundaryNode.Node as StringNode); tokenNode = (boundaryNode.Node as TokenNode); } else { stringNode = (scopeNode.Node as StringNode); tokenNode = (scopeNode.Node as TokenNode); } string text; if (stringNode != null) { text = stringNode.Text; } else { if (tokenNode == null) { ULS.SendTraceTag(5884052U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 50, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: Unexpected node type. The query looks like it is a 'SensitiveType' style query, but the value portion is not a StringNode or a TokenNode. Node type: " + boundaryNode.Node.GetType()); return(base.ProcessScopeSubQueryTree(scopeSubQueryTree)); } text = tokenNode.Token; } if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(5884053U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: encoding={0}; About to parse the encoding.", new object[] { text }); } SensitiveTypeWildcardExpander sensitiveTypeWildcardExpander = new SensitiveTypeWildcardExpander(text, DLPQuerySensitiveTypeTranslationOperator.Store); if (ULS.ShouldTrace(ULSCat.msoulscat_SEARCH_DataLossPrevention, 100)) { ULS.SendTraceTag(5884054U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 100, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: About to create the new subtree."); } return(sensitiveTypeWildcardExpander.CreateSubtree()); } if (string.Equals("SensitiveMatchConfidence", scope, StringComparison.OrdinalIgnoreCase) || string.Equals("SensitiveMatchCount", scope, StringComparison.OrdinalIgnoreCase)) { throw new ArgumentException(scope + " is illegal to use in a query. You may use it as a select property. In queries, use SensitiveType"); } ULS.SendTraceTag(5884055U, ULSCat.msoulscat_SEARCH_DataLossPrevention, 20, "DLPQuerySensitiveTypeTranslationProducer.ProcessScopeSubQueryTree :: scope={0}; This is not a legal scope for this producer. There must be some error in which the operator has the wrong scopes or a code change is incorrect. Ignoring and continuing.", new object[] { scope }); return(base.ProcessScopeSubQueryTree(scopeSubQueryTree)); }