Produits Entr'ouvert » w.c.s.

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 = 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) and get_request().is_in_backoffice():

                r += htmltext(self.file_validation_status(f, value))

    def file_validation_status(self, field, value):

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

        if status is None:

            return ''

        r = TemplateIO(html=True)

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

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

        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'],

            })

        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):

        r = TemplateIO(html=True)

        r += htmltext('<script>window.top.document.location.reload();</script>')

        return r.getvalue()