示例#1
0
        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);
        }
示例#2
0
 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(")");
        }
示例#4
0
        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));
            }
        }
示例#5
0
 internal ComparePropertyRestrictionData(Restriction.ComparePropertyRestriction r)
 {
     this.RelOp    = (int)r.Op;
     this.TagLeft  = (int)r.TagLeft;
     this.TagRight = (int)r.TagRight;
 }
示例#6
0
 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");
 }
示例#7
0
        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();
        }