#Django core bits
from django.shortcuts import render, render_to_response, get_object_or_404
from django.template import RequestContext, loader, Context
from django.contrib.auth.decorators import login_required, permission_required
from django.db.models import Q
from django.conf import settings
from django.http import HttpResponseRedirect, Http404, HttpResponse
from django.core.urlresolvers import reverse
from django.contrib.auth.models import User, Group
from django.core.mail import EmailMessage
from django.contrib import messages
from datetime import datetime,date,time
from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth import logout, views as auth_views

from dateutil.relativedelta import relativedelta
from calendar import *
#Others
import random,csv,string

import pdfcrowd

#Forms
from forms import *

#Models
from models import *
from modules.blocks.models import *
from modules.meeting_booking.models import *
from modules.payments.models import *

from functions import *
from modules.payments.functions import *
from modules.core.functions import *
from modules.core.decorators import *

from signals import *


@members_only
def account_home(request):

    member = get_object_or_404(Member,user=request.user)
    user_activity = UserActivity.objects.filter(member=member).order_by('-created')[:20]

    unread_activity = UserActivity.objects.filter(member=member, read=False)
    unread_count = unread_activity.count()

    return render(request, 'members/home.html', {'user_activity': user_activity, 'unread_activity': unread_activity})


@members_only
def dismiss_activity(request, id):

    member = get_object_or_404(Member, user=request.user)
    user_activity = get_object_or_404(UserActivity, id=id, member=member)

    user_activity.read = True
    user_activity.save()

    return HttpResponse('Ok')


@members_only
def remove_activity(request, id):

    member = get_object_or_404(Member, user=request.user)
    user_activity = get_object_or_404(UserActivity, id=id, member=member)

    try:
        user_activity.delete()
        return HttpResponse('Ok')
    except:
        raise Http404


@members_only
def activity_category(request):

    member = get_object_or_404(Member, user=request.user)

    if request.POST:

        if request.POST.get('category'):

            category = request.POST['category']

            if category == 'all':
                return HttpResponseRedirect(reverse('account_home'))

            if category == 'general':
                category_title = 'General Activity'
            elif category == 'meeting-notification':
                category_title = 'Meeting Notifications'
            elif category == 'voting-notification':
                category_title = 'Election Notifications'
            elif category == 'member-notification':
                category_title = 'Member Notifications'
            elif category == 'account-notification':
                category_title = 'Account Notifications'
            elif category == 'certificate-notification':
                category_title = 'Certificate Notifications'
            else:
                category_title = ''

            activity = UserActivity.objects.filter(type=category, member=member).order_by('-created')

            return render(request, 'members/activity-category.html', {'category_activity': activity, 'current_category': category, 'category_title': category_title})

    return HttpResponseRedirect(reverse('account_home'))


@members_only
def my_account(request):

    member = get_object_or_404(Member, user=request.user)

    form = MemberProfileImageForm()

    today = date.today()
    three_months = today+relativedelta(months=+3)

    member_expiring = False
    member_expired = False

    if member.expiry_date:
        if three_months >= member.expiry_date:
            member_expiring = True
            if today >= member.expiry_date:
                member_expired = True

    return render(request, 'members/account/my-account.html', {'member_expiring': member_expiring, 'member_expired': member_expired, 'form': form})


@members_only
def update_details_member(request):

    member = get_object_or_404(Member,user=request.user,user_type='member')
    avs_status = member.get_avs()

    update_user_form = UpdateUserForm(instance=member.user)
    update_personal_form = RegistrationFormPersonal(instance=member)
    update_hospital_form = RegistrationFormHospital(instance=member)
    update_personal_address_form = RegistrationFormPersonalAddress(instance=member)
    update_training_form = RegistrationFormTraining(instance=member)
    update_professional_form = RegistrationFormProfessional(instance=member)
    update_professional_form.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)
    update_terms_form = RegistrationFormTerms(instance=member)

    if request.POST:

        forms = [update_personal_form, update_hospital_form, update_personal_address_form, update_training_form, update_professional_form, update_terms_form]
        updated_fields = find_updated_fields(request, member, update_user_form, forms)

        update_user_form = UpdateUserForm(request.POST, instance=member.user)
        update_personal_form = RegistrationFormPersonal(request.POST, instance=member)
        update_hospital_form = RegistrationFormHospital(request.POST, instance=member)
        update_personal_address_form = RegistrationFormPersonalAddress(request.POST, instance=member)
        update_training_form = RegistrationFormTraining(request.POST, instance=member)
        update_professional_form = RegistrationFormProfessional(request.POST, instance=member)
        update_professional_form.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)
        update_terms_form = RegistrationFormTerms(request.POST, instance=member)

        if update_user_form.is_valid() and update_personal_form.is_valid() and update_hospital_form.is_valid() and update_personal_address_form.is_valid() and update_training_form.is_valid() and update_professional_form.is_valid() and update_terms_form.is_valid():

            update_user_form.save()
            update_personal_form.save()
            update_hospital_form.save()
            update_personal_address_form.save()
            update_training_form.save()
            update_professional_form.save()
            update_terms_form.save()

            if updated_fields:
                details_updated.send(sender=None, request=request, member=member, updated_fields=updated_fields)

            if member.given_name:
                member.user.first_name = member.given_name
            if member.surname:
                member.user.last_name = member.surname
            member.user.save()

            if avs_status:
                avs_items = ProfessionalChoice.objects.filter(admin_only=True)
                for avs_item in avs_items:
                    member.professional_certification.add(avs_item)
                    member.save()

            messages.success(request,'Your details have been updated')
            return HttpResponseRedirect(reverse('my_account'))

    return render(request, 'members/account/update-details-member.html', {'member': member, 'update_user_form': update_user_form, 'update_personal_form': update_personal_form, 'update_hospital_form': update_hospital_form, 'update_personal_address_form': update_personal_address_form, 'update_training_form': update_training_form, 'update_professional_form': update_professional_form, 'update_terms_form': update_terms_form})


@members_only
def update_details_delegate(request):

    member = get_object_or_404(Member, user=request.user, user_type='non-member')

    update_user_form = UpdateUserForm(instance=member.user)
    update_delegate_form = UpdateDelegateForm(instance=member)

    if request.POST:

        update_user_form = UpdateUserForm(request.POST, instance=member.user)
        update_delegate_form = UpdateDelegateForm(request.POST, instance=member)

        if update_user_form.is_valid() and update_delegate_form.is_valid():

            update_user_form.save()
            update_delegate_form.save()

            messages.success(request, 'Your details have been saved')

            return HttpResponseRedirect(reverse('my_account'))

    return render(request, 'members/account/update-details-delegate.html', {'member': member, 'update_user_form': update_user_form, 'update_delegate_form': update_delegate_form})


@members_only
def change_password(request):

    member = get_object_or_404(Member, user=request.user)
    reset_required = member.temp_password

    error = ''
    form = MemberPasswordForm()
    if request.POST:

        form = MemberPasswordForm(request.POST)
        if form.is_valid():
            # check passwords match
            if form.cleaned_data['password'] == form.cleaned_data['password2']:

                member.user.set_password(form.cleaned_data['password'])
                member.user.save()
                messages.success(request, 'Your Password has been changed')

                member.temp_password = False
                member.save()

                reset_password_notification = UserActivity(member=member, title='Your Password Has Been Changed', text='Please now login with your new password.', type='account-notification')
                reset_password_notification.save()

                if reset_required:
                    messages.warning(request, 'Please check your details below, to ensure we have the correct details')
                    return HttpResponseRedirect(reverse('update_details_member'))
                else:
                    return HttpResponseRedirect(reverse('my_account'))

            else:
                error = 'Passwords do not match'

    return render(request, 'members/account/change-password.html', {'form': form, 'reset_required': reset_required, 'error': error})


@members_only
def emails(request):

    member = get_object_or_404(Member, user=request.user)
    emails = member.get_emails()

    return render(request, 'members/emails/emails.html', {'member': member, 'emails': emails})


@members_only
def view_email(request, email_id):

    member = get_object_or_404(Member, user=request.user)
    email = get_object_or_404(AdminMessage, id=email_id)

    if not member.can_access_email(email):
        messages.error(request, 'Sorry, you cannot access this email')
        return HttpResponseRedirect(reverse('account_emails'))

    return render(request, 'members/emails/view-email.html', {'member': member, 'email': email})


@members_only
def change_image(request):

    user = request.user
    member = get_object_or_404(Member, user=user)

    if request.POST:
        if request.FILES['image']:
            member.profile_picture = request.FILES['image']
            member.save()

            return HttpResponseRedirect(reverse('my_account'))

        else:
            return HttpResponseRedirect(reverse('my_account'))

    else:
        return HttpResponseRedirect(reverse('my_account'))


@members_only
def membership(request):

    member = get_object_or_404(Member, user=request.user)

    try:
        direct_debit = MemberDirectDebit.objects.get(status='current',member=member)
    except MemberDirectDebit.DoesNotExist:
        direct_debit = False

    member_expiring = False
    member_expired = False

    today = date.today()
    three_months = today+relativedelta(months=+3)

    if member.expiry_date:
        if three_months >= member.expiry_date:
            member_expiring = True
        if today > member.expiry_date:
            member_expired = True

    return render(request, 'members/membership/membership.html', {'direct_debit': direct_debit, 'member_expiring': member_expiring, 'member_expired': member_expired})


@members_only
def update_direct_debit(request):

    member = get_object_or_404(Member, user=request.user)

    try:
        direct_debit = MemberDirectDebit.objects.get(status='current',member=member)
    except MemberDirectDebit.DoesNotExist:
        messages.error(request, 'You haven\'t got A Direct Debit setup yet')
        return HttpResponseRedirect(reverse('account_membership'))

    direct_debit_form = DirectDebitForm(instance=direct_debit)

    old_sort_code = direct_debit.sort_code
    old_ac_no = direct_debit.ac_no
    old_ac_name = direct_debit.ac_name

    if request.POST:
        direct_debit_form = DirectDebitForm(request.POST, instance=direct_debit)

        if direct_debit_form.is_valid():

            direct_debit_form.save()

            if direct_debit.sort_code != old_sort_code:
                direct_debit.old_sort_code = old_sort_code
            if direct_debit.sort_code != old_ac_no:
                direct_debit.old_ac_no = old_ac_no
            if direct_debit.sort_code != old_ac_name:
                direct_debit.old_ac_name = old_ac_name
            direct_debit.save()

            direct_debit_updated.send(sender=None, request=request, member=member, direct_debit=direct_debit)

            messages.success(request, 'Your Direct Debit details have been updated')

            return HttpResponseRedirect(reverse('account_membership'))

        else:
            messages.error(request, 'Could not update your Direct Debit details')

    return render(request, 'members/membership/update-direct-debit.html', {'direct_debit': direct_debit, 'direct_debit_form': direct_debit_form})


@lapsed_members_only
def renew_membership(request):

    member = get_object_or_404(Member, user=request.user, user_type='member',approved=True)

    today = date.today()
    one_month = today+relativedelta(months=+1)

    member_expiring = False
    member_expired = False

    if member.expiry_date:
        if one_month >= member.expiry_date:
            member_expiring = True
        if today > member.expiry_date:
            member_expired = True

    try:
        direct_debit = MemberDirectDebit.objects.get(status='current',member=member)
        messages.success(request, 'You have a Direct Debit associated with your membership, it will renew automatically.')
        return HttpResponseRedirect(reverse('account_membership'))
    except MemberDirectDebit.DoesNotExist:
        pass

    try:
        content = ContentBlock.objects.get(slug='member-renewal-intro')
    except ContentBlock.DoesNotExist:
        content = False

    member = get_object_or_404(Member, user=request.user,user_type='member')
    avs_status = member.get_avs()

    update_user_form = UpdateUserForm(instance=member.user)
    update_personal_form = RegistrationFormPersonal(instance=member)
    update_hospital_form = RegistrationFormHospital(instance=member)
    update_personal_address_form = RegistrationFormPersonalAddress(instance=member)
    update_training_form = RegistrationFormTraining(instance=member)
    update_professional_form = RegistrationFormProfessional(instance=member)
    update_professional_form.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)

    if request.POST:

        forms = [update_personal_form,update_hospital_form,update_personal_address_form,update_training_form,update_professional_form]
        updated_fields = find_updated_fields(request,member,update_user_form,forms)

        update_user_form = UpdateUserForm(request.POST,instance=member.user)
        update_personal_form = RegistrationFormPersonal(request.POST,instance=member)
        update_hospital_form = RegistrationFormHospital(request.POST,instance=member)
        update_personal_address_form = RegistrationFormPersonalAddress(request.POST,instance=member)
        update_training_form = RegistrationFormTraining(request.POST,instance=member)
        update_professional_form = RegistrationFormProfessional(request.POST,instance=member)
        update_professional_form.fields['professional_certification'].queryset = ProfessionalChoice.objects.filter(admin_only=False)

        if update_user_form.is_valid() and update_personal_form.is_valid() and update_hospital_form.is_valid() and update_personal_address_form.is_valid() and update_training_form.is_valid() and update_professional_form.is_valid():

            update_user_form.save()
            update_personal_form.save()
            update_hospital_form.save()
            update_personal_address_form.save()
            update_training_form.save()
            update_professional_form.save()

            if updated_fields:
                details_updated.send(sender=None,request=request,member=member,updated_fields=updated_fields)

            if avs_status:
                avs_items = ProfessionalChoice.objects.filter(admin_only=True)
                for avs_item in avs_items:
                    member.professional_certification.add(avs_item)
                    member.save()

            messages.success(request,'Your details have been saved.')
            return HttpResponseRedirect(reverse('account_renew_payment'))

    return render(request,"members/membership/renew/renew.html",{'content':content,'member_expiring':member_expiring,'member_expired':member_expired,'update_user_form':update_user_form,'update_personal_form':update_personal_form,'update_hospital_form':update_hospital_form,'update_personal_address_form':update_personal_address_form,'update_training_form':update_training_form,'update_professional_form':update_professional_form})


@lapsed_members_only
def renew_membership_payment(request):

    member = get_object_or_404(Member,user=request.user,user_type='member')
    #sort out the payment stuff here

    try:
        content = ContentBlock.objects.get(slug='member-renewal-payment')
    except:
        content = False

    try:
        direct_debit = MemberDirectDebit.objects.get(status='current',member=member)
        messages.success(request,'You have a Direct Debit associated with your membership, it will renew automatically.')
        return HttpResponseRedirect(reverse('account_membership'))
    except:
        pass

    if not member.expiry_date:
        messages.success(request,'Your membership is set to not expire, you do not need to renew.')
        return HttpResponseRedirect(reverse('account_membership'))
    else:
        year = member.expiry_date.year + 1

    if not member.member_type:
        messages.error(request, 'Sorry, your membership does not have a type set, please contact an administrator for further information')
        return HttpResponseRedirect(reverse('account_membership'))
    else:
        if member.expiry_date < date.today() or member.member_status == 'lapsed':
            payment_amount = member.member_type.new_fee
        else:
            payment_amount = member.member_type.renewal_fee

    payment = Payment(member=member, type='renewal')
    payment.save()

    today = date.today()

    if settings.DEVELOPMENT:
        payment.invoice = "%s_Member_Renewal_%s_DEV" % (settings.WEBSITE_CODE,payment.id)
    else :
        payment.invoice = "%s_Member_Renewal_%s" % (settings.WEBSITE_CODE,payment.id)
    payment.save()

    secret_key = settings.WORLD_PAY_SECRET_KEY
    installation_id = settings.WORLD_PAY_INSTALLATION_ID
    redirect_url = "%s%s" % (settings.PAYMENT_URL,reverse('account_renew_payment_process'))
    string = "%s:%s:%s:GBP:%s:%s" % (secret_key,installation_id,payment_amount,payment.invoice,redirect_url)
    import hashlib
    encrypted_string = hashlib.md5(string).hexdigest()

    """if request.POST:
        #process other payments
        if request.POST.get('payment_method'):
            payment_method = request.POST['payment_method']

            member_renewal = MemberRenewal(member=member,payment_method=payment_method)
            member_renewal.save()

            renewal_other_confirmation.send(sender=None,request=request,member=member,renewal=member_renewal)

            return HttpResponseRedirect(reverse('account_renew_complete'))"""

    return render(request,'members/membership/renew/renew-payment.html',{'content':content,'member':member,'payment':payment,'payment_amount':payment_amount,'redirect_url':redirect_url,'encrypted_string':encrypted_string})


@csrf_exempt
def renew_membership_payment_process(request):

    if not request.POST:
        raise Http404

    callbackPW                              = request.POST.get('callbackPW', '')
    transStatus                             = request.POST.get('transStatus', '')
    authAmount                              = request.POST.get('authAmount', '')
    cartId                                  = request.POST.get('cartId', '')

    payment = get_object_or_404(Payment,invoice=cartId)

    errors = []
    error = False

    if not callbackPW or not transStatus or not authAmount or not cartId:
        error = True
        errors.append('Missing a Required Variable')

    if callbackPW != settings.WORLD_PAY_PASSWORD:
        error = True
        errors.append('World Pay Password Incorrect')

    if not errors:
        if transStatus == 'Y':

            if payment.status == 'pending':

                payment.status = 'complete'
                payment.amount = authAmount
                payment.save()

                member = payment.member
                member_type = member.member_type
                current_expiry = member.expiry_date

                start_date = current_expiry + relativedelta(days=+1)
                end_date = start_date+relativedelta(months=+12,days=-1)

                member.expiry_date = end_date
                member.save()

                subscription_name = '%s Membership Subscription (%s)' % (member_type.name,start_date.strftime('%B %Y'))
                invoice_to_name = '%s %s %s' % (member.get_title_display(),member.given_name,member.surname)

                member_subscription = MemberSubscription(
                    member=member,
                    member_type=member_type,
                    subscription=subscription_name,
                    amount=payment.amount,
                    discount=0,
                    total=payment.amount,
                    invoice_to=invoice_to_name,
                    status='current',
                    start_date=start_date,
                    expiry_date=end_date,
                    invoice_created=date.today())
                member_subscription.save()

                receipt_name = '%s Membership Subscription (%s)' % (settings.WEBSITE_NAME,start_date.strftime('%B %Y'))
                receipt = Receipt(member=member,name=receipt_name,start_date=start_date,amount_paid=payment.amount,payment_type='Credit Card',member_subscription=member_subscription)
                receipt.save()

                try:
                    client = pdfcrowd.Client("calmdigital", "dc33e7c4525620565185d0a00d90b8f0")
                    client.setPageMargins('50','50','0','50')
                    output_file = open(os.path.join(settings.MEDIA_ROOT, 'members/receipts/membership_renewal_%s.pdf' % (receipt.id)), 'wb')
                    html = render_to_string('members/receipts/view-receipt-pdf.html',{'receipt':receipt})
                    client.convertHtml(html,output_file)
                    output_file.close()
                except:
                    pass

                receipt.file = 'members/receipts/membership_renewal_%s.pdf' % (receipt.id)
                receipt.save()

                #create certificate pdf
                certificate = Certificate(member=member,start_date=member_subscription.start_date,end_date=member_subscription.expiry_date)
                certificate.save()

                try:
                    client = pdfcrowd.Client("calmdigital", "dc33e7c4525620565185d0a00d90b8f0")
                    client.setPageMargins('50','50','0','50')
                    output_file = open(os.path.join(settings.MEDIA_ROOT, 'members/certificates/membership_certificate_%s.pdf' % (certificate.id)), 'wb')
                    html = render_to_string('members/certificates/view-cert-pdf.html',{'certificate':certificate})
                    client.convertHtml(html,output_file)
                    output_file.close()
                except:
                    pass

                certificate.file = 'members/certificates/membership_certificate_%s.pdf' % (certificate.id)
                certificate.save()

                renewal_confirmation.send(sender=None,member=member,subscription=member_subscription,method='Credit Card',receipt=receipt,certificate=certificate,notify_admin=True)

                notification = UserActivity(member=member,type='account-notification',title='Membership Renewed',text='Your membership has been successfully renewed.<br/>Visit <a href="%s">My Receipts</a> to view your receipt.' % (reverse('my_receipts')))
                notification.save()

            next = "%s%s" % (settings.URL,reverse('account_renew_payment_complete'))

        else:
            payment.status = 'rejected'
            payment.save()
            next = "%s%s" % (settings.URL,reverse('account_renew_payment_failure'))
    else:
        payment.status = 'rejected'
        payment.save()
        next = "%s%s" % (settings.URL,reverse('account_renew_payment_failure'))


    return render(request,'members/membership/renew/renew-payment-redirect.html',{'next':next})


@csrf_exempt
@lapsed_members_only
def renew_membership_payment_complete(request):

    try:
        content = ContentBlock.objects.get(slug='member-renewal-confirmed')
    except:
        content = False

    return render_to_response('members/membership/renew/renew-payment-complete.html',{'content':content},context_instance=RequestContext(request))

@csrf_exempt
@lapsed_members_only
def renew_membership_payment_failure(request):

    return render_to_response('members/membership/renew/renew-failure.html',{},context_instance=RequestContext(request))

@lapsed_members_only
def renew_membership_complete(request):

    member = get_object_or_404(Member,user=request.user)

    try:
        content = ContentBlock.objects.get(slug='member-renewal-complete')
    except ContentBlock.DoesNotExist:
        content = False

    return render_to_response('members/membership/renew/complete.html',{'content':content},context_instance=RequestContext(request))

@lapsed_members_only
def renew_membership_invoice(request):

    member = get_object_or_404(Member,user=request.user)

    try:
        content = ContentBlock.objects.get(slug='member-renewal-invoice')
    except ContentBlock.DoesNotExist:
        content = False

    try:
        direct_debit = MemberDirectDebit.objects.get(status='current',member=member)
        messages.success(request,'You have a Direct Debit associated with your membership, it will renew automatically.')
        return HttpResponseRedirect(reverse('account_membership'))
    except:
        pass

    if not member.expiry_date:
        messages.success(request,'Your membership is set to not expire, you do not need to renew')
        return HttpResponseRedirect(reverse('account_membership'))

    invoice_form = MemberRenewalInvoiceForm()

    if request.POST:
        invoice_form = MemberRenewalInvoiceForm(request.POST)

        if invoice_form.is_valid():
            #try:
            invoice = invoice_form.save(commit=False)
            invoice.member = member
            invoice.save()

            renewal_invoice_confirmation.send(sender=None,request=request,member=member,invoice=invoice)

            return HttpResponseRedirect(reverse('account_renew_invoice_complete'))

            #except:
            #    messages.error(request,'Could not save your invoice information')

    return render_to_response('members/membership/renew/invoice.html',{'content':content,'invoice_form':invoice_form},context_instance=RequestContext(request))



@lapsed_members_only
def renew_membership_invoice_complete(request):

    member = get_object_or_404(Member,user=request.user)

    try:
        content = ContentBlock.objects.get(slug='member-renewal-invoice-complete')
    except ContentBlock.DoesNotExist:
        content = False

    return render_to_response('members/membership/renew/invoice-complete.html',{'content':content},context_instance=RequestContext(request))


@lapsed_members_only
def renew_membership_direct_debit(request):

    member = get_object_or_404(Member,user=request.user)

    try:
        content = ContentBlock.objects.get(slug='member-renewal-direct-debit')
    except ContentBlock.DoesNotExist:
        content = False

    try:
        member_direct_debit = MemberDirectDebit.objects.get(member=member,status='approved')

        messages.success(request,'You already have a Direct Debit setup to handle your Membership Renewals')
        return HttpResponseRedirect(reverse('account_membership'))
    except MemberDirectDebit.DoesNotExist:
        member_direct_debit = False
        direct_debit_form = DirectDebitForm()

    if request.POST:

        if member_direct_debit:
            direct_debit_form = DirectDebitForm(request.POST,instance=member_direct_debit)
        else:
            direct_debit_form = DirectDebitForm(request.POST)

        if direct_debit_form.is_valid():

            errors = False

            if member_direct_debit:
                try:
                    direct_debit_form.save()

                    renewal_direct_debit_confirmation.send(sender=None,request=request,member=member,direct_debit=member_direct_debit)
                    return HttpResponseRedirect(reverse('account_renew_direct_debit_complete'))

                except:
                    messages.error(request,'Could not update your direct debit')

            else:
                try:
                    member_direct_debit = direct_debit_form.save(commit=False)
                    member_direct_debit.member = member
                    member_direct_debit.collection = 'A'
                    member_direct_debit.submission = '01'
                    member_direct_debit.type = 'UKDD'
                    member_direct_debit.save()

                    renewal_direct_debit_confirmation.send(sender=None,request=request,member=member,direct_debit=member_direct_debit)
                    return HttpResponseRedirect(reverse('account_renew_direct_debit_complete'))

                except:
                    messages.error(request,'Could not create the Direct Debit')

    return render_to_response('members/membership/renew/direct-debit.html',{'content':content,'direct_debit_form':direct_debit_form},context_instance=RequestContext(request))


@lapsed_members_only
def renew_membership_direct_debit_complete(request):

    member = get_object_or_404(Member,user=request.user)

    try:
        content = ContentBlock.objects.get(slug='member-renewal-direct-debit-confirm')
    except ContentBlock.DoesNotExist:
        content = False

    return render_to_response('members/membership/renew/direct-debit-confirm.html',{'content':content},context_instance=RequestContext(request))

@members_only
def my_receipts(request):

    member = get_object_or_404(Member,user=request.user)
    receipts = Receipt.objects.filter(member=member).order_by('-created')

    receipt_activity = UserActivity.objects.filter(type='account-notification',member=member)
    for activity in receipt_activity:
        activity.read = True
        activity.save()

    return render_to_response('members/receipts/my-receipts.html',{'receipts':receipts},context_instance=RequestContext(request))

def view_receipt_pdf(request,receipt_key):

    receipt = get_object_or_404(Receipt,unique_key=receipt_key)

    return render_to_response('members/receipts/view-receipt-pdf.html',{'receipt':receipt},context_instance=RequestContext(request))

@members_only
def my_certificates(request):

    member = get_object_or_404(Member,user=request.user)
    certificates = Certificate.objects.filter(member=member).order_by('-created')

    certificate_activity = UserActivity.objects.filter(type='certificate-notification',member=member)
    for activity in certificate_activity:
        activity.read = True
        activity.save()

    return render_to_response('members/certificates/my-certificates.html',{'certificates':certificates},context_instance=RequestContext(request))

def view_cert_pdf(request,certificate_id):

    certificate = get_object_or_404(Certificate,id=certificate_id)

    #return render_to_response('members/certificates/view-cert-pdf.html',{'certificate':certificate},context_instance=RequestContext(request))

    html = loader.render_to_string('members/certificates/view-cert-pdf.html',{'certificate':certificate},context_instance=RequestContext(request))

    client = pdfcrowd.Client("calmdigital", "dc33e7c4525620565185d0a00d90b8f0")
    client.setPageMargins('50','50','50','50')

    pdf = client.convertHtml(html)

     # set HTTP response headers
    response = HttpResponse(content_type="application/pdf")
    response["Cache-Control"] = "no-cache"
    response["Accept-Ranges"] = "none"
    response["Content-Disposition"] = "attachment; filename=certificate.pdf"

    response.write(pdf)

    return response

@members_only
def documents(request):

    member = get_object_or_404(Member,user=request.user)
    member_documents = MemberDocument.objects.filter(member=member).order_by('-created')

    return render(request,'members/documents/documents.html',{'member':member,'member_documents':member_documents})

@members_only
def download_document(request,id):

    from filetransfers.api import serve_file

    member = get_object_or_404(Member,user=request.user)
    document = get_object_or_404(MemberDocument,id=id,member=member)

    if document.document:
        return serve_file(request,document.document,save_as=True)
    else:
        messages.error(request,'Sorry there is no file associated with this document.')

    return HttpResponseRedirect(reverse('account_documents',args=[member.id]))