private static bool EvaluateComparePropertyRestriction(Restriction.ComparePropertyRestriction restriction, IRuleEvaluationContext context)
{
RestrictionEvaluator.ValidateComparePropertyRestriction(restriction);
object obj = context[restriction.TagLeft];
object obj2 = context[restriction.TagRight];
context.TraceFunction <PropTag, Restriction.RelOp, PropTag>("ComparePropertyRestriction [{0}] {1} [{2}]", restriction.TagLeft, restriction.Op, restriction.TagRight);
bool flag = false;
if (obj != null && obj2 != null)
{
flag = context.CompareSingleValue(restriction.TagLeft, restriction.Op, obj, obj2);
}
context.TraceFunction <object, Restriction.RelOp, object, bool>("[{0}] {1} [{2}] evaluated to {3}", obj, restriction.Op, obj2, flag);
return(flag);
}
private static void ValidateComparePropertyRestriction(Restriction.ComparePropertyRestriction restriction)
{
if (!RestrictionEvaluator.IsSupportedOperation(restriction.Op))
{
throw new InvalidRuleException(string.Format("Operation {0} is not supported", restriction.Op));
}
if (!RuleUtil.IsSameType(restriction.TagLeft, restriction.TagRight))
{
throw new InvalidRuleException("Tag and value are of different type");
}
if (RuleUtil.IsBooleanTag(restriction.TagLeft) && restriction.Op != Restriction.RelOp.Equal && restriction.Op != Restriction.RelOp.NotEqual)
{
throw new InvalidRuleException("Boolean tag only support Equal or NotEqual operation");
}
if (RuleUtil.IsMultiValueTag(restriction.TagLeft) || RuleUtil.IsMultiValueTag(restriction.TagRight))
{
throw new InvalidRuleException("Multi-valued prop or value is not supported in CompareProperty Restriction");
}
}
private static void DumpRestriction(StringBuilder sb, Restriction restriction)
{
if (restriction == null)
{
return;
}
sb.Append("(");
Restriction.ResType type = restriction.Type;
switch (type)
{
case Restriction.ResType.And:
{
Restriction.AndRestriction andRestriction = (Restriction.AndRestriction)restriction;
sb.Append("AND ");
foreach (Restriction restriction2 in andRestriction.Restrictions)
{
GetFolderRestriction.DumpRestriction(sb, restriction2);
}
break;
}
case Restriction.ResType.Or:
{
Restriction.OrRestriction orRestriction = (Restriction.OrRestriction)restriction;
sb.Append("OR ");
foreach (Restriction restriction3 in orRestriction.Restrictions)
{
GetFolderRestriction.DumpRestriction(sb, restriction3);
}
break;
}
case Restriction.ResType.Not:
{
Restriction.NotRestriction notRestriction = (Restriction.NotRestriction)restriction;
sb.Append("NOT ");
GetFolderRestriction.DumpRestriction(sb, notRestriction.Restriction);
break;
}
case Restriction.ResType.Content:
{
Restriction.ContentRestriction contentRestriction = (Restriction.ContentRestriction)restriction;
sb.AppendFormat("CONTENT flags:{0} mv:{1} propTag:{2:X} propValue:(", contentRestriction.Flags, contentRestriction.MultiValued, contentRestriction.PropTag);
GetFolderRestriction.DumpPropValue(sb, contentRestriction.PropValue);
sb.Append(")");
break;
}
case Restriction.ResType.Property:
{
Restriction.PropertyRestriction propertyRestriction = (Restriction.PropertyRestriction)restriction;
sb.AppendFormat("PROPERTY Op:{0}, propTag:{1:X} propValue:", propertyRestriction.Op, propertyRestriction.PropTag);
GetFolderRestriction.DumpPropValue(sb, propertyRestriction.PropValue);
break;
}
case Restriction.ResType.CompareProps:
{
Restriction.ComparePropertyRestriction comparePropertyRestriction = (Restriction.ComparePropertyRestriction)restriction;
sb.AppendFormat("COMPPROPS Op:{0} propTag1:{1:X} propTag2:{2:X}", comparePropertyRestriction.Op, comparePropertyRestriction.TagLeft, comparePropertyRestriction.TagRight);
break;
}
case Restriction.ResType.BitMask:
{
Restriction.BitMaskRestriction bitMaskRestriction = (Restriction.BitMaskRestriction)restriction;
sb.AppendFormat("BITMASK Bmr:{0} Mask:{1:X} propTag:{2:X}", bitMaskRestriction.Bmr, bitMaskRestriction.Mask, bitMaskRestriction.Tag);
break;
}
case Restriction.ResType.Size:
{
Restriction.SizeRestriction sizeRestriction = (Restriction.SizeRestriction)restriction;
sb.AppendFormat("SIZE propTag:{0:X} Op:{1} size:{2}", sizeRestriction.Tag, sizeRestriction.Op, sizeRestriction.Size);
break;
}
case Restriction.ResType.Exist:
{
Restriction.ExistRestriction existRestriction = (Restriction.ExistRestriction)restriction;
sb.AppendFormat("EXIST propTag:{0:X}", existRestriction.Tag);
break;
}
case Restriction.ResType.SubRestriction:
{
Restriction.SubRestriction subRestriction = (Restriction.SubRestriction)restriction;
sb.Append("SUBRESTRICTION ");
GetFolderRestriction.DumpRestriction(sb, subRestriction.Restriction);
break;
}
case Restriction.ResType.Comment:
{
Restriction.CommentRestriction commentRestriction = (Restriction.CommentRestriction)restriction;
sb.AppendFormat("COMMENT values:{0} ", commentRestriction.Values.Length);
foreach (PropValue v in commentRestriction.Values)
{
GetFolderRestriction.DumpPropValue(sb, v);
}
GetFolderRestriction.DumpRestriction(sb, commentRestriction.Restriction);
break;
}
case Restriction.ResType.Count:
{
Restriction.CountRestriction countRestriction = (Restriction.CountRestriction)restriction;
sb.AppendFormat("COUNT {0} ", countRestriction.Count);
GetFolderRestriction.DumpRestriction(sb, countRestriction.Restriction);
break;
}
default:
switch (type)
{
case Restriction.ResType.True:
sb.Append("TRUE");
break;
case Restriction.ResType.False:
sb.Append("FALSE");
break;
default:
sb.AppendFormat("<UNKNOWN RESTYPE:{0}>", restriction.Type);
break;
}
break;
}
sb.Append(")");
}
internal static Restriction ConvertFromMapiRestriction(Restriction restriction, int codePage)
{
if (restriction == null)
{
return(null);
}
switch (restriction.Type)
{
case Restriction.ResType.And:
return(new AndRestriction((from r in ((Restriction.AndRestriction)restriction).Restrictions
select ConvertHelper.ConvertFromMapiRestriction(r, codePage)).ToArray <Restriction>()));
case Restriction.ResType.Or:
return(new OrRestriction((from r in ((Restriction.OrRestriction)restriction).Restrictions
select ConvertHelper.ConvertFromMapiRestriction(r, codePage)).ToArray <Restriction>()));
case Restriction.ResType.Not:
return(new NotRestriction(ConvertHelper.ConvertFromMapiRestriction((Restriction.NotRestriction)restriction, codePage)));
case Restriction.ResType.Content:
{
Restriction.ContentRestriction contentRestriction = (Restriction.ContentRestriction)restriction;
return(new ContentRestriction((FuzzyLevel)contentRestriction.Flags, ConvertHelper.ConvertFromMapiPropTag(contentRestriction.PropTag), new PropertyValue?(ConvertHelper.ConvertFromMapiPropValue(contentRestriction.PropValue, codePage))));
}
case Restriction.ResType.Property:
{
Restriction.PropertyRestriction propertyRestriction = (Restriction.PropertyRestriction)restriction;
RelationOperator relop = ConvertHelper.ConvertFromMapiRelOp(propertyRestriction.Op);
PropertyTag propertyTag = ConvertHelper.ConvertFromMapiPropTag(propertyRestriction.PropTag);
PropertyValue value = ConvertHelper.ConvertFromMapiPropValue(propertyRestriction.PropValue, codePage);
return(new PropertyRestriction(relop, propertyTag, new PropertyValue?(value)));
}
case Restriction.ResType.CompareProps:
{
Restriction.ComparePropertyRestriction comparePropertyRestriction = (Restriction.ComparePropertyRestriction)restriction;
return(new ComparePropsRestriction(ConvertHelper.ConvertFromMapiRelOp(comparePropertyRestriction.Op), ConvertHelper.ConvertFromMapiPropTag(comparePropertyRestriction.TagLeft), ConvertHelper.ConvertFromMapiPropTag(comparePropertyRestriction.TagRight)));
}
case Restriction.ResType.BitMask:
{
Restriction.BitMaskRestriction bitMaskRestriction = (Restriction.BitMaskRestriction)restriction;
return(new BitMaskRestriction(ConvertHelper.ConvertFromMapiRelBmr(bitMaskRestriction.Bmr), ConvertHelper.ConvertFromMapiPropTag(bitMaskRestriction.Tag), (uint)bitMaskRestriction.Mask));
}
case Restriction.ResType.Size:
{
Restriction.SizeRestriction sizeRestriction = (Restriction.SizeRestriction)restriction;
return(new SizeRestriction(ConvertHelper.ConvertFromMapiRelOp(sizeRestriction.Op), ConvertHelper.ConvertFromMapiPropTag(sizeRestriction.Tag), (uint)sizeRestriction.Size));
}
case Restriction.ResType.Exist:
{
Restriction.ExistRestriction existRestriction = (Restriction.ExistRestriction)restriction;
return(new ExistsRestriction(ConvertHelper.ConvertFromMapiPropTag(existRestriction.Tag)));
}
case Restriction.ResType.SubRestriction:
{
Restriction.SubRestriction subRestriction = (Restriction.SubRestriction)restriction;
return(new SubRestriction((SubRestrictionType)subRestriction.Type, ConvertHelper.ConvertFromMapiRestriction(subRestriction.Restriction, codePage)));
}
default:
throw new NspiException(NspiStatus.InvalidParameter, string.Format("Invalid MAPI restriction type: {0}", restriction));
}
}
internal ComparePropertyRestrictionData(Restriction.ComparePropertyRestriction r)
{
this.RelOp = (int)r.Op;
this.TagLeft = (int)r.TagLeft;
this.TagRight = (int)r.TagRight;
}
internal void WriteRestriction(Restriction restriction)
{
if (restriction is Restriction.BitMaskRestriction)
{
Restriction.BitMaskRestriction bitMaskRestriction = (Restriction.BitMaskRestriction)restriction;
this.WriteInt(6);
this.WriteInt((int)bitMaskRestriction.Bmr);
this.WriteInt((int)bitMaskRestriction.Tag);
this.WriteInt(bitMaskRestriction.Mask);
return;
}
if (restriction is Restriction.AndRestriction)
{
this.WriteInt(0);
Restriction.AndRestriction andRestriction = (Restriction.AndRestriction)restriction;
this.WriteInt(andRestriction.Restrictions.Length);
foreach (Restriction restriction2 in andRestriction.Restrictions)
{
this.WriteRestriction(restriction2);
}
return;
}
if (restriction is Restriction.OrRestriction)
{
this.WriteInt(1);
Restriction.OrRestriction orRestriction = (Restriction.OrRestriction)restriction;
this.WriteInt(orRestriction.Restrictions.Length);
foreach (Restriction restriction3 in orRestriction.Restrictions)
{
this.WriteRestriction(restriction3);
}
return;
}
if (restriction is Restriction.NotRestriction)
{
Restriction.NotRestriction notRestriction = (Restriction.NotRestriction)restriction;
this.WriteInt(2);
this.WriteRestriction(notRestriction.Restriction);
return;
}
if (restriction is Restriction.ContentRestriction)
{
Restriction.ContentRestriction contentRestriction = (Restriction.ContentRestriction)restriction;
this.WriteInt(3);
this.WriteInt((int)contentRestriction.Flags);
this.WriteInt((int)contentRestriction.PropTag);
this.WritePropValue(contentRestriction.PropValue.PropTag, contentRestriction.PropValue.Value);
return;
}
if (restriction is Restriction.PropertyRestriction)
{
Restriction.PropertyRestriction propertyRestriction = (Restriction.PropertyRestriction)restriction;
this.WriteInt(4);
this.WriteInt((int)propertyRestriction.Op);
this.WriteInt((int)propertyRestriction.PropTag);
this.WritePropValue(propertyRestriction.PropValue.PropTag, propertyRestriction.PropValue.Value);
return;
}
if (restriction is Restriction.ComparePropertyRestriction)
{
Restriction.ComparePropertyRestriction comparePropertyRestriction = (Restriction.ComparePropertyRestriction)restriction;
this.WriteInt(5);
this.WriteInt((int)comparePropertyRestriction.Op);
this.WriteInt((int)comparePropertyRestriction.TagLeft);
this.WriteInt((int)comparePropertyRestriction.TagRight);
return;
}
if (restriction is Restriction.ExistRestriction)
{
Restriction.ExistRestriction existRestriction = (Restriction.ExistRestriction)restriction;
this.WriteInt(8);
this.WriteInt((int)existRestriction.Tag);
return;
}
if (restriction is Restriction.AttachmentRestriction)
{
Restriction.AttachmentRestriction attachmentRestriction = (Restriction.AttachmentRestriction)restriction;
this.WriteInt(9);
this.WriteInt(236126221);
this.WriteRestriction(attachmentRestriction.Restriction);
return;
}
if (restriction is Restriction.RecipientRestriction)
{
Restriction.RecipientRestriction recipientRestriction = (Restriction.RecipientRestriction)restriction;
this.WriteInt(9);
this.WriteInt(236060685);
this.WriteRestriction(recipientRestriction.Restriction);
return;
}
throw new ArgumentException(ServerStrings.ExUnknownRestrictionType, "restriction");
}
private void WriteRestriction(Restriction restriction)
{
this.writer.WriteStartElement("Restriction");
if (restriction != null)
{
Restriction.ResType type = restriction.Type;
this.writer.WriteAttributeString("Type", type.ToString());
Restriction.ResType resType = type;
switch (resType)
{
case Restriction.ResType.And:
this.WriteRestrictions("And", ((Restriction.AndRestriction)restriction).Restrictions);
break;
case Restriction.ResType.Or:
this.WriteRestrictions("Or", ((Restriction.OrRestriction)restriction).Restrictions);
break;
case Restriction.ResType.Not:
this.writer.WriteStartElement("Not");
this.WriteRestriction(((Restriction.NotRestriction)restriction).Restriction);
this.writer.WriteEndElement();
break;
case Restriction.ResType.Content:
{
Restriction.ContentRestriction contentRestriction = (Restriction.ContentRestriction)restriction;
this.writer.WriteAttributeString("ContentFlags", RuleWriter.EnumToString(contentRestriction.Flags));
this.writer.WriteAttributeString("PropTag", RuleWriter.EnumToString(contentRestriction.PropTag));
this.writer.WriteAttributeString("MultiValued", contentRestriction.MultiValued.ToString());
this.WritePropValue(contentRestriction.PropValue);
break;
}
case Restriction.ResType.Property:
{
Restriction.PropertyRestriction propertyRestriction = (Restriction.PropertyRestriction)restriction;
this.writer.WriteAttributeString("Operation", propertyRestriction.Op.ToString());
this.writer.WriteAttributeString("PropTag", RuleWriter.EnumToString(propertyRestriction.PropTag));
this.writer.WriteAttributeString("MultiValued", propertyRestriction.MultiValued.ToString());
this.WritePropValue(propertyRestriction.PropValue);
break;
}
case Restriction.ResType.CompareProps:
{
Restriction.ComparePropertyRestriction comparePropertyRestriction = (Restriction.ComparePropertyRestriction)restriction;
this.writer.WriteAttributeString("Operation", comparePropertyRestriction.Op.ToString());
this.writer.WriteAttributeString("PropTagLeft", RuleWriter.EnumToString(comparePropertyRestriction.TagLeft));
this.writer.WriteAttributeString("PropTagRight", RuleWriter.EnumToString(comparePropertyRestriction.TagRight));
break;
}
case Restriction.ResType.BitMask:
{
Restriction.BitMaskRestriction bitMaskRestriction = (Restriction.BitMaskRestriction)restriction;
this.writer.WriteAttributeString("PropTag", RuleWriter.EnumToString(bitMaskRestriction.Tag));
this.writer.WriteAttributeString("Operation", bitMaskRestriction.Bmr.ToString());
this.writer.WriteAttributeString("Mask", bitMaskRestriction.Mask.ToString("X08"));
break;
}
case Restriction.ResType.Size:
{
Restriction.SizeRestriction sizeRestriction = (Restriction.SizeRestriction)restriction;
this.writer.WriteAttributeString("Operation", sizeRestriction.Op.ToString());
this.writer.WriteAttributeString("PropTag", RuleWriter.EnumToString(sizeRestriction.Tag));
this.writer.WriteAttributeString("Size", sizeRestriction.Size.ToString("X08"));
break;
}
case Restriction.ResType.Exist:
{
Restriction.ExistRestriction existRestriction = (Restriction.ExistRestriction)restriction;
this.writer.WriteAttributeString("PropTag", RuleWriter.EnumToString(existRestriction.Tag));
break;
}
case Restriction.ResType.SubRestriction:
{
Restriction.SubRestriction subRestriction = (Restriction.SubRestriction)restriction;
this.writer.WriteAttributeString("SubType", subRestriction.GetType().Name);
this.WriteRestriction(subRestriction.Restriction);
break;
}
case Restriction.ResType.Comment:
{
Restriction.CommentRestriction commentRestriction = (Restriction.CommentRestriction)restriction;
this.WritePropValues("Comment", commentRestriction.Values);
this.WriteRestriction(commentRestriction.Restriction);
break;
}
case Restriction.ResType.Count:
{
Restriction.CountRestriction countRestriction = (Restriction.CountRestriction)restriction;
this.writer.WriteAttributeString("Count", countRestriction.Count.ToString());
this.WriteRestriction(countRestriction.Restriction);
break;
}
default:
switch (resType)
{
}
this.writer.WriteAttributeString("Error", "Unsupported restriction type: " + type.ToString());
break;
}
}
this.writer.WriteEndElement();
}