Produits Entr'ouvert » w.c.s.

import os

import ConfigParser

@pytest.fixture

def fargo_url(request, pub):

    config = ConfigParser.ConfigParser()

    path = os.path.join(pub.app_dir, 'site-options.cfg')

    url = 'http://fargo.example.net/'

    if os.path.exists(path):

        config.read([path])

    if not config.has_section('options'):

        config.add_section('options')

    config.set('options', 'fargo_url', url)

    with file(path, 'w') as site_option:

        config.write(site_option)

    def fin():

        config = ConfigParser.ConfigParser()

        if os.path.exists(path):

            config.read([path])

            config.remove_option('options', 'fargo_url')

            with file(path, 'w') as site_option:

                config.write(site_option)

    request.addfinalizer(fin)

    return url

import hashlib

from webtest import Upload

import mock

def test_backoffice_file_field_validation(pub, fargo_url):

    user = create_user(pub, is_admin=True)

    user.name_identifiers = ['12345']

    user.store()

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'form title'

    formdef.fields = [fields.FileField(

        id='0', label='1st field', type='file',

        document_type={

            'id': 'justificatif-de-domicile',

            'fargo': True,

            'mimetypes': ['application/pdf'],

            'label': 'PDF files',

        })

    ]

    formdef.store()

    formdef.data_class().wipe()

    upload = Upload('test.pdf', 'foobar', 'application/pdf')

    digest = hashlib.sha256('foobar').hexdigest()

    app = login(get_app(pub))

    resp = app.get('/form-title/')

    resp.forms[0]['f0$file'] = upload

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

    assert 'Check values then click submit.' in resp.body

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

    assert resp.status_int == 302

    with mock.patch('wcs.file_validation.http_get_page') as http_get_page:

        json_response = json.dumps({

            'err': 0,

            'data': {

                'type': 'justificatif-de-domicile',

                'label': 'Justificatif de domicile',

                'creator': 'Jean Bono',

                'created': '2014-01-01T01:01:01',

                'start': '2014-01-01T01:01:01',

                'end': '2014-01-01T01:01:01',

                'metadata': [{

                        'name': 'code_postal',

                        'label': 'Code postal',

                        'value': '13400',

                }],

            },

        })

        http_get_page.return_value = None, 200, json_response, None

        resp = app.get('/backoffice/management/form-title/1/')

        http_get_page.assert_called_once_with('http://fargo.example.net/metadata/12345/c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2/justificatif-de-domicile/')

        assert 'class="value valid"' in resp.body

        assert 'Justificatif de domicile validated by Jean Bono on 2014-01-01T01:01:01' in resp.body

        assert 'Code postal: 13400' in resp.body

        assert 'Valid from 2014-01-01T01:01:01 to 2014-01-01T01:01:01' in resp.body

import json

import mock

def test_file_field_validation(pub, fargo_url):

    user = create_user(pub)

    user.name_identifiers = ['12345']

    user.store()

    FormDef.wipe()

    formdef = FormDef()

    formdef.name = 'form title'

    formdef.fields = [fields.FileField(

        id='0', label='1st field', type='file',

        document_type={

            'id': 'justificatif-de-domicile',

            'fargo': True,

            'mimetypes': ['application/pdf'],

            'label': 'PDF files',

        })

    ]

    formdef.store()

    formdef.data_class().wipe()

    upload = Upload('test.pdf', 'foobar', 'application/pdf')

    digest = hashlib.sha256('foobar').hexdigest()

    app = login(get_app(pub), username='foo', password='foo')

    resp = app.get('/form-title/')

    resp.forms[0]['f0$file'] = upload

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

    assert 'Check values then click submit.' in resp.body

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

    assert resp.status_int == 302

    with mock.patch('wcs.file_validation.http_get_page') as http_get_page:

        json_response = json.dumps({

            'err': 0,

            'data': {

                'type': 'justificatif-de-domicile',

                'label': 'Justificatif de domicile',

                'creator': 'Jean Bono',

                'created': '2014-01-01T01:01:01',

                'start': '2014-01-01T01:01:01',

                'end': '2014-01-01T01:01:01',

                'metadata': [{

                        'name': 'code_postal',

                        'label': 'Code postal',

                        'value': '13400',

                }],

            },

        })

        http_get_page.return_value = None, 200, json_response, None

        resp = resp.follow()

        http_get_page.assert_called_once_with('http://fargo.example.net/metadata/12345/c3ab8ff13720e8ad9047dd39466b3c8974e592c2fa383d4a3960714caef0c4f2/justificatif-de-domicile/')

        http_get_page.reset_mock()

        assert 'The form has been recorded' in resp.body

        assert 'class="value valid"' in resp.body

from mock import patch

from wcs.fields import StringField, FileField

def test_file_field_migration():

    with patch('wcs.file_validation.get_document_types') as get_document_types:

        get_document_types.return_value = {

                'justificatif-de-domicile': {

                    'id': 'justificatif-de-domicile',

                    'label': 'Justificatif de domicile',

                    'fargo': True,

                },

        }

        FormDef.wipe()

        formdef = FormDef()

        formdef.name = 'foo'

        file_type = ['image/*', 'application/pdf,application/vnd.oasis.opendocument.text,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.oasis.opendocument.spreadsheet,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']

        formdef.fields = [FileField(type='file', id='1', label='file')]

        formdef.fields[0].__dict__['file_type'] = file_type

        formdef.store()

        formdef = FormDef.get(1)

        assert 'file_type' not in formdef.fields[0].__dict__

        assert formdef.fields[0].document_type

        assert formdef.fields[0].document_type['id'] == '_legacy'

        assert formdef.fields[0].document_type['mimetypes'] == ['image/*', 'application/pdf,application/vnd.oasis.opendocument.text,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.oasis.opendocument.spreadsheet,application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet']

        assert formdef.fields[0].document_type['label'] == ','.join(file_type)

def test_file_field():

    formdef = FormDef()

    formdef.name = 'foo'

    formdef.fields = [fields.FileField(type='file', id='1', document_type={

        'id': 'justificatif-de-domicile',

        'fargo': True,

        'mimetypes': ['application/pdf,application/vnd.openxmlformats-officedocument.wordprocessingml.document', 'image/*'],

    })]

    assert_xml_import_export_works(formdef, include_id=True)

    assert_xml_import_export_works(formdef)

    assert_json_import_export_works(formdef, include_id=True)

    assert_json_import_export_works(formdef)

import file_validation

    document_type = None

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

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

        self.document_type = self.document_type or {}

    @property

    def file_type(self):

        return (self.document_type or {}).get('mimetypes', [])

        document_types = self.get_document_types()

        cur_dt = self.document_type

        # SingleSelectWidget compare the value and not the keys, so if we want

        # the current value not to be hidden, we must reset it with the corresponding

        # value from settings based on the 'id'

        document_type_id = self.document_type.get('id')

        if document_type_id in document_types \

               and self.document_type != document_types[document_type_id]:

            self.document_type = document_types[document_type_id]

        options = [(None, '---', {})]

        options += [(doc_type, doc_type['label'], key) for key, doc_type in document_types.iteritems()]

        form.add(SingleSelectWidget, 'document_type', title=_('File type suggestion'),

                value=self.document_type, options=options,

                advanced=not(self.document_type))

        return WidgetField.get_admin_attributes(self) + ['document_type',

                                                         'max_file_size']

    def get_document_types(self):

        document_types = {

            '_audio': {

                'label': _('Sound files'),

                'mimetypes': ['audio/*'],

            },

            '_video': {

                'label': _('Video files'),

                'mimetypes': ['video/*'],

            },

            '_image': {

                'label': _('Image files'),

                'mimetypes': ['image/*'],

            }

        }

        # Local document types

        document_types.update(get_cfg('filetypes', {}))

        # Remote documents types

        document_types.update(file_validation.get_document_types())

        for key, document_type in document_types.iteritems():

            document_type['id'] = key

        # add current file type if it does not exist anymore in the settings

        cur_dt = self.document_type

        if cur_dt and cur_dt['id'] not in document_types:

            document_types[cur_dt['id']] = cur_dt

        return document_types

    def migrate(self):

        if 'file_type' in self.__dict__:

            self.document_type = {}

            if self.__dict__['file_type']:

                file_type = self.__dict__['file_type']

                document_types = self.get_document_types()

                for key, value in document_types.iteritems():

                    if self.file_type == value.get('mimetypes'):

                        self.document_type = value.copy()

                        self.document_type['id'] = key

                else:

                    # self.file_type is a combination of file type, we create a

                    # virtual one from them

                    self.document_type = {

                        'id': '_legacy',

                        'label': ','.join(file_type),

                        'mimetypes': file_type,

                    }

            del self.__dict__['file_type']

            return True

        return False

    def export_to_xml(self, charset, include_id=False):

        # convert some sub-fields to strings as export_to_xml() only supports

        # dictionnaries with strings values

        if self.document_type and self.document_type.get('mimetypes'):

            old_value = self.document_type['mimetypes']

            self.document_type['mimetypes'] = '|'.join(self.document_type['mimetypes'])

        result = super(FileField, self).export_to_xml(charset, include_id=include_id)

        if self.document_type and self.document_type.get('mimetypes'):

            self.document_type['mimetypes'] = old_value

        return result

    def init_with_xml(self, element, charset, include_id=False):

        super(FileField, self).init_with_xml(element, charset, include_id=include_id)

        # translate fields flattened to strings

        if self.document_type and self.document_type.get('mimetypes'):

            self.document_type['mimetypes'] = self.document_type['mimetypes'].split('|')

        if self.document_type and self.document_type.get('fargo'):

            self.document_type['fargo'] = self.document_type['fargo'] == 'True'

# w.c.s. - web application for online forms

# Copyright (C) 2005-2010  Entr'ouvert

#

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

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 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 General Public License for more details.

#

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

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

import json

import urlparse

import hashlib

import urllib

from qommon.misc import http_get_page, json_loads

from quixote import get_publisher, get_response

from quixote.html import htmltext

def has_file_validation():

    return get_publisher().get_site_option('fargo_url') is not None

def fargo_get(path):

    fargo_url = get_publisher().get_site_option('fargo_url')

    url = urlparse.urljoin(fargo_url, path)

    response, status, data, auth_header = http_get_page(url)

    if status == 200:

        return json_loads(data)

    return None

def sha256_of_upload(upload):

    return hashlib.sha256(upload.get_content()).hexdigest()

def get_document_types():

    if not has_file_validation():

        return {}

    response = fargo_get('/document-types/')

    publisher = get_publisher()

    if response.get('err') == 0:

        result = {}

        for schema in response['data']:

            d = {

                'id': schema['name'],

                'label': schema['label'],

                'fargo': True,

            }

            if 'mimetypes' in schema:

                d['mimetypes'] = shema['mimetypes']

            result[d['id']] = d

        return result

    return {}

def validation_path(filled, field, upload):

    user = filled.get_user()

    if not user:

        return None

    if not user.name_identifiers:

        return None

    if not field.document_type or not field.document_type.get('fargo'):

        return None

    name_id = user.name_identifiers[0]

    sha_256 = sha256_of_upload(upload)

    document_type = field.document_type['id']

    path = '%s/%s/%s/' % (

        urllib.quote(name_id),

        urllib.quote(sha_256),

        urllib.quote(document_type),

    )

    return path

def validate_upload(filled, field, upload):

    '''Check validation of the uploaded file with Fargo'''

    path = validation_path(filled, field, upload)

    if not path:

        return None

    response = fargo_get('metadata/' + path)

    if response is None:

        return None

    if response['err'] == 1:

        return False

    return response['data']

def get_document_type_label(document_type):

    return get_document_types().get(document_type, {}).get('label')

def validation_link(filled, field, upload):

    '''Compute link to Fargo to validate the given document'''

    path = validation_path(filled, field, upload)

    if not path:

        return ''

    get_response().add_css_include('../js/smoothness/jquery-ui-1.10.0.custom.min.css')

    get_response().add_javascript(['jquery-ui.js', 'jquery.js', 'fargo.js'])

    label = get_document_type_label(field.document_type['id'])

    fargo_url = get_publisher().get_site_option('fargo_url')

    url = urlparse.urljoin(fargo_url, 'validation/' + path)

    next_url = get_publisher().get_frontoffice_url() + '/reload-top'

    url += '?next=%s' % urllib.quote(next_url)

    title = _('Validate as a %s') % label

    return htmltext('<a data-title="%(title)s" data-width="800" '

                    'data-height="500" href="%(url)s">%(title)s</a>') % {

        'title': title,

        'url': url,

    }

import hashlib

import urlparse

from wcs.fields import WidgetField, FileField

from wcs import file_validation

            if isinstance(f, FileField):

                r += htmltext(self.display_file_field(form_url, f, value))

            else: # normal display

                r += htmltext('<div class="value">')

                s = f.get_view_value(value)

                s = s.replace(str('[download]'), str('%sdownload' % form_url))

                r += s

                r += htmltext('</div>')

            r += htmltext('</div>')

    def display_file_field(self, form_url, field, value):

        r = TemplateIO(html=True)

        status = None

        if file_validation.has_file_validation():

            status = file_validation.validate_upload(self.filled, field, value)

            if status is False:

                extra_class = ' invalid'

            elif status is None:

                extra_class = ''

            else:

                extra_class = ' valid'

            r += htmltext('<div class="value%s">' % extra_class)

        else:

            r += htmltext('<div class="value">')

        s = field.get_view_value(value)

        s = s.replace(str('[download]'), str('%sdownload' % form_url))

        r += s

        if status is not None and get_request().is_in_backoffice():

            r += htmltext('<div class="file-validation">')

            if status:

                r += htmltext(_('<p>%s validated by %s on %s</p>')) % (

                    status['label'], status['creator'], status['created'])

                r += htmltext('<ul>')

                for meta in status['metadata']:

                    r += htmltext(_('<li>%(label)s: %(value)s</li>')) % {

                        'label': meta['label'],

                        'value': meta['value']

                    }

                r += htmltext('</ul>')

                r += htmltext('<p>%s</p>') % (_('Valid from %(start)s to %(end)s') % {

                    'start': status['start'],

                    'end': status['end'],

                })

            else:

                r += file_validation.validation_link(self.filled, field, value)

            r += htmltext('</div>')

        r += htmltext('</div>')

        return str(r)

$(function() {

  var iframe = $('<iframe frameborder="0" marginwidth="0" marginheight="0" allowfullscreen></iframe>');

  var dialog = $("<div></div>").append(iframe).appendTo("body").dialog({

        autoOpen: false,

        modal: true,

        resizable: false,

        width: "auto",

        height: "auto",

        close: function () {

            iframe.attr("src", "");

        }

  });

  $('.file-validation a').click(function (e) {

    e.preventDefault();

    var src = $(e.target).attr('href');

    var title = $(e.target).data("title");

    var width = $(e.target).data("width");

    var height = $(e.target).data("height");

    iframe.attr({

        width: parseInt(width),

        height: parseInt(height),

        src: src

    });

    dialog.dialog("option", "title", title);

    dialog.dialog("open");

  });

  $('p.use-file-from-fargo span').click(function(e) {

    e.preventDefault();

    var base_widget = $(this).parents('.file-upload-widget');

    document.fargo_set_token = function (token, title) {

       if (token) {

         $(base_widget).find('.filename').text(title);

         $(base_widget).find('.fileinfo').show();

         $(base_widget).find('input[type=hidden]').val(token);

         $(base_widget).find('input[type=file]').hide();

       }

       document.fargo_close_dialog();

    }

    document.fargo_close_dialog = function () {

       document.fargo_set_token = undefined;

       dialog.dialog('close');

    }

    var src = $(this).data('src');

    var title = $(this).data("title");

    var width = $(this).data("width");

    var height = $(this).data("height");

    iframe.attr({

        width: parseInt(width),

        height: parseInt(height),

        src: src

    });

    dialog.dialog("option", "title", title);

    dialog.dialog("open");

  });

});

            'tryauth', 'auth', 'preview', ('reload-top', 'reload_top')]

    def reload_top(self):

        get_response().filter = {}

        return htmltext('<html><body><script>window.top.document.location.reload();</script></body></html>')