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/>.

import os

import json

import logging

import subprocess

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 import get_user_model

from django.contrib.auth.decorators import login_required

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 .models import UserCredentials

from mandayejs.mandaye.forms import FormFactory

from mandayejs.mandaye.utils import cookie_builder, get_location

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)

        context['login_txt'] = _('login')

        context['logout_txt'] = _('logout')

        context['site_scripts'] = getattr(settings, 'SITE_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: 

            UserCredentials.objects.get(user=self.request.user)

            return True

        except :

            return False

panel = Panel.as_view()

@login_required

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

    try:

        credentials = UserCredentials.objects.get(

                user=request.user)

    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.POST:

        credentials = UserCredentials()

        credentials.user = request.user

        credentials.locators = request.POST

        form = FormFactory(request.POST, auto_id=True, locators=settings.SITE_LOCATORS)

    else:

        form = FormFactory(auto_id=True, locators=settings.SITE_LOCATORS)

    if not form.is_valid():

        return render(request, 'mandaye/associate.html', {

                    'form': form, 

                    'submit': _('submit'), 

                    'associate': _('associate your account'),

                    'associate_static': getattr(settings, 

                        'SITE_ASSOCIATE_STATIC', 

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

                })

    try:

        credentials.save()

    except (IntegrityError,) as e:

        pass

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

@login_required

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

    try:

        User = get_user_model()

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

        return HttpResponseRedirect(resolve_url('mellon_logout'))

    except (User.DoesNotExist,) as e:

        return HttpResponseRedirect(resolve_url('associate'))

@login_required

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

    credentials = get_object_or_404(UserCredentials, user=request.user)

    login_info = {

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

        'cookies': [],

        'locators': [ credentials.to_login_info() ] 

    }

    result = exec_phantom(login_info) 

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

        return HttpResponseRedirect('/')

    location = get_location(result.get('url','/'))

    response = HttpResponseRedirect(location)

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

    return response

def exec_phantom(data):

    phantom = subprocess.Popen(['/usr/bin/phantomjs',

        '--ignore-ssl-errors=yes',

        '--ssl-protocol=any',

        '--cookies-file=cookies.txt',

        os.path.join(settings.BASE_DIR,'mandayejs/do_login.js')],

        close_fds=True,

        stdin=subprocess.PIPE,

        stdout=subprocess.PIPE)

    stdout, stderr = phantom.communicate(json.dumps(data))

    result = json.loads(stdout)

    return result