ccvpn/lambdainst/views.py

from math import ceil
import base64
import hmac
from datetime import datetime, timedelta
from hashlib import sha256
from urllib.parse import parse_qsl, urlencode

import requests
from constance import config as site_config
from django.conf import settings as project_settings
from django.contrib import auth, messages
from django.contrib.admin.sites import site
from django.contrib.auth.decorators import login_required, user_passes_test
from django.contrib.auth.models import User
from django.db.models import Count
from django.db import transaction
from django.http import (
    HttpResponse,
    HttpResponseNotFound,
    HttpResponseRedirect,
    JsonResponse,
)
from django.shortcuts import redirect, render
from django.utils import timezone
from django.utils.translation import ugettext as _
from django.template.loader import render_to_string
from django_countries import countries
import django_lcore
import lcoreapi

from ccvpn.common import get_client_ip, get_price_float
from payments.models import ACTIVE_BACKENDS
from .forms import SignupForm, ReqEmailForm, WgPeerForm
from .models import VPNUser
from . import graphs


def get_locations():
    """Pretty bad thing that returns get_locations() with translated stuff
    that depends on the request
    """
    countries_d = dict(countries)
    locations = django_lcore.get_clusters()
    for (_), loc in locations:
        code = loc["country_code"].upper()
        loc["country_name"] = countries_d.get(code, code)

        loc["load_percent"] = ceil(
            (loc["usage"].get("net", 0) / (loc["bandwidth"] / 1e6)) * 100
        )
    locations = list(sorted(locations, key=lambda l: l[0]))
    return locations


def log_errors(request, form):
    errors = []
    for field in form:
        for e in field.errors:
            errors.append(e)
    messages.add_message(request, messages.ERROR, ", ".join(errors))


def ca_crt(request):
    return HttpResponse(
        content=project_settings.OPENVPN_CA, content_type="application/x-x509-ca-cert"
    )


def logout(request):
    auth.logout(request)
    return redirect("index")


def signup(request):
    if request.user.is_authenticated:
        return redirect("account:index")

    if request.method != "POST":
        form = SignupForm()
        return render(request, "ccvpn/signup.html", dict(form=form))

    form = SignupForm(request.POST)

    grr = request.POST.get("g-recaptcha-response", "")
    if captcha_test(grr, request):
        request.session["signup_captcha_pass"] = True
    elif not request.session.get("signup_captcha_pass"):
        messages.error(request, _("Invalid captcha. Please try again"))
        return render(request, "ccvpn/signup.html", dict(form=form))

    if not form.is_valid():
        return render(request, "ccvpn/signup.html", dict(form=form))

    user = User.objects.create_user(
        form.cleaned_data["username"],
        form.cleaned_data["email"],
        form.cleaned_data["password"],
    )
    user.save()

    try:
        user.vpnuser
    except VPNUser.DoesNotExist:
        user.vpnuser = VPNUser.objects.create(user=user)
        user.vpnuser.save()

    try:
        user.vpnuser.referrer = User.objects.get(id=request.session.get("referrer"))
    except User.DoesNotExist:
        pass

    user.vpnuser.campaign = request.session.get("campaign")
    user.vpnuser.add_paid_time(timedelta(days=7), "trial")

    user.vpnuser.save()
    user.vpnuser.lcore_sync()

    user.backend = "django.contrib.auth.backends.ModelBackend"
    auth.login(request, user)

    # invalidate that captcha
    request.session["signup_captcha_pass"] = False

    return redirect("account:index")


@login_required
def discourse_login(request):
    sso_secret = project_settings.DISCOURSE_SECRET
    discourse_url = project_settings.DISCOURSE_URL

    if project_settings.DISCOURSE_SSO is not True:
        return HttpResponseNotFound()

    payload = request.GET.get("sso", "")
    signature = request.GET.get("sig", "")

    expected_signature = hmac.new(
        sso_secret.encode("utf-8"), payload.encode("utf-8"), sha256
    ).hexdigest()

    if signature != expected_signature:
        return HttpResponseNotFound()

    if request.method == "POST" and "email" in request.POST:
        form = ReqEmailForm(request.POST)
        if not form.is_valid():
            return render(request, "ccvpn/require_email.html", dict(form=form))

        request.user.email = form.cleaned_data["email"]
        request.user.save()

    if not request.user.email:
        form = ReqEmailForm()
        return render(request, "ccvpn/require_email.html", dict(form=form))

    try:
        payload = base64.b64decode(payload).decode("utf-8")
        payload_data = dict(parse_qsl(payload))
    except (TypeError, ValueError):
        return HttpResponseNotFound()

    payload_data.update(
        {
            "external_id": request.user.id,
            "username": request.user.username,
            "email": request.user.email,
            "require_activation": "true",
        }
    )

    payload = urlencode(payload_data)
    payload = base64.b64encode(payload.encode("utf-8"))
    signature = hmac.new(sso_secret.encode("utf-8"), payload, sha256).hexdigest()
    redirect_query = urlencode(dict(sso=payload, sig=signature))
    redirect_path = "/session/sso_login?" + redirect_query

    return HttpResponseRedirect(discourse_url + redirect_path)


@login_required
def index(request):
    ref_url = project_settings.ROOT_URL + "?ref=" + str(request.user.id)

    twitter_url = "https://twitter.com/intent/tweet?"
    twitter_args = {
        "text": _("Awesome VPN! 3€ per month, with a free 7 days trial!"),
        "via": "CCrypto_VPN",
        "url": ref_url,
        "related": "CCrypto_VPN,CCrypto_org",
    }

    class price_fn:
        """Clever hack to get the price in templates with {{price.3}} with
        3 an arbitrary number of months
        """

        def __getitem__(self, months):
            n = int(months) * get_price_float()
            c = project_settings.PAYMENTS_CURRENCY[1]
            return "%.2f %s" % (n, c)

    context = dict(
        title=_("Account"),
        ref_url=ref_url,
        twitter_link=twitter_url + urlencode(twitter_args),
        subscription=request.user.vpnuser.get_subscription(),
        backends=sorted(ACTIVE_BACKENDS.values(), key=lambda x: x.backend_display_name),
        subscr_backends=sorted(
            (b for b in ACTIVE_BACKENDS.values() if b.backend_has_recurring),
            key=lambda x: x.backend_id,
        ),
        default_backend="paypal",
        hcaptcha_site_key=project_settings.HCAPTCHA_SITE_KEY,
        price=price_fn(),
        user_motd=site_config.MOTD_USER,
    )
    return render(request, "lambdainst/account.html", context)


def captcha_test(grr, request):
    api_url = project_settings.HCAPTCHA_API

    if not project_settings.HCAPTCHA_SITE_KEY:
        return True

    if api_url == "TEST" and grr == "TEST-TOKEN":
        # FIXME: i'm sorry.
        return True

    data = dict(secret=project_settings.HCAPTCHA_SECRET_KEY, response=grr)

    try:
        r = requests.post(api_url, data=data)
        r.raise_for_status()
        d = r.json()
        return d.get("success")
    except (requests.ConnectionError, requests.HTTPError, ValueError):
        return False


def make_export_zip(user, name):
    import io
    import zipfile
    import json

    f = io.BytesIO()
    z = zipfile.ZipFile(f, mode="w")

    gw_cache = {}

    def process_wg_peer(item):
        keys = {
            "gateway_port",
            "id",
            "local_ipv4",
            "local_ipv6",
            "name",
            "object",
            "private_key",
            "public_key",
        }
        return {k: v for (k, v) in item.items() if k in keys}

    def process_ovpn_sess(item):
        keys = {
            "connect_date",
            "disconnect_date",
            "remote",
            "object",
            "protocol",
            "id",
            "stats",
            "tunnel",
        }

        def convert(v):
            if isinstance(v, datetime):
                return v.isoformat()
            return v

        obj = {k: convert(v) for (k, v) in item.items() if k in keys}
        gw_url = item["gateway"]["href"]
        if gw_url not in gw_cache:
            gw = django_lcore.api.get(gw_url)
            gw_cache[gw_url] = {
                "name": gw["name"],
                "ipv4": gw["main_addr"]["ipv4"],
                "ipv6": gw["main_addr"]["ipv6"],
            }
        obj["gateway"] = gw_cache[gw_url]
        return obj

    def process_payments(item):
        obj = {
            "id": item.id,
            "backend": item.backend_id,
            "status": item.status,
            "created": item.created.isoformat(),
            "confirmed": item.confirmed_on.isoformat() if item.confirmed_on else None,
            "amount": item.amount / 100,
            "paid_amount": item.amount / 100,
            "time": item.time.total_seconds(),
            "external_id": item.backend_extid,
        }
        if item.subscription:
            obj["subscription"] = item.subscription.backend_extid
        else:
            obj["subscription"] = None
        return obj

    with z.open(name + "/account.json", "w") as jf:
        jf.write(
            json.dumps(
                {
                    "username": user.username,
                    "email": user.email,
                    "date_joined": user.date_joined.isoformat(),
                    "expiration": user.vpnuser.expiration.isoformat()
                    if user.vpnuser.expiration
                    else None,
                },
                indent=2,
            ).encode("ascii")
        )

    with z.open(name + "/wireguard_peers.json", "w") as jf:
        try:
            keys = list(
                map(process_wg_peer, django_lcore.api.get_wg_peers(user.username))
            )
        except lcoreapi.APINotFoundError:
            keys = []
        jf.write(json.dumps(keys, indent=2).encode("ascii"))

    with z.open(name + "/openvpn_logs.json", "w") as jf:
        base = django_lcore.api.info["current_instance"]
        next_page = "/users/" + user.username + "/sessions/"
        try:
            items = django_lcore.api.get(base + next_page).list_iter()
        except lcoreapi.APINotFoundError:
            items = []
        items = list(map(process_ovpn_sess, items))
        jf.write(json.dumps(items, indent=2).encode("ascii"))

    with z.open(name + "/payments.json", "w") as jf:
        items = user.payment_set.all()
        items = list(map(process_payments, items))
        jf.write(json.dumps(items, indent=2).encode("ascii"))

    z.close()
    return f.getvalue()


def deactivate_user(user):
    """clear most information from a user, keeping the username and id"""
    user.vpnuser.clear_fields()
    user.vpnuser.save()

    user.is_active = False
    user.email = ""
    user.password = ""
    user.save()

    user.payment_set.update(backend_data="null")
    user.subscription_set.update(backend_data="null")

    django_lcore.sync_user(user.vpnuser)


@login_required
def settings(request):
    can_delete = request.user.vpnuser.get_subscription() is None

    if request.method != "POST":
        return render(
            request,
            "lambdainst/settings.html",
            dict(
                can_delete=can_delete,
            ),
        )

    action = request.POST.get("action")

    current_pw = request.POST.get("current_password")
    if not request.user.check_password(current_pw):
        messages.error(request, _("Invalid password"))
        return redirect("lambdainst:account_settings")

    if action == "email":
        email = request.POST.get("email")
        if email:
            request.user.email = email
            messages.success(request, _("OK! Email address changed."))
        else:
            request.user.email = ""
            messages.success(request, _("OK! Email address unset."))

        request.user.save()
        return redirect("lambdainst:account_settings")

    elif action == "password":
        pw = request.POST.get("password")
        pw2 = request.POST.get("password2")
        if pw != pw2 or not pw:
            messages.error(request, _("Password and confirmation do not match"))
        else:
            request.user.set_password(pw)
            messages.success(request, _("OK! Password changed."))
            request.user.save()
            django_lcore.sync_user(request.user.vpnuser)
        return redirect("lambdainst:account_settings")

    elif action == "export":
        timestamp = datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
        data = make_export_zip(request.user, timestamp)
        r = HttpResponse(content=data, content_type="application/zip")
        r[
            "Content-Disposition"
        ] = 'attachment; filename="ccvpn-export-{}-{}.zip"'.format(
            request.user.username, timestamp
        )
        return r

    elif action == "delete" and can_delete:
        with transaction.atomic():
            deactivate_user(request.user)
        logout(request)
        messages.success(request, _("OK! Your account has been deactivated."))
        return redirect("/")

    return render(
        request,
        "lambdainst/settings.html",
        dict(
            title=_("Settings"),
            user=request.user,
            can_delete=can_delete,
        ),
    )


@login_required
def config(request):
    return render(
        request,
        "lambdainst/config.html",
        dict(
            title=_("Config"),
            config_os=django_lcore.openvpn.CONFIG_OS,
            config_countries=(c for _, c in get_locations()),
            config_protocols=django_lcore.openvpn.PROTOCOLS,
        ),
    )


def api_locations(request):
    def format_loc(cc, l):
        msg = ""
        tags = l.get("tags", {})
        message = tags.get("message")
        if message:
            msg = " [%s]" % message
        return {
            "country_name": l["country_name"] + msg,
            "country_code": cc,
            "hostname": l["hostname"],
            "bandwidth": l["bandwidth"],
            "servers": l["servers"],
        }

    return JsonResponse(
        dict(locations=[format_loc(cc, l) for cc, l in get_locations()])
    )


def status(request):
    locations = get_locations()

    ctx = {
        "title": _("Servers"),
        "locations": locations,
    }
    return render(request, "lambdainst/status.html", ctx)


@user_passes_test(lambda user: user.is_staff)
def admin_status(request):
    graph_name = request.GET.get("graph_name")
    graph_period = request.GET.get("period")
    if graph_period not in ("y", "m"):
        graph_period = "m"
    if graph_name:
        if graph_name == "users":
            content = graphs.users_graph(graph_period)
        elif graph_name == "payments_paid":
            content = graphs.payments_paid_graph(graph_period)
        elif graph_name == "payments_success":
            content = graphs.payments_success_graph(graph_period)
        else:
            return HttpResponseNotFound()
        return HttpResponse(content=content, content_type="image/svg+xml")

    payment_status = ((b, b.get_info()) for b in ACTIVE_BACKENDS.values())
    payment_status = ((b, i) for (b, i) in payment_status if i)

    lcore_keys = {
        "core_name",
        "core_now",
        "core_version",
        "current_instance",
        "key_public",
    }

    ctx = {
        "api_status": {
            k: str(v) for k, v in django_lcore.api.info.items() if k in lcore_keys
        },
        "payment_backends": sorted(
            ACTIVE_BACKENDS.values(), key=lambda x: x.backend_id
        ),
        "payment_status": payment_status,
    }
    ctx.update(site.each_context(request))
    return render(request, "lambdainst/admin_status.html", ctx)


@user_passes_test(lambda user: user.is_staff)
def admin_ref(request):
    last_week = datetime.now() - timedelta(days=7)
    last_month = datetime.now() - timedelta(days=30)

    top_ref = User.objects.annotate(n_ref=Count("referrals")).order_by("-n_ref")[:10]
    top_ref_week = (
        User.objects.filter(referrals__user__date_joined__gt=last_week)
        .annotate(n_ref=Count("referrals"))
        .order_by("-n_ref")[:10]
    )
    top_ref_month = (
        User.objects.filter(referrals__user__date_joined__gt=last_month)
        .annotate(n_ref=Count("referrals"))
        .order_by("-n_ref")[:10]
    )

    ctx = {
        "top_ref": top_ref,
        "top_ref_week": top_ref_week,
        "top_ref_month": top_ref_month,
    }
    ctx.update(site.each_context(request))
    return render(request, "lambdainst/admin_ref.html", ctx)


@login_required
def wireguard(request):
    api = django_lcore.api
    if request.method == "POST":
        action = request.POST.get("action")
        if action == "delete_key":
            key = api.get_wg_peer(request.user.username, request.POST.get("peer_id"))
            if key:
                key.delete()
        elif action == "set_name":
            key = api.get_wg_peer(request.user.username, request.POST.get("peer_id"))
            if key:
                name = request.POST.get("name")
                if name:
                    name = name[:21]
                key.rename(name)
        return redirect(request.path)

    try:
        keys = api.get_wg_peers(request.user.username)
    except lcoreapi.APINotFoundError:
        django_lcore.sync_user(request.user.vpnuser)
        keys = []

    context = dict(
        can_create_key=len(keys) < int(site_config.WIREGUARD_MAX_PEERS),
        menu_item="wireguard",
        enabled=request.user.vpnuser.is_paid,
        config_countries=[(k, v) for (k, v) in django_lcore.get_clusters()],
        keys=keys,
        locations=get_locations(),
    )
    return render(request, "lambdainst/wireguard.html", context)


@login_required
def wireguard_new(request):
    if not request.user.vpnuser.is_paid:
        return redirect("account:index")

    try:
        keys = django_lcore.api.get_wg_peers(request.user.username)
    except lcoreapi.APINotFoundError:
        django_lcore.sync_user(request.user.vpnuser)
        keys = []
    if len(keys) >= int(site_config.WIREGUARD_MAX_PEERS):
        return redirect("/account/wireguard")

    api = django_lcore.api
    if request.method == "POST":
        action = request.POST.get("action")
        form = WgPeerForm(request.POST)
        if action == "add_key":
            if form.is_valid():
                api.create_wg_peer(
                    request.user.username,
                    public_key=form.cleaned_data["public_key"],
                    name=form.cleaned_data["name"],
                )
            else:
                log_errors(request, form)
        return redirect("/account/wireguard")
    context = dict(
        menu_item="wireguard",
        locations=get_locations(),
    )
    return render(request, "lambdainst/wireguard_new.html", context)