Produits Entr'ouvert » w.c.s.

import file_validation

    document_type = None

    @property

    def file_type(self):

        if self.document_type:

            return self.document_type.get('mimetypes')

        document_types, value = self.get_document_types_and_value()

        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=value, options=options, advanced=not(self.document_type))

        l = WidgetField.get_admin_attributes(self) + ['document_type',

        return l

    def get_default_document_types(self):

        return {

            '_audio': {

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

                'mimetypes': 'audio/*', 

            },

            '_video': {

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

                'mimetypes': 'video/*',

            },

            '_image': {

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

                'mimetypes': 'image/*',

            }

        }

    def get_document_types_and_value(self):

        document_types = self.get_default_document_types()

        # Local document types

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

        # Remote documents types

        document_types.update(file_validation.get_document_types())

        value = self.document_type

        if isinstance(value, str):

            value = None

        for key, document_type in document_types.iteritems():

            document_type['id'] = key

            # normalize current value against known file types

            if value and value['id'] == key:

                value = document_type

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

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

            document_types[value['id']] = value

        return document_types, value

    def migrate(self):

        if 'file_type' in self.__dict__:

            for key, value in self.get_default_document_types().iteritems():

                if self.file_type == value['mimetypes']:

                    self.document_type = value.copy()

                    self.document_type['id'] = key

            del self.__dict__['file_type']

            return True

        return False

import json

import urlparse

import hashlib

import urllib

from qommon.misc import http_get_page

from quixote import get_publisher, get_response

from quixote.html import htmltext

def json_encode_helper(d, charset):

    '''Encode a JSON structure into local charset'''

    if isinstance(d, unicode):

        return d.encode(charset)

    elif isinstance(d, list):

        return [json_encode_helper(e, charset) for e in d]

    elif isinstance(d, dict):

        new_d = {}

        for k, v in d.iteritems():

            new_d[json_encode_helper(k, charset)] = json_encode_helper(v, charset)

        return new_d

    else:

        return d

def json_encode(d, charset=None):

    return json_encode_helper(d, charset or get_publisher().site_charset)

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_encode(json.loads(data))

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

    if not user.name_identifiers:

        return

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

        return

    name_id = user.name_identifiers[0]

    sha_256 = sha256_of_upload(upload)

    document_type = field.document_type

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

        urllib.quote(name_id),

        urllib.quote(sha_256),

        urllib.quote(document_type),

    )

    return path

def validate_upload(filled, field, upload):

    path = validation_path(filled, field, upload)

    if not path:

        return

    response = fargo_get('metadata/' + path)

    if response is None:

        return

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

    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)

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

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

    url += '?next=%s' % urllib.quote(get_publisher().get_frontoffice_url() + '/reload-top')

    return htmltext(_('<a data-title="Validate as a %(document_type_label)s" data-width="800" data-height="500" href="%(url)s">Validate as a %(document_type_label)s</a>')) % {

        'url': url,

        'document_type_label': label,

    }

import hashlib

import urlparse

from wcs.fields import WidgetField, FileField

from wcs import file_validation

            if isinstance(f, FileField):

                s = self.file_validation_status(f, value)

                if s:

                    r += htmltext(str(s))

    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">')

        if status is False:

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

        else:

            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('</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()