def add_invited(user):
    print "ADD INVITED SUBSCRIPTIONS"
    ## Add to subscription list

    # get newsletter
    try:
        newsl = Newsletter.objects.get(slug='emif-catalogue-newsletter')

        # create subscription
        user_sub = Subscription(user=user,  newsletter=newsl)

        user_sub.subscribe()

        user_sub.save()

    except Newsletter.DoesNotExist:
        print "Problem registering new user to emif default newsletter"

    # add invited dbs if any
    sps = InvitePending.objects.filter(email=user.email)

    for sp in sps:

        fingerprint = sp.fingerprint

        fingerprint.save()

        fingerprint.shared.add(user)

        sp.delete()

        # must reindex, because databases lists come from solr, to update user_t
        fingerprint.indexFingerprint()

    def test_update_request_activate(self):
        """ Update a request. """

        subscription = Subscription(newsletter=self.n,
                                    name='Test Name',
                                    email='[email protected]')
        subscription.save()

        activate_url = subscription.update_activate_url()

        response = self.client.get(activate_url)
        self.assertInContext(response, 'form', UpdateForm)
        self.assertContains(response, subscription.activation_code)

        testname2 = 'Test Name2'
        testemail2 = '[email protected]'
        response = self.client.post(activate_url, {
            'name_field': testname2,
            'email_field': testemail2,
            'user_activation_code': subscription.activation_code
        })

        # Assure we are redirected to "update activated" page.
        self.assertRedirects(response, self.update_activated_url)

        subscription = self.get_only_subscription(
            email_field__exact=testemail2
        )

        self.assertTrue(subscription)
        self.assertTrue(subscription.subscribed)
        self.assertEqual(subscription.name, testname2)
        self.assertEqual(subscription.email, testemail2)

    def import_auth_users(self, *args, **options):
        auth_list, created = List.objects.get_or_create(name="8pm_leak")
        file = open("newsletter/management/commands/runners.txt", "r")

        EMAIL_REGEX = re.compile(r"[^@][email protected][^@]+\.[^@]+")

        runners = []
        for email in file:
            if not EMAIL_REGEX.match(email):
                print "Error matching regex"
            else:
                runners.append(email.replace(',','').rstrip())

        users = []
        for u in User.objects.all():
            users.append(u.email)

        diff = [x for x in runners if x not in users]

        for u in diff:
            try:
                s = Subscription.objects.get(email_field=u)
                print "skipping, user alread loaded from auth: ",s
            except Subscription.DoesNotExist:
                print "adding new user from list intersection: ",u
                subscriber = Subscription(email_field=u,list=auth_list,subscribed=True)
                subscriber.save()

        print "Runners.txt len: ", len(runners)
        print "Current DB users len: ",len(users)
        print "Diff len: ",len(diff)

    def test_unsubscribe_view(self):
        """ Test the unsubscription form. """
        subscription = Subscription(user=self.user, newsletter=self.n)
        subscription.subscribed = True
        subscription.unsubscribed = False
        subscription.save()

        self.assertLessThan(
            subscription.subscribe_date, timezone.now() + timedelta(seconds=1)
        )

        response = self.client.get(self.unsubscribe_url)

        self.assertContains(response, self.n.title, status_code=200)

        self.assertEqual(response.context['newsletter'], self.n)
        self.assertEqual(response.context['user'], self.user)

        self.assertContains(
            response, 'action="%s"' % self.unsubscribe_confirm_url)
        self.assertContains(response, 'id="id_submit"')

        subscription = self.get_user_subscription()
        self.assertTrue(subscription.subscribed)
        self.assertFalse(subscription.unsubscribed)

    def test_subscribe_request_activate_form_loophole(self):
        """
        Prevent updating to unconfirmed email address. (#108)
        """

        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail)
        subscription.save()

        activate_url = subscription.subscribe_activate_url()

        response = self.client.get(activate_url)
        self.assertInContext(response, 'form', UpdateForm)
        self.assertContains(response, subscription.activation_code)

        testname2 = 'Test Name2'
        testemail2 = '[email protected]'
        response = self.client.post(activate_url, {
            'name_field': testname2,
            'email_field': testemail2,
            'user_activation_code': subscription.activation_code
        })

        # Assure we are redirected to "update activated" page.
        self.assertRedirects(response, self.subscribe_activated_url)

        subscription = Subscription.objects.get(pk=subscription.pk)

        self.assertTrue(subscription)
        self.assertTrue(subscription.subscribed)
        self.assertEqual(subscription.email, self.testemail)

    def test_unsubscribe_request_post_no_email(self):
        """
        Post the unsubscribe request form
        with confirmation email switched off in settings.
        """

        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail,
                                    subscribed=True)
        subscription.save()

        response = self.client.post(
            self.unsubscribe_url, {'email_field': self.testemail}
        )

        # Assure we are redirected to "unsubscribe activated" page.
        self.assertRedirects(response, self.unsubscribe_activated_url)

        changed_subscription = self.get_only_subscription(
            email_field__exact=self.testemail
        )

        # email confirmation is switched off,
        # so after unsubscribe request user should be unsubscribed
        self.assertFalse(changed_subscription.subscribed)
        self.assertTrue(changed_subscription.unsubscribed)

        """ Check the subscription email. """
        # no email should be send
        self.assertEqual(len(mail.outbox), 0)

def subscribe_request(request):
    """ Adds a new subscription to mailchimp list. """
    if request.POST:
        mail_chimp = mailchimp.Mailchimp(
            settings.SECRETS['mailchimp_api_key']
        )
        form = NewsletterForm(request.POST)
        if form.is_valid():
            email = form.cleaned_data['email']
            subscription = Subscription(email=email)
            subscription.save()
            try:
                mail_chimp.lists.subscribe(
                    settings.SECRETS['mailchimp_list_id'],
                    {'email': email},
                    double_optin=False,
                    send_welcome=True
                )
            except mailchimp.ListAlreadySubscribedError:
                return {
                    'success': False, 'error': 'Email is already subscribed'
                }
            return {'success': True}
        else:
            return {
                'success': False,
                'error': form.errors.get('email')
            }
    return {'success': False, 'error': 'Request not valid'}

    def test_unsubscribe_request_post_error(self):
        """
        Test whether a failing unsubscribe request email generated an error in
        the context.

        We do this by overriding the default mail backend to a settings which
        we know pretty sure is bound to fail.
        """
        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail,
                                    subscribed=True)
        subscription.save()

        with override_settings(
            EMAIL_BACKEND='tests.utils.FailingEmailBackend'
        ):
            with patch_logger('newsletter.views', 'error') as messages:
                response = self.client.post(
                    self.unsubscribe_url, {'email_field': self.testemail}
                )
            self.assertEqual(len(messages), 1)
            self.assertIn("Connection refused", messages[0])

        self.assertTrue(response.context['error'])

def importUsers():

    try:
        newsl = Newsletter.objects.get(slug='emif-catalogue-newsletter')


        users = User.objects.all()

        for user in users:
            try:
                subscription = Subscription.objects.get(user=user,  newsletter=newsl)

            except Subscription.DoesNotExist:
                # create subscription if doesnt exist yet
                user_sub = Subscription(user=user,  newsletter=newsl)

                user_sub.subscribe()

                user_sub.save()

                print "-- Created subscription for emif newsletter to user "+str(user.username)

                pass

    except Newsletter.DoesNotExist:
        print "Problem finding default newsletter for emif"

    def test_unsubscribe_request_activate(self):
        """ Update a request. """

        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail)
        subscription.save()

        activate_url = subscription.unsubscribe_activate_url()

        response = self.client.get(activate_url)
        self.assertInContext(response, 'form', UpdateForm)
        self.assertContains(response, subscription.activation_code)

        testname2 = 'Test Name2'
        response = self.client.post(activate_url, {
            'name_field': testname2,
            'user_activation_code': subscription.activation_code
        })

        # Assure we are redirected to "unsubscribe activated" page.
        self.assertRedirects(response, self.unsubscribe_activated_url)

        subscription = self.get_only_subscription(
            email_field__exact=self.testemail
        )

        self.assertTrue(subscription.unsubscribed)
        self.assertEqual(subscription.name, testname2)
        self.assertEqual(subscription.email, self.testemail)

        dt = (timezone.now() - subscription.unsubscribe_date).seconds
        self.assertLessThan(dt, 2)

 def import_auth_users(self, *args, **options):
     auth_list, created = List.objects.get_or_create(name="django_auth")
     users = User.objects.all()
     for u in users:
         try:
             s = Subscription.objects.get(user=u,list=auth_list)
             print "skipping, user alread loaded from auth: ",s
         except Subscription.DoesNotExist:
             print "adding new user from auth: ",u
             subscriber = Subscription(user=u,list=auth_list,subscribed=True)
             subscriber.save()

def subscribe(request):
  if request.method == 'POST':
    from django.forms.fields import email_re
    if email_re.match(request.POST['email']):
      sub = Subscription(email=request.POST['email'])
      sub.save()
      create_message(request, "Dodano do newslettera")
      return conditional_redirect(request, '/')
    else:
      create_message(request, "Błędny adres e-mail")
      return conditional_redirect(request, '/')
  else:
      return conditional_redirect(request, '/')

    def test_twosubmissions_unsubscried(self):
        """ Test submission with two subscribers, one unactivated. """

        s2 = Subscription(
            name='Test Name 2', email='[email protected]',
            newsletter=self.n, subscribed=False
        )
        s2.save()

        sub = Submission.from_message(self.m)

        subscriptions = sub.subscriptions.all()
        self.assertEqual(list(subscriptions), [self.s])

def subscribe(request):
    if 'subscription' in request.POST:
        subscription = Subscription(email = request.POST['subscription'])
        subscriptions = Subscription.objects.filter(email = request.POST['subscription'])

        try:
            subscription.full_clean()
            subscription.save()
            return HttpResponse('Uspješno ste se pretplatili!')
        except ValidationError, e:
            if (subscriptions.count() != 0):
              return HttpResponse('E-mail adresa je vec pretplacena!')
            else:
              return HttpResponse('Došlo je do pogreške!')

    def test_twosubmissions(self):
        """ Test submission with two activated subscribers. """

        s2 = Subscription(
            name='Test Name 2', email='[email protected]',
            newsletter=self.n, subscribed=True
        )
        s2.save()

        sub = Submission.from_message(self.m)

        subscriptions = sub.subscriptions.all()
        self.assertTrue(self.s in list(subscriptions))
        self.assertTrue(s2 in list(subscriptions))

    def test_subscribe_twice(self):
        # After subscribing we should not be able to subscribe again
        subscription = Subscription(user=self.user, newsletter=self.n)
        subscription.subscribed = True
        subscription.unsubscribed = False
        subscription.save()

        response = self.client.get(self.subscribe_url)

        self.assertContains(response, self.n.title, status_code=200)

        self.assertEqual(response.context['newsletter'], self.n)
        self.assertEqual(response.context['user'], self.user)

        self.assertNotContains(
            response, 'action="%s"' % self.subscribe_confirm_url)
        self.assertNotContains(response, 'id="id_submit"')

    def test_unsubscribe_update_unactivated(self):
        """ Test updating unsubscribed subscriptions view. """

        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail,
                                    subscribed=False)
        subscription.save()

        for url in (self.update_url, self.unsubscribe_url):
            response = self.client.post(
                url, {'email_field': self.testemail}
            )

            self.assertContains(
                response, "This subscription has not yet been activated."
            )

class MailingTestCase(MailTestCase):

    def get_newsletter_kwargs(self):
        """ Returns the keyword arguments for instanciating the newsletter. """

        return {
            'title': 'Test newsletter',
            'slug': 'test-newsletter',
            'sender': 'Test Sender',
            'email': '[email protected]'
        }

    def setUp(self):
        self.n = Newsletter(**self.get_newsletter_kwargs())
        self.n.save()
        self.n.site = get_default_sites()

        self.m = Message(title='Test message',
                         newsletter=self.n,
                         slug='test-message')
        self.m.save()

        self.s = Subscription(
            name='Test Name', email='[email protected]',
            newsletter=self.n, subscribed=True
        )
        self.s.save()

    def send_email(self, action):
        assert action in ACTIONS + ('message', ), 'Unknown action: %s' % action

        if action == 'message':
            # Create submission
            sub = Submission.from_message(self.m)
            sub.prepared = True
            sub.publish_date = now() - timedelta(seconds=1)
            sub.save()

            # Send message email
            Submission.submit_queue()
        else:
            self.s.send_activation_email(action)

 def form_valid(self, form):
     newsletter = self.get_services_newsletter()
     email = form.cleaned_data['email']
     try:
         subscription = Subscription.objects.get(email_field=email, newsletter=newsletter)
     except Subscription.DoesNotExist:
         subscription = Subscription()
         subscription.email = form.cleaned_data['email']
         subscription.name = form.cleaned_data['name']
         subscription.newsletter = self.get_services_newsletter()
         subscription.save()
         subscription.send_activation_email(action='subscribe')
         messages.success(self.request, u'Вы подписались на уведомления о новых акциях стоматологического центра "Рябина"!')
     else:
         if subscription.subscribed:
             messages.success(self.request, u'Вы уже подписаны на уведомления о новых акциях стоматологического центра "Рябина"!')
         else:
             subscription.send_activation_email(action='subscribe')
             messages.success(self.request, u'Мы выслали вам письмо активации на уведомления о новых акциях стоматологического центра "Рябина"!')
     return HttpResponseRedirect(self.get_success_url())

    def test_update_request_activate_form(self):
        """
        Test requesting a form for activating an update without activation
        code in the URL.
        """

        subscription = Subscription(newsletter=self.n,
                                    name=self.testname,
                                    email=self.testemail)
        subscription.save()

        activate_url = reverse('newsletter_update', kwargs={
            'newsletter_slug': self.n.slug,
            'action': 'update',
            'email': subscription.email
        })

        response = self.client.get(activate_url)

        # Make sure the form is there
        self.assertInContext(response, 'form', UpdateForm)