public bool Match(IPublication publication, ISubscription subscription, EventArgs e)
        {
            var publisher = publication.Publisher as IVhptIdentificationProvider;
            var subscriber = subscription.Subscriber as IVhptIdentificationProvider;

            return publisher != null && subscriber != null && publisher.Identification.Equals(subscriber.Identification);
        }

        public void AddSubscription(ISubscription subscription)
        {
            if (subscription == null)
            {
                throw new ArgumentNullException("subscription");
            }

            try
            {
                SubscriptionLock.EnterWriteLock();

                MarkUsed();

                Subscriptions.Add(subscription);
                
                // Created -> HasSubscriptions
                Interlocked.CompareExchange(ref State,
                                            TopicState.HasSubscriptions,
                                            TopicState.NoSubscriptions);
            }
            finally
            {
                SubscriptionLock.ExitWriteLock();
            }
        }

		public virtual IRequestResult Accept(ISubscription subscription, IMessage message) {
			var bundle = new ProcessableUnit { Subscription = subscription, Message = message };
            Accepting(bundle);
            //RealizeIdentifier(subscription);
            BundlePrototype.IsNull(() => BundlePrototype = subscription);
			return Result();
		}

 public LatestProfile( IListenedShow latestShow, IShow show, UserProfile profile, ISubscription subscription )
 {
     LatestListenedShow = latestShow;
     LatestShow = show;
     Profile = profile;
     Subscription = subscription;
 }

 public void SaveCommit( ISubscription subscription, out bool success )
 {
     using ( IUnitOfWork u = UnitOfWork.Begin() ) {
         Save( subscription, out success );
         if ( success )
             u.Commit();
     }
 }

        public void CreateSubscription()
        {
            var phoneNumber = "44556677";
            var subscriptionRegistration = ObjectFactory.GetInstance<ISubscriptionRegistration>();
            var customerRegistration = ObjectFactory.GetInstance<ICustomerRegistration>();

            subscription = SubscriptionHelper.CreateSubscriptionWithDefaultCustomer(subscriptionRegistration,customerRegistration, phoneNumber, "DK", CustomerStatus.Normal);
        }

        public void MakeProxy(string EndpoindAddress, object callbackinstance)
        {
            NetTcpBinding netTcpbinding = new NetTcpBinding(SecurityMode.None);
            EndpointAddress endpointAddress = new EndpointAddress(EndpoindAddress);
            InstanceContext context = new InstanceContext(callbackinstance);        

            DuplexChannelFactory<ISubscription> channelFactory = new DuplexChannelFactory<ISubscription>(new InstanceContext(this), netTcpbinding, endpointAddress);
            _proxy  = channelFactory.CreateChannel();
        }

 public static PlanSubscription MapSubscriptionToPlanSubscription(ISubscription subscription, Func<string, Plan> lookupPlanById)
 {
     return new PlanSubscription
                {
                    Id = subscription.SubscriptionID,
                    Plan = lookupPlanById(subscription.Product.Handle),
                    Subscriber = MapCustomerToSubscriber(subscription.Customer) // in actual system probably look up db
                };
 }

        public void Delete( ISubscription subscription )
        {
            Checks.Argument.IsNotNull( subscription, "subscription" );

            using ( IUnitOfWork u = UnitOfWork.Begin() ) {
                _repo.Remove( subscription );
                u.Commit();
            }
        }

 public bool Add(ISubscription subscription)
 {
     var wasAdded = false;
     foreach (var resolver in resolvers)
     {
         wasAdded = resolver.Add(subscription);
         if (wasAdded) break;
     }
     return wasAdded;
 }

        /// <summary>
        /// Returns whether the publication and subscription match and the event published by the
        /// publisher will be relayed to the subscriber.
        /// <para>
        /// This is the case if the name of the subscriber is a prefix to the name of the publisher.
        /// </para>
        /// </summary>
        /// <param name="publication">The publication.</param>
        /// <param name="subscription">The subscription.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        /// <returns><code>true</code> if event has to be sent to the subscriber.</returns>
        public bool Match(IPublication publication, ISubscription subscription, EventArgs e)
        {
            object publisher = publication.Publisher;
            object subscriber = subscription.Subscriber;

            string publisherName = publisher is INamedItem ? ((INamedItem)publisher).EventBrokerItemName : string.Empty;
            string subscriberName = subscriber is INamedItem ? ((INamedItem)subscriber).EventBrokerItemName : string.Empty;

            return publisherName.StartsWith(subscriberName);
        }

        public async Task SaveSubscription(ISubscription subscription)
        {
            Debug.Assert(_count != DEFAULT_COUNT_VALUE, "Count field is not inited, LoadSubscriptions() wasn't called before SaveSubscription()");

            var serializable = new SubscriptionDto {Uri = subscription.Uri};
            var key = string.Format(CACHE_KEY_FMT, _count);
            this.Log().Info("Inserting subscription to {0} into cache", serializable.Uri);
            await Cache.Local.InsertObject(key, serializable.Uri.OriginalString);
            _count++;
        }

 public SubscriptionDetails(ISubscription s )
 {
     Id = s.Id;
     Label = s.Label;
     Created = s.Created;
     IsActive = s.IsActive;
     CurrentStoreCount = s.StoreCount;
     StoreLimit = s.StoreCountLimit;
     StoreSizeLimit = s.StoreSizeLimit;
     TotalSizeLimit = s.TotalSizeLimit;
     IsTrial = s.IsTrial;
     Stores = s.Stores.Select(store => new StoreDetail(store)).ToList();
 }

        /// <summary>
        /// Returns whether the publication and subscription match and the event published by the
        /// publisher will be relayed to the subscriber.
        /// <para>
        /// This is the case if the name of the subscriber is a prefix to the name of the publisher.
        /// </para>
        /// </summary>
        /// <param name="publication">The publication.</param>
        /// <param name="subscription">The subscription.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        /// <returns><code>true</code> if event has to be sent to the subscriber.</returns>
        public bool Match(IPublication publication, ISubscription subscription, EventArgs e)
        {
            Ensure.ArgumentNotNull(publication, "publication");
            Ensure.ArgumentNotNull(subscription, "subscription");

            object publisher = publication.Publisher;
            object subscriber = subscription.Subscriber;

            string publisherName = publisher is INamedItem ? ((INamedItem)publisher).EventBrokerItemName : string.Empty;
            string subscriberName = subscriber is INamedItem ? ((INamedItem)subscriber).EventBrokerItemName : string.Empty;

            return publisherName.StartsWith(subscriberName, StringComparison.Ordinal);
        }

        public EventActivityHub(
            ISubscription<EventActivitySubscriptionInfo> subscription,
            Func<Task<IEnumerable<string>>> getEventNames,
            Func<string, Task<IEnumerable<ActivityTimeframe>>> getTimeframes)
            : base(getEventNames, getTimeframes)
        {
            if (subscription == null)
            {
                throw new ArgumentNullException("subscription");
            }

            this.subscription = subscription;
        }

 public WhiteListForecastWorker(
     ISubscription[] subscriptions,
     IDeployment deployment,
     IOperation operation,
     WhiteListService[] allowedServices,
     int pollingIntervalInMinutes)
     : base(GetWorkerId(typeof(WhiteListForecastWorker).FullName))
 {
     this.subscriptions = subscriptions;
     this.deployment = deployment;
     this.operation = operation;
     this.allowedServices = allowedServices;
     this.pollingIntervalInMinutes = pollingIntervalInMinutes;
 }

        public void Save( ISubscription subscription, out bool success )
        {
            Checks.Argument.IsNotNull( subscription, "subscription" );

            success = false;

            if ( null == _repo.FindById( subscription.Id ) ) {
                try {
                    _repo.Add( subscription );
                    success = true;
                }
                catch ( Exception ex ) {
                    success = false;
                }
            }
        }

        public void RemoveSubscription(ISubscription subscription)
        {
            try
            {
                SubscriptionLock.EnterWriteLock();

                if (_subcriptionIdentities.Remove(subscription.Identity))
                {
                    Subscriptions.Remove(subscription);
                }
            }
            finally
            {
                SubscriptionLock.ExitWriteLock();
            }
        }

        private void ScheduleWork(ISubscription subscription)
        {
            var workContext = new WorkContext(subscription, this);

            ThreadPool.QueueUserWorkItem(state =>
            {
                var context = (WorkContext)state;

                context.Broker._counters.MessageBusAllocatedWorkers.Increment();

                DoWork(context);

                context.Broker._counters.MessageBusAllocatedWorkers.Decrement();
            },
            workContext);
        }

 public static PlanSubscription MapSubscription(ISubscription chargifySubscription)
 {
     return new PlanSubscription
                {
                    ChargifySubscriptionID = chargifySubscription.SubscriptionID,
                    Plan = MapProductToPlan(chargifySubscription.Product),
                    Account = MapCustomerToAccount(chargifySubscription.Customer),
                    ActivatedAt = chargifySubscription.ActivatedAt.ToUniversalTime(),
                    NextAssessmentAt = chargifySubscription.NextAssessmentAt.ToUniversalTime(),
                    CurrentPeriodStartedAt = chargifySubscription.CurrentPeriodStartedAt.ToUniversalTime(),
                    CurrentPeriodEndsAt = chargifySubscription.CurrentPeriodEndsAt.ToUniversalTime(),
                    ExpiresAt = chargifySubscription.ExpiresAt.ToUniversalTime(),
                    TrialStartedAt = chargifySubscription.TrialStartedAt.ToUniversalTime(),
                    TrialEndedAt = chargifySubscription.TrialEndedAt.ToUniversalTime(),
                    State = MapChargifySubscriptionState(chargifySubscription.State.ToString())
                };
 }