public WLMMailRulesReader()
        {
            using (var mailKey = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Windows Live Mail\Rules\Mail", false))
            {
                if (mailKey != null)
                {
                    var OrderValue = "" + mailKey.GetValue("Order");
                    foreach (var order in spaceSplitter.Split(OrderValue))
                    {
                        using (var orderKey = mailKey.OpenSubKey(order, false))
                        {
                            if (orderKey != null)
                            {
                                var Name    = "" + orderKey.GetValue("Name");
                                var Enabled = ("" + orderKey.GetValue("Enabled")) == "1";

                                var rule = new WLMMailRule
                                {
                                    Name    = Name,
                                    Enabled = Enabled,
                                };
                                Rules.Add(rule);

                                using (var criteriaKey = orderKey.OpenSubKey("Criteria", false))
                                {
                                    if (criteriaKey != null)
                                    {
                                        var criteriaOrderValue = "" + criteriaKey.GetValue("Order");
                                        foreach (var criteriaOrder in spaceSplitter.Split(criteriaOrderValue))
                                        {
                                            using (var criteriaOrderKey = criteriaKey.OpenSubKey(criteriaOrder, false))
                                            {
                                                if (criteriaOrderKey != null)
                                                {
                                                    var Logic = criteriaOrderKey.GetIntValue("Logic") ?? 0;
                                                    var Type  = criteriaOrderKey.GetIntValue("Type") ?? 0;

                                                    var criteria = new WLMCriteria
                                                    {
                                                        ThisAndNext = 0 != (2 & Logic),
                                                        Type        = (CriteriaType)Type,
                                                    };
                                                    rule.CriteriaList.Add(criteria);

                                                    var Flags       = criteriaOrderKey.GetIntValue("Flags") ?? 0;
                                                    var ValueType   = criteriaOrderKey.GetIntValue("ValueType") ?? 0;
                                                    var StringValue = criteriaOrderKey.GetByteaUnicodeStringValue("Value") ?? criteriaOrderKey.GetStringValue("Value") ?? "";
                                                    var IntValue    = criteriaOrderKey.GetIntValue("Value") ?? 0;

                                                    switch (ValueType)
                                                    {
                                                    case 19:
                                                    {
                                                        criteria.Verifier = new IntVerifier
                                                        {
                                                            Value = IntValue,
                                                        };
                                                        break;
                                                    }

                                                    case 31:
                                                    {
                                                        criteria.Verifier = new StringTargetVerifier
                                                        {
                                                            Target = StringValue,
                                                        };
                                                        break;
                                                    }

                                                    case 65:
                                                    {
                                                        criteria.Verifier = new StringVerifier
                                                        {
                                                            AndValues  = 0 != (2 & Flags),
                                                            NotContain = 0 != (1 & Flags),
                                                            Keywords   = StringValue.Split(new char[] { '\0' }, StringSplitOptions.RemoveEmptyEntries),
                                                        };
                                                        break;
                                                    }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }

                                using (var actionsKey = orderKey.OpenSubKey("Actions", false))
                                {
                                    if (actionsKey != null)
                                    {
                                        var actionsOrderValue = "" + actionsKey.GetValue("Order");
                                        foreach (var actionsOrder in spaceSplitter.Split(actionsOrderValue))
                                        {
                                            using (var actionsOrderKey = actionsKey.OpenSubKey(actionsOrder, false))
                                            {
                                                if (actionsOrderKey != null)
                                                {
                                                    var Type = actionsOrderKey.GetIntValue("Type") ?? 0;

                                                    var action = new WLMAction
                                                    {
                                                        Type = (ActionType)Type,
                                                    };
                                                    rule.ActionsList.Add(action);

                                                    var ValueType   = actionsOrderKey.GetIntValue("ValueType") ?? 0;
                                                    var StringValue = actionsOrderKey.GetByteaUnicodeStringValue("Value") ?? actionsOrderKey.GetStringValue("Value") ?? "";

                                                    switch (ValueType)
                                                    {
                                                    case 31:
                                                    {
                                                        action.Verifier = new StringTargetVerifier
                                                        {
                                                            Target = StringValue,
                                                        };
                                                        break;
                                                    }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #2
0
        private ActionsAndCondSet ToSet(WLMMailRule rule)
        {
            var set = new ActionsAndCondSet();

            if (rule.CriteriaList.Count == 1)
            {
                var criteria = rule.CriteriaList[0];
                switch (criteria.Type)
                {
                case CriteriaType.From:
                    set.condition = BuildTBStringCondition("from", criteria.Verifier as StringVerifier);
                    break;

                case CriteriaType.To:
                    set.condition = BuildTBStringCondition("to", criteria.Verifier as StringVerifier);
                    set.type      = TBFilterType.Manual | TBFilterType.Sent;
                    break;

                case CriteriaType.Cc:
                    set.condition = BuildTBStringCondition("cc", criteria.Verifier as StringVerifier);
                    break;

                case CriteriaType.Body:
                    set.condition = BuildTBStringCondition("body", criteria.Verifier as StringVerifier);
                    break;

                case CriteriaType.Subject:
                    set.condition = BuildTBStringCondition("subject", criteria.Verifier as StringVerifier);
                    break;

                case CriteriaType.ToOrCc:
                    set.condition = BuildTBStringCondition("to or cc", criteria.Verifier as StringVerifier);
                    set.type      = TBFilterType.Manual | TBFilterType.Sent;
                    break;

                case CriteriaType.HasAttachment:
                    set.condition = "AND (has attachment status,is,true)";
                    break;
                }
            }
            foreach (var action in rule.ActionsList)
            {
                switch (action.Type)
                {
                case ActionType.Delete:
                    set.actionSets.Add(new ActionSet
                    {
                        action = "Delete",
                    });
                    break;

                case ActionType.Forward:
                    foreach (var mail in (action.Verifier as StringTargetVerifier).Target.Split(','))
                    {
                        set.actionSets.Add(
                            new ActionSet
                        {
                            action      = "Forward",
                            actionValue = mail
                        }
                            );
                    }
                    break;
                }
            }
            if (!set.actionSets.Any())
            {
                set.actionSets.Add(ActionSet.AddBusinessTag);
            }
            return(set);
        }