Produits Entr'ouvert » Mandaye

from importlib import import_module

from django.conf import settings

from django.http import Http404

from django.core.exceptions import ImproperlyConfigured

from django.core.urlresolvers import resolve

def get_app_settings():

    module = import_module(module_name)

    return getattr(module, app_settings)

def app_web_services(request, path):

    app = get_app_settings()

    if hasattr(app, 'urlpatterns'):

        return view(request, *args, **kwargs)

    raise Http404

    def __new__(cls, name, bases, dct):

        if name != 'AppSettings':

                missing_key = set(cls.REQUIRED_KEYS).difference(set(dct.keys())) or None

                if missing_key:

                    raise ImproperlyConfigured('{} is mandatory'.format(missing_key.pop()))

                # Script asserting phantomjs authentication

                # Default form submit element

                if not dct.get('SITE_FORM_SUBMIT_ELEMENT', None):

                    dct['SITE_FORM_SUBMIT_ELEMENT'] = 'input[type=submit], button'

    ]

    SITE_APP_SCRIPTS = [

        'duonet/js/duonet.js',

    SITE_FORCE_REDIRECT_URL = '/Connect.aspx'

        'account_details': '/DEFAULT/Ermes/Services/ILSClient.svc/RetrieveAccount',

    }

        url(

            r'account/(?P<username>[\w+]*)/$',

            'mandayejs.views.archimed_account_details',

class Imuse(AppSettings):

    SITE_LOCATORS = [

        {

from rest_framework import status

from rest_framework.views import APIView

from rest_framework.response import Response

from mandayejs.applications import get_app_settings

from mandayejs.mandaye.models import UserCredentials

    def get(self, request, *args, **kwargs):

        app_settings = get_app_settings()

        locators = {

            for locator in app_settings.SITE_LOCATORS

        }

        return Response(locators)

        data = request.data

        user, created = User.objects.get_or_create(

        )

        uuid, created = UserSAMLIdentifier.objects.get_or_create(

        )

        cred = UserCredentials(user=user, locators=data.get('locators'))

            return Response(status=status.HTTP_401_UNAUTHORIZED)

        cred.save()

    def delete(self, request, *args, **kwargs):

        data = request.data

from __future__ import absolute_import

from django import forms

from mandayejs.applications import get_app_settings

app_settings = get_app_settings()

class FormFactory(forms.Form):

        super(FormFactory, self).__init__(*args, **kwargs)

        fields = getattr(app_settings, 'SITE_LOCATORS', [])

                if field['kind'] == 'string':

                    self.fields[field['name']] = forms.CharField(

                    )

                elif field['kind'] == 'password':

                    self.fields[field['name']] = forms.CharField(

                    )

                else:

                    self.fields[field['name']] = forms.DateField(

                    )

    def to_login_info(self, decrypt=False):

        if decrypt:

            self.decrypt()

from mandayejs.applications import get_app_settings

def exec_phantom(data, script='do_login.js'):

        os.path.join(settings.BASE_DIR, 'mandayejs', script)],

        close_fds=True,

        stdin=subprocess.PIPE,

        phantom.terminate()

    return result

def cookie_builder(headers):

    """Build Cookies from list of headers

    """

    return cookie

def get_logout_info(request):

    """Returns phantomjs logout prerequis

    """

        'value': value.value,

        'domain': domain,

        'path': '/'

    return data

def get_password_field():

    """Return name of the password field

    """

    app_settings = get_app_settings()

    try:

        return field_name[0]

    except (IndexError,):

        return None

def get_login_info(request, credentials):

    """Returns phantomjs login prerequis

    """

    return {

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

        'cookies': [],

        'auth_checker': app_settings.SITE_AUTH_CHECKER,

        'form_submit_element': app_settings.SITE_FORM_SUBMIT_ELEMENT

    }

def get_idp():

    """Return idp

    """

import logging

from django.contrib.auth.models import User

from django.contrib.auth.decorators import login_required

from django.contrib import messages

from django.http import HttpResponseRedirect, HttpResponse

from django.template import RequestContext

from django.views.generic.base import TemplateView

from django.views.decorators.csrf import csrf_exempt

from django.utils.translation import ugettext_lazy as _

from .models import UserCredentials

from mandayejs.mandaye.forms import FormFactory

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

from mandayejs.applications import get_app_settings

from mellon.views import logout as mellon_logout

app_settings = get_app_settings()

logger = logging.getLogger(__name__)

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

    logger.debug("running slo")

    data = get_logout_info(request)

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

        scripts = getattr(app_settings, 'SITE_APP_SCRIPTS', None)

        context['site_scripts'] = scripts

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

        return context

panel = Panel.as_view()

@login_required

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

    try:

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

        logger.debug(user)

        logger.debug(credentials)

    except (UserCredentials.DoesNotExist,):

        return HttpResponseRedirect(resolve_url('associate'))

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

@login_required

@csrf_exempt

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

            credentials.save()

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

        form = FormFactory()

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

@login_required

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

    try:

        c_user.delete()

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

        return HttpResponseRedirect(

    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)

    login_info = get_login_info(request, credentials)

    logger.debug(login_info)

    result = exec_phantom(login_info)

    logger.debug(result)

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

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

    response = HttpResponse(template.render(context))

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

    return response

from django.contrib.auth.models import User

from django.shortcuts import get_object_or_404

from rest_framework import status

from rest_framework.views import APIView

from rest_framework.response import Response

from mandayejs.mandaye.models import UserCredentials

from mandayejs.applications import get_app_settings

    def get(self, request, *args, **kwargs):

        logger = logging.getLogger(__name__)

        app_settings = get_app_settings()

        ws_uri = app_settings.SITE_WS_ENDPOINT['account_details']

        username = kwargs['username']

        login_info = get_login_info(request, credentials)

        logger.debug(login_info)

        result = exec_phantom(login_info)

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

        }

        content = '{"codeConfig":"", "xslPath":"Services/LectorShortAccount.xslt"}'

        url = request.build_absolute_uri(ws_uri)

        data = request_response.json()

        logger.debug(pprint(data))

        return Response(data)

archimed_account_details = ArchimedAccountDetails.as_view()