Produits Entr'ouvert » Fargo

                raise api_errors.APIError('NOT_BASE64')

            max_size = self.get_max_size()

            if max_size and len(content) > self.get_max_size():

            data = ContentFile(content, name=name)

        else:

            raise api_errors.APIError('NOT_STRING')

        user = data['user']

        if (Document.objects.used_space(user) + data['file_b64_content'].size

                > settings.FARGO_MAX_DOCUMENT_BOX_SIZE):

        return data

class Migration(migrations.Migration):

    initial = True

from django.conf import settings

from django.core.urlresolvers import reverse

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.utils.text import slugify

from django.utils.http import urlquote

from django.utils.html import format_html

from . import utils, managers

class Origin(models.Model):

    label = models.CharField(_('Label'), max_length=80)

    slug = models.SlugField(_('Slug'))

            self.slug = slugify(self.label)

        return super(Origin, self).save(*args, **kwargs)

        return self.label

class UserDocument(models.Model):

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

    user = models.ForeignKey(

    def filename_encoded(self):

        return urlquote(self.filename, safe='')

        return self.title or self.filename

    def get_download_url(self):

                re.sub('[/\.+-]', '-', self.document.mime_type))

class Validation(models.Model):

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

       the data field contains metadata extracted from the document.

        template = self.document_type_schema.get('display_template', '')

        if template:

            try:

            except KeyError:

                pass

        l = []

                         'label': meta_field['label'],

                         'value': self.data.get(meta_field['varname'], ''),

                     })

    display.short_description = _('description')

    @property

            except UserDocument.DoesNotExist:

                pass

        return self.display()

import logging

from json import dumps

from copy import deepcopy

from django.contrib.auth import get_user_model, REDIRECT_FIELD_NAME

from django.contrib.auth import logout as auth_logout

from django.contrib.auth import views as auth_views

from django.utils.translation import ugettext as _

from django.utils.decorators import method_decorator

from django.conf import settings

        if not 'next' in request.GET:

            return HttpResponseRedirect(resolve_url('mellon_login'))

        return HttpResponseRedirect(resolve_url('mellon_login') + '?next='

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

# 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 logging

import requests

from django.conf import settings

from django.utils.translation import ugettext_lazy as _

from rest_framework.authentication import BasicAuthentication

    def handle(self, redirect_uri, paths, client_id, **options):

        client = OAuth2Client.objects.get(id=client_id)

        for path in paths:

                filename = os.path.basename(path)

                f = ContentFile(file_object.read(), name=filename)

                document = Document.objects.get_by_file(f)

class Migration(migrations.Migration):

    initial = True

from django.core.exceptions import ValidationError

from django.core.validators import URLValidator

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.db.models.query import QuerySet

from django.utils.timezone import now

        raise ValidationError(errors)

class OAuth2Client(models.Model):

    client_name = models.CharField(max_length=255)

    redirect_uris = models.TextField(

    def check_redirect_uri(self, redirect_uri):

        return redirect_uri in self.redirect_uris.strip().split()

        return self.client_name

    class Meta:

import cgi

from django.utils.timezone import now

from django.conf import settings

        return None, 'wrong disposition type: attachment expected'

    if 'filename*' in filename:

        encode, country, name = filename['filename*'].split("'")

        # check accepted charset from rfc 5987

        if encode == 'UTF-8':

        elif encode == 'ISO-8859-1':

        else:

            return None, 'unknown encoding: UTF-8 or ISO-8859-1 allowed'

    elif 'filename' in filename:

import logging

from django.shortcuts import get_object_or_404

from django.utils.translation import ugettext as _

from django.utils.timezone import now

from django.core.files.base import ContentFile

                            content_type='application/octet-stream')

    filename = user_document.filename

    percent_encoded_filename = quote(filename.encode('utf8'), safe='')

    response['Content-Disposition'] = 'attachment; filename="%s"; filename*=UTF-8\'\'%s' % (ascii_filename,

                                                                                            percent_encoded_filename)

                                         'local_settings.py'))

if os.path.exists(local_settings_file):

from django.utils.http import urlencode

def make_url(__url, **kwargs):

    request = kwargs.pop('request', None)

    parsed = urlparse.urlparse(__url)

    query = urlparse.parse_qs(parsed.query)

        if value is not None:

            query[key] = value

    parsed = parsed[:4] + (urlencode(query),) + parsed[5:]

import logging

import pytest

import django_webtest

@pytest.fixture

def user_doc(document, john_doe):

            == set(['origin', 'file_b64_content']))

    data.update({

        'origin': 'wcs',

        'file_name': 'monfichier.pdf',

    })

    response = app.post_json(url, params=data, status=200)

    assert models.UserDocument.objects.get().user == john_doe

    assert models.UserDocument.objects.get().deletable_by_user == True

    assert models.Document.objects.count() == 1

    assert (models.UserDocument.objects.get().document

            == models.Document.objects.get())

    assert (models.UserDocument.objects.get().origin

            == models.Origin.objects.get())

    data['deletable_by_user'] = False

    response = app.post_json(url, params=data, status=200)

    assert response.json['result'] == 1

    assert models.UserDocument.objects.count() == 2 # new document

    assert models.UserDocument.objects.filter(deletable_by_user=False).count() == 1

    data['deletable_by_user'] = True

    response = app.post_json(url, params=data, status=200)

    assert response.json['result'] == 1

    assert models.UserDocument.objects.filter(deletable_by_user=True).count() == 2

    # same document

    data['deletable_by_user'] = True

    response = app.post_json(url, params=data, status=400)

    assert response.json['result'] == 0

    data = {

        'user_email': john_doe.email,

        'origin': 'wcs',

        'file_name': 'monfichier.pdf',

    }

    response = app.post_json(url, params=data, status=400)

    assert response.json['result'] == 0

    assert response.json['errors']['file_b64_content'][0]['code'] == 'too-big'

def test_push_document_max_document_box_size(app, private_settings, admin_user, john_doe):

    data = {

        'user_email': john_doe.email,

        'origin': 'wcs',

        'file_name': 'monfichier.pdf',

    }

    response = app.post_json(url, params=data, status=200)

    assert models.Document.objects.count() == 1

    response = app.post_json(url, params=data, status=400)

    assert response.json['result'] == 0

    assert response.json['errors']['__all__'][0]['code'] == 'box-is-full'

def test_push_document_slashed_name(app, admin_user, john_doe):

    data = {

        'user_email': john_doe.email,

        'origin': 'wcs',

        'file_name': 'monfichier 18/06/2017.pdf',

    }

    response = app.post_json(url, params=data, status=200)

    client = OAuth2Client.objects.create(client_name='c', redirect_uris='')

    UserDocument.objects.create(user=john_doe,

                                document=foo,

                                filename='foo.txt',

    return app

def test_document_delete(app):

    doc = Document.objects.get_by_file(f)

    file_path = doc.content.path

    assert os.path.isfile(file_path)

import os

import json

import mock

import pytest

from django.core.urlresolvers import reverse

from django.core.management import call_command

from fargo.oauth2.models import OAuth2Client, OAuth2Authorize, OAuth2TempFile

from fargo.fargo.models import UserDocument

    }

    # test missing redirect_uri

    resp = app.get(url, params={}, status=400)

    # test missing client id

    params['redirect_uri'] = 'https://toto.example.com'

    resp = app.get(url, params=params, status=302)

    assert resp.status_code == 200

    assert len(resp.forms[0]['document'].options) == 2

    options = resp.forms[0]['document'].options

    resp.forms[0]['document'].select(options[1][0])

    resp = resp.forms[0].submit()

    assert 'Content-disposition' in resp.headers

    content_disposition = resp.content_disposition.replace(' ', '').split(';')

    assert content_disposition[0] == 'attachment'

def test_put_document(app, john_doe, oauth2_client):

    app.authorization = ('Basic', (str(oauth2_client.client_id), str(oauth2_client.client_secret)))

    resp = app.post(url, params=data, status=400)

    headers = {

        'Content-disposition': 'attachment; filename="%s"; filename*=UTF-8\'\'%s' % (filename, percent_encode_filename)

    }

    assert OAuth2TempFile.objects.count() == 1

    assert UserDocument.objects.count() == 1

    assert OAuth2TempFile.objects.get().document == UserDocument.objects.get().document

def test_confirm_put_document_file_exception(app, oauth2_client, john_doe, user_doc):

    url = reverse('oauth2-put-document-authorize', kwargs={'pk': 'fakemofo'})

    url += '?%s' % urlencode({'redirect_uri': 'https://example.com'})

    resp = app.get(url)

    url = reverse('oauth2-put-document-authorize', kwargs={'pk': oauth_tmp_file.pk})

    url += '?%s' % urlencode({'redirect_uri': 'https://example.com'})

    resp = app.get(url)

@mock.patch('fargo.oauth2.authentication.requests.post')

    params['redirect_uri'] = 'https://example.com'

    resp = app.get(url, params=params)

    options = resp.forms[0]['document'].options

    resp.forms[0]['document'].select(options[1][0])

    resp = resp.forms[0].submit()

    auth = OAuth2Authorize.objects.filter(user_document__user=john_doe)[0]

from webtest import Upload

import pytest

from django.core.urlresolvers import reverse

try:

    import magic

    login(app, user=john_doe)

    response1 = app.get('/')

    form = response1.form

    response2 = form.submit().follow()

    if magic is not None:

        assert UserDocument.objects.get(filename='monfichier.pdf').document.mime_type == 'text/plain'

    UserDocument.objects.all().delete()

    response1 = app.get('/')

    form = response1.form

    response2 = form.submit().follow()

    if magic is not None:

        assert UserDocument.objects.get(filename='monfichier.pdf').document.mime_type == 'application/pdf'

def test_upload_max_size(app, private_settings, john_doe):

    login(app, user=john_doe)

    response1 = app.get('/')

    form = response1.form

    response2 = form.submit()

    assert response2.status_code == 200

def test_upload_max_document_box_size(app, private_settings, john_doe):

    login(app, user=john_doe)

    response1 = app.get('/')

    form = response1.form

    response2 = form.submit().follow()

    response1 = app.get('/')

    form = response1.forms['send-file']

    response2 = form.submit()

    assert response2.status_code == 200

def test_pick(app, private_settings, john_doe, user_doc):

[tox]

toxworkdir = {env:TMPDIR:/tmp}/tox-{env:USER}/fargo/

[testenv]

usedevelop = True

        django-webtest<1.9.3

        WebTest

        djangorestframework>=3.3,<3.4

commands =

        py.test {env:COVERAGE:} {posargs:--random --junit-xml=junit-{envname}.xml tests}

        coverage: mv coverage.xml coverage-{envname}.xml