Produits Entr'ouvert » Mandaye

# mandayejs - saml reverse proxy

# Copyright (C) 2015  Entr'ouvert

#

# This program is free software: you can redistribute it and/or modify it

# under the terms of the GNU Affero General Public License as published

# by the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from __future__ import absolute_import

import os

import json

import logging

import urlparse

import urllib

from django.conf import settings

from django.contrib.auth import views as auth_views

from django.contrib.auth import logout as auth_logout

from django.contrib.auth.models import User

from django.contrib.auth.decorators import login_required

from django.contrib import messages

from django.forms import PasswordInput

from django.forms import models as model_forms

from django.http import HttpResponseRedirect, HttpResponse

from django.shortcuts import get_object_or_404, render, resolve_url

from django.template import RequestContext

from django.views.generic.base import TemplateView

from django.views.decorators.csrf import csrf_exempt

from django.db import IntegrityError

from django.utils.translation import ugettext_lazy as _

from django.template import RequestContext, Template

from .models import UserCredentials

from mandayejs.mandaye.forms import FormFactory

from mandayejs.mandaye.utils import exec_phantom, cookie_builder, get_location

logger = logging.getLogger(__name__)

def login(request, *args, **kwargs):

    return auth_views.login(request, *args, **kwargs)

def logout(request, *args, **kwargs):

    auth_logout(request)

    return HttpResponseRedirect('/')

class Panel(TemplateView):

    template_name = 'mandaye/panel.html'

    def get_context_data(self, **kwargs):

        context = super(Panel, self).get_context_data(**kwargs)

        scripts = getattr(settings, 'SITE_SCRIPTS', [])

        static_root_path = getattr(settings, 'SITE_STATIC_ROOT_PATH', '')

        context['site_scripts'] = [os.path.join(static_root_path, s) for s in scripts]

        context['ca_url'] = getattr(settings, 'SITE_CA_URL', '/')

        context['is_linked'] = self.is_account_linked()

        return context

    def is_account_linked(self):

        """Check if user account is associated

        """

        try:

            user = User.objects.get(username=self.request.user.username)

            return user.usercredentials_set.get().linked

        except (User.DoesNotExist, UserCredentials.DoesNotExist) as e:

            return False

panel = Panel.as_view()

@login_required

def post_login(request, *args, **kwargs):

    try:

        user = User.objects.get(username=request.user.username)

        logger.debug(user)

        credentials = UserCredentials.objects.get(

                user=user)

        logger.debug(credentials)

    except (UserCredentials.DoesNotExist,):

        return HttpResponseRedirect(resolve_url('associate'))

    context = {}

    context['address'] = getattr(settings, 'SITE_HOME_PATH', '/')

    return render(request, 'mandaye/post-login.html', context)

@login_required

@csrf_exempt

def associate(request, *args, **kwargs):

    if request.method == 'POST':

        form = FormFactory(request.POST)

        if form.is_valid():

            credentials, created = UserCredentials.objects.get_or_create(user=request.user)

            credentials.locators = form.cleaned_data

            credentials.linked = False

            credentials.save()        

            return HttpResponseRedirect(resolve_url('post-login'))

    else :

        form = FormFactory()

    site_static_root = getattr(settings, 'SITE_STATIC_ROOT_PATH', '')

    associate_static = getattr(settings, 'SITE_ASSOCIATE_STATIC',

                           {'css':'', 'js':''})

    response = render(request, 'mandaye/associate.html', {

        'form': form,

        'associate_js': os.path.join(site_static_root, associate_static['js']),

        'associate_css': os.path.join(site_static_root, associate_static['css'])        

    })

    return response

@login_required

def dissociate(request, *args, **kwargs):

    try:

        c_user = UserCredentials.objects.get(

                user__username=request.user.username)

        c_user.delete()

        logger.debug("{} dissacioted".format(c_user.user.username))

        response = HttpResponseRedirect('/')

        for cookie_key in getattr(settings, 'SITE_AUTH_COOKIE_KEYS', []):

            response.delete_cookie(cookie_key)

            logger.debug("cookie {} deleted".format(cookie_key))

        return response 

    except (UserCredentials.DoesNotExist,):

        return HttpResponseRedirect(resolve_url('associate'))

@login_required

def post_login_do(request, *args, **kwargs):

    user = User.objects.get(username=request.user.username)

    try:

        credentials = user.usercredentials_set.get()

    except (UserCredentials.DoesNotExist,):

        return HttpResponseRedirect(resolve_url('associate'))

    site_static_root = os.path.join(getattr(settings, 'STATIC_ROOT'), getattr(settings, 'SITE_STATIC_ROOT_PATH', ''))

    site_auth_checker = getattr(settings, 'SITE_AUTH_CHECKER', '')

    login_info = {

        'address': request.build_absolute_uri(settings.SITE_LOGIN_PATH),

        'cookies': [],

        'locators': [ credentials.to_login_info() ],

        'homepath': getattr(settings, 'SITE_HOME_PATH', '/'),

        'auth_checker': os.path.join(site_static_root, site_auth_checker)

    }

    logger.debug(login_info)

    result = exec_phantom(login_info)

    logger.debug(result)

    if result.get('result') != 'ok':

        logger.debug('authentication failed')

        logger.debug("redirecting to {}".format(resolve_url('associate')))

        credentials.delete()

        messages.error(request, _('wrong user credentials'))

        url = resolve_url('associate')

    else:

        credentials.linked = True

        credentials.save()

        url = getattr(settings, 'SITE_HOME_PATH', '/')

    template = Template('<script type="text/javascript">\

                window.top.location = "{{url}}";</script>')

    context = RequestContext(request, {'url': url})

    response = HttpResponse(template.render(context))

    if result.get('headers',None):

        response.cookies = cookie_builder(result.get('headers'))

    return response