web2.0-backend/members/views/utils.py

from django.shortcuts import render
from django.contrib.auth.decorators import permission_required, login_required
from django.views.decorators.http import require_http_methods
from django.views.decorators.csrf import ensure_csrf_cookie
from django.http import HttpResponse, HttpResponseRedirect
from django.core.mail import send_mail
from django.conf import settings
from django.utils.translation import ugettext as _
from django.forms.models import model_to_dict

import logging
import csv

# REST framework
from members.serializers import MemberSerializer
from members.throttles import BurstRateThrottle, SustainedRateThrottle

from rest_framework import generics
from rest_framework import permissions

from members.models import Member, Request, Payment
from members.forms import MemberForm, PaymentForm, ApplicationForm, CSVValidationError
from members.tables import MemberTable, PaymentTable, RequestTable


# Can be used to retrieve single member information via REST API
class MemberDetail(generics.RetrieveAPIView):
    """Member detail rest API view."""

    queryset = Member.objects.all()
    serializer_class = MemberSerializer
    permission_classes = (permissions.DjangoModelPermissions, )
    throttle_classes = (BurstRateThrottle, SustainedRateThrottle, )


def error_view(request, message):
    return render(request, 'error.html', {'error': str(message)})


def validate_recaptcha(response):
    """
    Recaptcha is used in member applications.

    :param response:
    :return: Boolean, success or not
    """
    values = {
        'secret': settings.GOOGLE_RECAPTCHA_SECRET_KEY,
        'response': response,
    }
    url = "https://www.google.com/recaptcha/api/siteverify"
    headers = {'Content-type': 'application/x-www-form-urlencoded'}
    resp = requests.post(url, values, headers=headers)
    try:
        result = json.loads(resp.text)
        logging.info('Recaptcha response: {}'.format(result))
        return result["success"]
    except:
        return False


def send_mail_wrapper(subject, message):
    """Call send_mail function."""
    send_mail(subject,
              message,
              'no-reply@sahkoinsinoorikilta.fi',
              ['viestintamestari@sahkoinsinoorikilta.fi'],
              fail_silently=False)


def convert_table_to_html(table, request):
    """
    Convert table to html.

    This is a horrible hack for converting a table object to raw html.
    Even with extensive research I wasn't able to find a way to add a path
    prefix "e.g. /members/list" to the query strings "e.g. ?sort=foo", so I
    did it manually with string.replace.

    Note: When adding the html to a page, you need to run it through
    the "safe" filter. E.g. "{{ table|safe }}"

    :param table: Table object from members.tables
    :param request:  HttpRequest
    :return: Raw html string
    """
    table_as_html = table.as_html(request)
    path = request.path

    fixed = table_as_html.replace(r'href="?', r'href="{}?'.format(path))
    return fixed


@ensure_csrf_cookie
@require_http_methods(["GET"])
@login_required(login_url='/login')
@permission_required('members.change_member', raise_exception=True)
def settings_page(request, *args, **kwargs):
    """Render member app settings page."""
    return render(request, 'settings.html', {})


@ensure_csrf_cookie
@require_http_methods(["POST"])
@login_required(login_url='/login')
@permission_required(['members.change_member', 'members.change_payment'], raise_exception=True)
def import_csv(request, *args, **kwargs):
    """Get csv data imported to page and create members based on that."""
    try:
        data = request.POST['textfield']
        delimiter = request.POST.get('delimiter', ',')
        payment_source = request.POST['payment_source']
    except:
        return render(request,
                      'error.html',
                      {'error': _('Missing "textfield" POST request field')})

    try:
        result = MemberForm.csv_to_models(data, payment_source=payment_source, delimiter=delimiter)
    except CSVValidationError as ex:
        logging.exception('Model validation error')
        return error_view(request, ex.form_errors)
    except Exception as ex:
        logging.exception('Other error in CSV import')
        return error_view(request, ex)

    member_table = MemberTable(result.members,
                               request=request,
                               exclude=['id', 'options'],
                               attrs={'class': 'table table-bordered table-hover'})

    member_table_html = convert_table_to_html(member_table, request)

    payment_table = PaymentTable(result.payments,
                                 request=request,
                                 exclude=['id', 'options'],
                                 attrs={'class': 'table table-bordered table-hover'})

    payment_table_html = convert_table_to_html(payment_table, request)

    request.session['models'] = result
    context = {
        'members': member_table_html,
        'payments': payment_table_html
    }
    return render(request, 'member_add_many_confirm.html', context)


@ensure_csrf_cookie
@require_http_methods(["GET"])
@permission_required('members.read_member', login_url='/login', raise_exception=True)
def export_csv(request, *args, **kwargs):
    """Export members as csv."""
    response = HttpResponse()
    response['Content-type'] = 'text/csv'
    response['Accept'] = 'text/csv'
    response['Content-Disposition'] = 'filename; filename=members.csv'
    writer = csv.writer(response, csv.excel)
    # BOM (optional...Excel needs it to open UTF-8 file properly)
    response.write(u'\ufeff'.encode('utf8'))
    for obj in Member.objects.all():
        data = obj.as_array()
        field_list = list(map(lambda d: str(d), data))

        writer.writerow(field_list)

    return response


def send_mail_wrapper(subject, message, email_to):
    """Send mail to default email."""
    send_mail(subject,
              message,
              settings.DEFAULT_EMAIL_FROM,
              [email_to],
              fail_silently=False)