Produits Entr'ouvert » Fargo

from django.contrib.auth import get_user_model

class ValidationMixin(object):

    fields = [ 'user',

               'filename',

               'size',

               'document_type',

               'start',

               'end',

               'data' ]

    readonly_fields = ['user', 'filename', 'size']

    def user(self, validation):

        user = validation.user_document.user

        return user.get_full_name().strip() or user.email or user.username

    def filename(self, validation):

        return validation.user_document.filename

    def size(self, validation):

        return validation.user_document.document.content.size

class ValidationInline(ValidationMixin, admin.TabularInline):

    model = models.Validation

class UserDocumentAdmin(admin.ModelAdmin):

    list_display = ['user', 'filename', 'created']

    readonly_fields = ['created']

    inlines = [ValidationInline]

    list_display = ['content_hash', 'users']

    def users(self, instance):

        User = get_user_model()

        qs = User.objects.filter(user_document_set__document=instance)

        return u', '.join(unicode(u) for u in qs)

class ValidationAdmin(ValidationMixin, admin.ModelAdmin):

    list_display = ['user', 'filename', 'size', 'document_type', 'start', 'end']

admin.site.register(models.UserDocument, UserDocumentAdmin)

admin.site.register(models.Validation, ValidationAdmin)

from django import forms

from django.utils.translation import ugettext_lazy as _

from django.conf import settings

from . import models, utils

class UploadForm(forms.ModelForm):

    content = forms.FileField(

        label=_('file'), max_length=512)

        self.instance.filename = self.files['content'].name[:512]

        self.instance.document = models.Document.objects.get_by_file(

            self.files['content'])

        model = models.UserDocument

        fields = []

class ValidationForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):

        self.creator = kwargs.pop('user').get_full_name()

        self.user_document = kwargs.pop('user_document')

        self.document_type = kwargs.pop('document_type')

        self.schema = utils.get_document_type_schema(settings, self.document_type)

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

        for fields in self.schema['metadata']:

            name = fields['name']

            label = fields['label']

            required = fields.get('required', True)

            self.fields[name] = forms.CharField(required=required, label=label)

    def save(self, commit=True):

        assert commit, 'not committing is unsupported'

        data = {}

        for fields in self.schema['metadata']:

            name = fields['name']

            value = self.cleaned_data.get(name)

            if value:

                data[fields['name']] = value

        validation, created = models.Validation.objects.get_or_create(

            user_document=self.user_document,

            document_type=self.document_type,

            defaults={

                'data': data,

                'creator': self.creator,

                'start': self.cleaned_data['start'],

                'end': self.cleaned_data['end'],

            })

        if not created:

            validation.data = data

            validation.creator = self.creator

            validation.start = self.cleaned_data['start']

            validation.end = self.cleaned_data['end']

            validation.save()

        return validation

    class Meta:

        model = models.Validation

        fields = ['start', 'end']

from django.db import models

from . import utils

class DocumentManager(models.Manager):

    def clean(self):

        '''Remove all documents not linked to an user'''

        qs = self.filter(user_documents__isnull=True)

        for document in qs:

            qs.content.delete(False)

        qs.delete()

    def get_by_file(self, f):

        '''Get document with the same SHA-256 hash as the passde Django file

           like object.

        '''

        file_hash = utils.sha256_of_file(f)

        try:

            o = self.get(content_hash=file_hash)

        except self.model.DoesNotExist:

            o = self.model()

            o.content.save(file_hash, f)

        return o

# -*- coding: utf-8 -*-

from __future__ import unicode_literals

from django.db import models, migrations

import jsonfield.fields

from django.utils.timezone import utc

import datetime

from django.conf import settings

def clear_document(apps, schema_editor):

    Document = apps.get_model('fargo', 'Document')

    Document.objects.all().delete()

def noop(apps, schema_editor):

    pass

class Migration(migrations.Migration):

    dependencies = [

        migrations.swappable_dependency(settings.AUTH_USER_MODEL),

        ('fargo', '0002_auto_20150818_2117'),

    ]

    operations = [

        migrations.RunPython(clear_document, noop),

        migrations.CreateModel(

            name='UserDocument',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('filename', models.CharField(max_length=512, verbose_name='filename')),

                ('created', models.DateTimeField(auto_now_add=True, verbose_name='creation date')),

            ],

            options={

                'ordering': ('-created', 'user'),

                'verbose_name': 'user document',

                'verbose_name_plural': 'user documents',

            },

        ),

        migrations.CreateModel(

            name='Validation',

            fields=[

                ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),

                ('document_type', models.CharField(max_length=256, verbose_name='document type')),

                ('data', jsonfield.fields.JSONField(null=True, verbose_name='data')),

                ('start', models.DateField(verbose_name='start date')),

                ('end', models.DateField(verbose_name='end date')),

                ('creator', models.CharField(max_length=256, verbose_name='creator')),

                ('created', models.DateTimeField(auto_now_add=True, verbose_name='creation date')),

                ('user_document', models.ForeignKey(verbose_name='user document', to='fargo.UserDocument')),

            ],

        ),

        migrations.AlterModelOptions(

            name='document',

            options={'ordering': ('content_hash',), 'verbose_name': 'document', 'verbose_name_plural': 'documents'},

        ),

        migrations.RenameField(

            model_name='document',

            old_name='document_file',

            new_name='content',

        ),

        migrations.RemoveField(

            model_name='document',

            name='creation',

        ),

        migrations.RemoveField(

            model_name='document',

            name='document_filename',

        ),

        migrations.RemoveField(

            model_name='document',

            name='id',

        ),

        migrations.RemoveField(

            model_name='document',

            name='user',

        ),

        migrations.AddField(

            model_name='document',

            name='content_hash',

            field=models.CharField(default=datetime.datetime(2015, 9, 24, 10, 56, 54, 873399, tzinfo=utc), max_length=128, serialize=False, verbose_name='content hash', primary_key=True),

            preserve_default=False,

        ),

        migrations.AddField(

            model_name='userdocument',

            name='document',

            field=models.ForeignKey(related_name='user_documents', verbose_name='document', to='fargo.Document'),

        ),

        migrations.AddField(

            model_name='userdocument',

            name='user',

            field=models.ForeignKey(verbose_name='user', to=settings.AUTH_USER_MODEL),

        ),

        migrations.RunPython(noop, clear_document),

    ]

from jsonfield import JSONField

from . import utils, managers

class UserDocument(models.Model):

    '''Document uploaded by an user or an agent'''

        settings.AUTH_USER_MODEL,

        verbose_name=_('user'))

    document = models.ForeignKey(

        'Document',

        related_name='user_documents',

        verbose_name=_('document'))

    filename = models.CharField(

        verbose_name=_('filename'),

        max_length=512)

    created = models.DateTimeField(

        verbose_name=_('creation date'),

        auto_now_add=True)

    class Meta:

        verbose_name = _('user document')

        verbose_name_plural = _('user documents')

        ordering = ('-created', 'user')

class Validation(models.Model):

    '''Validation of a document as special kind for an user,

       the data field contains metadata extracted from the document.

    '''

    user_document = models.ForeignKey('UserDocument',

                                      verbose_name=_('user document'))

    document_type = models.CharField(max_length=256, verbose_name=_('document type'))

    data = JSONField(null=True, verbose_name=_('data'))

    start = models.DateField(verbose_name=_('start date'))

    end = models.DateField(verbose_name=_('end date'))

    creator = models.CharField(max_length=256, verbose_name=_('creator'))

    created = models.DateTimeField(verbose_name=_('creation date'),

                                   auto_now_add=True)

class Document(models.Model):

    '''Content indexed documents'''

    content_hash = models.CharField(

        primary_key=True,

        max_length=128,

        verbose_name=_('content hash'))

    content = models.FileField(

        verbose_name=_('file'))

    objects = managers.DocumentManager()

    def save(self, *args, **kwargs):

        '''Create content_hash if new'''

        if not self.content_hash:

            self.content_hash = utils.sha256_of_file(self.content)

        super(Document, self).save(*args, **kwargs)

        ordering = ('content_hash',)

from django.utils.translation import ugettext_lazy as _

    '''Display the list of documents of the user'''

    filename = tables.Column(verbose_name=_('filename').title())

    size = tables.Column(accessor='document.content.size',

                         verbose_name=_('size').title())

    created = tables.DateTimeColumn(verbose_name=_('creation date').title())

        fields = ('filename', 'size', 'created')

        empty_text = _('You currently have no documents')

import hashlib

from django.utils.timezone import utc

def to_isodate(dt):

    return dt.astimezone(utc).isoformat('T').split('.')[0] + 'Z'

def get_document_type_schema(settings, document_type):

    for schema in settings.FARGO_DOCUMENT_TYPES:

        if schema.get('name') == document_type:

            return schema

def sha256_of_file(f):

    '''Compute SHA-256 hash of Django File object'''

    hasher = hashlib.sha256()

    for chunk in f.chunks():

        hasher.update(chunk)

    return hasher.hexdigest()

from django.http import (HttpResponse, HttpResponseRedirect,

                         HttpResponseForbidden, Http404)

from django.conf import settings

from . import models, forms, tables, utils

    model = models.UserDocument

        kwargs['instance'] = models.UserDocument(

            user=self.request.user)

        self.logger.info(u'user uploaded file %s (sha256=%s)',

                         self.object.filename,

                         self.object.document.content_hash)

        return models.UserDocument.objects \

            .filter(user=self.request.user) \

            .select_related('document', 'user')

        'per_page': 5,

    model = models.UserDocument

        messages.info(request, _('File %s deleted') % self.object.filename)

        self.logger.info('user deleted file %r(%s)', self.object.filename,

                         self.object.pk)

class Pick(Documents, Logger, View):

        user_document = get_object_or_404(self.get_queryset(), pk=pk,

                                          user=request.user)

        token = signing.dumps(user_document.pk)

        url = reverse('remote_download',

                      kwargs={'filename': user_document.filename})

        self.logger.info(u'user picked file %s sha256 %s returned to %s',

                         user_document.filename,

                         user_document.document.content_hash, pick)

class Download(Documents, View):

        user_document = get_object_or_404(self.get_queryset(), pk=pk,

                                          user=self.request.user)

        return self.return_user_document(user_document)

    def return_user_document(self, user_document):

        response = HttpResponse(user_document.document.content.chunks(),

                                content_type='application/octet-stream')

        user_document = get_object_or_404(models.UserDocument, pk=pk)

        return self.return_user_document(user_document)

        for user_document in self.get_queryset():

            url = reverse('download',

                          kwargs={'pk': user_document.pk,

                                  'filename': user_document.filename})

                'filename': user_document.filename,

                        dumps(self.get_data(request)))

                                content_type='application/json')

class ChooseDocumentKind(TemplateView):

    template_name = 'fargo/choose_document_kind.html'

    def get_context_data(self, **kwargs):

        ctx = super(ChooseDocumentKind, self).get_context_data(**kwargs)

        ctx['document_kinds'] = settings.FARGO_DOCUMENT_KINDS

        return ctx

class Metadata(View):

    def get(self, request, username, content_hash, document_type):

        schema = utils.get_document_type_schema(settings, document_type)

        if not schema:

            raise Http404

        try:

            user_document = models.UserDocument.objects.get(

                user__username=username[:30],

                document__content_hash=content_hash)

        except models.UserDocument.DoesNotExist:

            raise Http404

        try:

            validation = models.Validation.objects.get(

                user_document=user_document,

                document_type=document_type)

        except models.Validation.DoesNotExist:

            data = {'err': 1, 'data': 'validation-not-found'}

        else:

            metadata = []

            data = {

                'err': 0,

                'data': {

                    'type': schema['name'],

                    'label': schema['label'],

                    'creator': validation.creator,

                    'created': utils.to_isodate(validation.created),

                    'start': validation.start.isoformat(),

                    'end': validation.end.isoformat(),

                    'metadata': metadata,

                },

            }

            for field in schema.get('metadata', []):

                value = validation.data.get(field['name'])

                if value:

                    metadata.append({

                        'value': value,

                        'name': field['name'],

                        'label': field['label'],

                    })

        return HttpResponse(dumps(data), content_type='application/json')

class Validation(CreateView):

    form_class = forms.ValidationForm

    template_name = 'fargo/validation.html'

    def dispatch(self, request, username, content_hash, document_type):

        self.user_document = get_object_or_404(

            models.UserDocument, user__username=username[:30],

            document__content_hash=content_hash)

        if not utils.get_document_type_schema(settings, document_type):

            raise Http404

        self.document_type = document_type

        return super(Validation, self).dispatch(request,

                                                username=username,

                                                content_hash=content_hash,

                                                document_type=document_type)

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

        if 'cancel' in request.POST:

            return HttpResponseRedirect(self.get_success_url())

        return super(Validation, self).post(request, *args, **kwargs)

    def get_form_kwargs(self, **kwargs):

        kwargs = super(Validation, self).get_form_kwargs(**kwargs)

        try:

            validation = models.Validation.objects.get(

                user_document=self.user_document,

                document_type=self.document_type)

            kwargs['instance'] = validation

            initials = kwargs['initial'] = kwargs.get('initial', {})

            for key, value in validation.data.iteritems():

                initials[key] = value

        except models.Validation.DoesNotExist:

            pass

        kwargs['user'] = self.request.user

        kwargs['user_document'] = self.user_document

        kwargs['document_type'] = self.document_type

        return kwargs

    def get_success_url(self):

        return self.request.GET.get(REDIRECT_FIELD_NAME) \

                or reverse(settings.LOGIN_REDIRECT_URL)

class DocumentTypes(View):

    def get(self, request):

        data = {

            'err': 0,

            'data': settings.FARGO_DOCUMENT_TYPES,

        }

        return HttpResponse(dumps(data), content_type='application/json')

home = login_required(Homepage.as_view())

document = login_required(Document.as_view())

download = login_required(Download.as_view())

upload = login_required(Upload.as_view())

delete = login_required(Delete.as_view())

pick = login_required(Pick.as_view())

jsonp = login_required(JSONP.as_view())

json = login_required(JSON.as_view())

metadata = Metadata.as_view()

validation = login_required(Validation.as_view())

document_types = DocumentTypes.as_view()

# -*- coding: utf-8 -*-

FARGO_DOCUMENT_TYPES = [

    {

        'name': 'justificatif-de-domicile',

        'label': 'Justificatif de domicile',

        'metadata': [

            {'label': u'Numéro', 'name': 'numero'},

            {'label': u'Rue', 'name': 'rue'},

            {'label': u'Code postal', 'name': 'code-postal'},

            {'label': u'Ville', 'name': 'ville'},

        ]

    }

]

LOGIN_REDIRECT_URL = 'home'

{% load gadjo staticfiles %}<!DOCTYPE html>

<html>

  <head>

    <script src="{% xstatic 'jquery' 'jquery.min.js' %}"></script>

    <link rel="stylesheet" href="{% static "fargo/css/style.css" %}" />

    {% block extra_head %}

    {% endblock %}

  </head>

  <body {% block bodyargs %}{% endblock %}>

    {% block content %}

    {% endblock %}

  </body>

</html>

{% extends "fargo/base_iframe.html" %}

{% load render_table from django_tables2 %}

{% load i18n %}

{% block bodyargs %}class="fargo-popup fargo-pick-popup"{% endblock %}

{% block content %}

      $(function() {

        $('table').on('click', 'tbody tr', function() {

          $(this).find('form').submit();

        });

      });

{% endblock %}

   <tr><td span="3"><a href="{% url "validation" username=user.username content_hash=row.record.document.content_hash document_type="justificatif-de-domicile" %}">Valider</a></td></tr>

{% extends "fargo/base_iframe.html" %}

{% load i18n gadjo %}

{% block extra_head %}

  <link rel="stylesheet" type="text/css" media="all"

              href="{% xstatic 'jquery-ui' 'themes/smoothness/jquery-ui.min.css' %}"/>

  <script src="{% xstatic 'jquery-ui' 'jquery-ui.min.js' %}"></script>

{% endblock %}

{% block bodyargs %}class="fargo-popup fargo-pick-popup"{% endblock %}

{% block content %}

    <form method="post" enctype="multipart/form-data">

      {% csrf_token %}

      {{ form.as_p  }}

      <input type="submit" name="submit" value="{% trans "Validate" %}">

      <input type="submit" name="cancel" value="{% trans "Cancel" %}">

    </form>

    <script>

  $('#id_start, #id_end').datepicker();

    </script>

{% endblock %}

from .fargo.views import (home, jsonp, json, document, download, pick, delete,

                          upload, remote_download, login, logout, pick_list,

                          metadata, validation, document_types)

urlpatterns = patterns(

    '',

    url(r'^(?P<pk>\d+)/download/(?P<filename>[^/]*)$', download,

        name='download'),

    url(r'^remote-download/(?P<filename>[^/]*)$', remote_download,

        name='remote_download'),

    url(r'^metadata/(?P<username>[^/]*)/(?P<content_hash>[^/]*)/(?P<document_type>[^/]*)/$',

        metadata, name='metadata'),

    url(r'^validation/(?P<username>[^/]*)/(?P<content_hash>[^/]*)/(?P<document_type>[^/]*)/$',

        validation, name='validation'),

    url(r'^document-types/$', document_types, name='document_types'),

    urlpatterns += patterns('',

                            url(r'^accounts/mellon/', include('mellon.urls')))

        'django-jsonfield >= 0.9.3',