public virtual void Subscribe(INotifyAction action, string objectID, IRecipient recipient)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            subscriptionProvider.Subscribe(action, objectID, recipient);
        }

        public string[] GetSubscriptions(INotifyAction action, IRecipient recipient, bool checkSubscribe = true)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            return subscriptionManager.GetSubscriptions(sourceID, action.ID, recipient.ID, checkSubscribe);
        }

 public SendResponse(INotifyAction action, IRecipient recipient, Exception exc)
 {
     Result = SendResult.Impossible;
     Exception = exc;
     Recipient = recipient;
     NotifyAction = action;
 }

        public string[] GetSubscriptionMethod(INotifyAction action, IRecipient recipient)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            return subscriptionManager.GetSubscriptionMethod(sourceID, action.ID, recipient.ID);
        }

        public virtual bool IsUnsubscribe(IDirectRecipient recipient, INotifyAction action, string objectID)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            return subscriptionProvider.IsUnsubscribe(recipient, action, objectID);
        }

 public NoticeMessage(IDirectRecipient recipient, INotifyAction action, string objectID)
 {
     if (recipient == null) throw new ArgumentNullException("recipient");
     Recipient = recipient;
     Action = action;
     ObjectID = objectID;
 }

 public bool IsUnsubscribe(IDirectRecipient recipient, INotifyAction action, string objectID)
 {
     if (recipient == null) throw new ArgumentNullException("recipient");
     if (action == null) throw new ArgumentNullException("action");
     
     return subscriptionManager.IsUnsubscribe(sourceID, recipient.ID, action.ID, objectID);
 }        

        public void Subscribe(INotifyAction action, string objectID, IRecipient recipient)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            subscriptionManager.Subscribe(sourceID, action.ID, objectID, recipient.ID);
        }

 public ProjectEntityEngine(INotifyAction notifyAction, EngineFactory factory)
 {
     SubscriptionProvider = NotifySource.Instance.GetSubscriptionProvider();
     RecipientProvider = NotifySource.Instance.GetRecipientsProvider();
     NotifyAction = notifyAction;
     FileEngine = factory != null ? factory.GetFileEngine() : null;
     Factory = factory;
 }

        private IPattern ChoosePattern(INotifyAction action, string senderName, Notify.Engine.NotifyRequest request)
        {
            if (action == NotifyConstants.Event_ShareDocument
                || action == NotifyConstants.Event_UpdateDocument)
                return ActionPatternProvider.GetPattern(action, senderName);

            return null;
        }

 public static bool IsSubscribed(this ISubscriptionProvider provider, INotifyAction action, IRecipient recipient,
                                 string objectID)
 {
     return Array.Exists(
         provider.GetSubscriptions(action, recipient),
         id => id == objectID || (string.IsNullOrEmpty(id) && string.IsNullOrEmpty(objectID))
         );
 }

 private IPattern ChoosePattern(INotifyAction action, string senderName, Notify.Engine.NotifyRequest request)
 {
     if (action == NotifyConstants.Event_NewCommentForMessage)
     {
         var tag = request.Arguments.Find(tv => tv.Tag.Name == "EventType");
         if (tag != null) return ActionPatternProvider.GetPattern(new NotifyAction(Convert.ToString(tag.Value), ""), senderName);
     }
     return null;
 }

        private IPattern SelectPattern(INotifyAction action, string sender, NotifyRequest request)
        {
            if (action != Constants.ActionAdminNotify) return null; //after that pattern will be selected by xml

            var tagvalue = request.Arguments.Find(tag => tag.Tag.Name == "UNDERLYING_ACTION");
            if (tagvalue == null) return null;

            return ActionPatternProvider.GetPattern(new NotifyAction(Convert.ToString(tagvalue.Value), ""), sender);
        }

        public IRecipient[] GetRecipients(INotifyAction action, string objectID)
        {
            if (action == null) throw new ArgumentNullException("action");

            return subscriptionManager.GetRecipients(sourceID, action.ID, objectID)
                .Select(r => recipientProvider.GetRecipient(r))
                .Where(r => r != null)
                .ToArray();
        }

 public virtual IRecipient[] GetRecipients(INotifyAction action, string objectID)
 {
     if (action == null) throw new ArgumentNullException("action");
     var recipents = new List<IRecipient>(5);
     IRecipient[] directRecipients = _directSubscriptionProvider.GetRecipients(action, objectID) ??
                                     new IRecipient[0];
     recipents.AddRange(directRecipients);
     return recipents.ToArray();
 }

 private IPattern ChoosePattern(INotifyAction action, string senderName, ASC.Notify.Engine.NotifyRequest request)
 {
     if (action == PhotoConst.NewEventComment)
     {
         if (request.Arguments.Exists((tv) => tv.Tag.Name == "FEED_TYPE"))
         {
             return ActionPatternProvider.GetPattern(PhotoConst.NewPhotoUploaded, senderName) ?? ActionPatternProvider.GetPattern(PhotoConst.NewPhotoUploaded);
         }
     }
     return null;
 }

 private IPattern ChoosePattern(INotifyAction action, string senderName, ASC.Notify.Engine.NotifyRequest request)
 {
     if (action == Constants.EditPage)
     {
         var tag = request.Arguments.Find(t => t.Tag == "ChangeType");
         if (tag != null && tag.Value.ToString() == "new wiki page comment")
         {
             return PatternProvider.GetPattern(new NotifyAction(tag.Value.ToString()), senderName);
         }
     }
     return null;
 }

 public static void SendNoticeAsync(string AuthorID, INotifyAction action, string objectID, SendNoticeCallback sendCallback, params ITagValue[] args)
 {
     InitiatorInterceptor initatorInterceptor = new InitiatorInterceptor(new DirectRecipient(AuthorID, ""));
     try
     {
         NotifyClient.AddInterceptor(initatorInterceptor);
         NotifyClient.SendNoticeAsync(action, objectID, sendCallback, args);
     }
     finally
     {
         NotifyClient.RemoveInterceptor(initatorInterceptor.Name);
     }
 }

 private IPattern ChoosePattern(INotifyAction action, string senderName, ASC.Notify.Engine.NotifyRequest request)
 {
     if (action == Constants.EditPage)
     {
         var tag = request.Arguments.Find((tv) => tv.Tag.Name == "ChangeType");
         if (tag != null && tag.Value.ToString() == "new wiki page comment")
         {
             if (senderName == "email.sender") return PatternProvider.GetPattern("3");
             if (senderName == "messanger.sender") return PatternProvider.GetPattern("3_jabber");
         }
     }
     return null;
 }

        public virtual string[] GetSubscriptionMethod(INotifyAction action, IRecipient recipient)
        {
            if (action == null) throw new ArgumentNullException("action");
            if (recipient == null) throw new ArgumentNullException("recipient");

            var senders = subscriptionProvider.GetSubscriptionMethod(action, recipient);
            if (senders == null || senders.Length == 0)
            {
                var parents = WalkUp(recipient);
                foreach (var parent in parents)
                {
                    senders = subscriptionProvider.GetSubscriptionMethod(action, parent);
                    if (senders != null && senders.Length != 0) break;
                }
            }

            return senders != null && 0 < senders.Length ? senders : defaultSenderMethods;
        }