dataobject.py 10.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# copyright 2016 LOGILAB S.A. (Paris, FRANCE), all rights reserved.
# contact http://www.logilab.fr -- mailto:contact@logilab.fr
#
# This program is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 2.1 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 Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.
"""cubicweb-seda views for data objects (BinaryDataObject / PhysicalDataObject)"""

18
19
import json

20
21
from logilab.mtconverter import xml_escape

22
from cubicweb import tags
23
24
from cubicweb.predicates import match_form_params, is_instance
from cubicweb.web.views import uicfg, tabs
25
26
27

from cubes.relationwidget import views as rwdg

28
from cubes.seda.xsd2yams import RDEF_CONSTRAINTS
29
from cubes.seda.views import rtags_from_xsd_element, add_subobject_link, viewlib
30

31
32
_ = unicode

33
34
35
pvs = uicfg.primaryview_section
rec = uicfg.reledit_ctrl
afs = uicfg.autoform_section
36
37
affk = uicfg.autoform_field_kwargs

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

def _container_eid(entity):
    """Attempt to return the container eid from the entity, handling case where entity is being
    created and container information will be find through linkto or parent form (partially
    supported)
    """
    if entity.has_eid():
        # entity is expected to be a contained entity, not the container itself
        container = entity.cw_adapt_to('IContained').container
    else:
        # but parent entity, retrieved through linkto, may be the container itself or a
        # contained entity
        try:
            parent_eid = int(entity._cw.form['__linkto'].split(':')[1])
        except KeyError:
            # ajax created form
            try:
                parent_eid = int(json.loads(entity._cw.form['arg'][0]))
            except ValueError:
                # unable to get parent eid for now :()
                return None
        parent = entity._cw.entity_from_eid(parent_eid)
        icontainer = parent.cw_adapt_to('IContainer')
        if icontainer is None:
            container = parent.cw_adapt_to('IContained').container
        else:
            container = icontainer.container
    return container.eid


class ContainedRelationFacetWidget(rwdg.RelationFacetWidget):

    def trigger_search_url(self, entity, url_params):
        """Overriden to add information about who is the container

        This information will be used later for proper vocabulary computation.
        """
        # first retrieve the container entity
        container_eid = _container_eid(entity)
        # and put it as an extra url param
        if container_eid is not None:
            url_params['container'] = unicode(container_eid)
        return super(ContainedRelationFacetWidget, self).trigger_search_url(entity, url_params)


class ContainedSearchForRelatedEntitiesView(rwdg.SearchForRelatedEntitiesView):
    __select__ = rwdg.SearchForRelatedEntitiesView.__select__ & match_form_params('container')

86
87
    has_creation_form = False

88
89
90
91
92
93
94
95
96
97
98
99
100
101
    def linkable_rset(self):
        """Return rset of entities to be displayed as possible values for the
        edited relation. You may want to override this.
        """
        entity = self.compute_entity()
        rtype, tetype, role = self.rdef
        rdef = entity.e_schema.rdef(rtype, role, tetype)
        assert len(rdef.constraints) == 1 and 'S container AT' in rdef.constraints[0].expression
        baserql = rdef.constraints[0].expression
        baserql.replace('S container AT', 'AT eid %(at)s')
        rql = 'Any O WHERE ' + baserql
        return self._cw.execute(rql, {'at': int(self._cw.form['container'])})


102
103
# hide some relation from autoform because of limitation of _container_eid
afs.tag_object_of(('*', 'seda_compressed', 'SEDABinaryDataObject'), 'main', 'hidden')
104
pvs.tag_object_of(('*', 'seda_compressed', 'SEDABinaryDataObject'), 'attributes')
105
106
107
108
109
110
111
112
113
rec.tag_object_of(('*', 'seda_compressed', 'SEDABinaryDataObject'),
                  {'rvid': 'seda.reledit.complexlink',
                   'novalue_label': _('<unauthorized>')})

rec.tag_subject_of(('SEDABinaryDataObject', 'seda_alt_binary_data_object_attachment', '*'),
                   {'rvid': 'seda.reledit.alternative',
                    'novalue_label': _('<unauthorized>')})

for etype in ('SEDABinaryDataObject', 'SEDAPhysicalDataObject'):
114
115
    afs.tag_object_of(('*', 'seda_data_object_version_from', etype), 'main', 'hidden')
    pvs.tag_object_of(('*', 'seda_data_object_version_from', etype), 'attributes')
116
117
118
119
120
    rec.tag_object_of(('*', 'seda_data_object_version_from', etype),
                      {'rvid': 'seda.reledit.complexlink',
                       'novalue_label': _('<unauthorized>')})


121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
def uri_cardinality_vocabulary(form, field):
    req = form._cw
    try:
        # inlined creation form
        parent_type = json.loads(req.form['arg'][1])
    except KeyError:
        # edition through reledit
        parent_eid = req.form['eid']
        parent_type = req.describe(int(parent_eid))[0]
    if parent_type in ('SEDABinaryDataObject', 'SEDAAltBinaryDataObjectAttachment'):
        return [u'1']
    return [u'0..1', u'1']

affk.tag_attribute(('SEDAUri', 'user_cardinality'),
                   {'choices': uri_cardinality_vocabulary})


138
139
140
141
142
143
144
145
146
for key, rql_expr in RDEF_CONSTRAINTS.items():
    if 'S container AT' in rql_expr:
        try:
            etype, rtype = key
        except ValueError:
            etype = '*'
            rtype = key
        affk.tag_subject_of((etype, rtype, '*'),
                            {'widget': ContainedRelationFacetWidget(dialog_options={'width': 800})})
147
148
149
150
151
152


class BinaryDataObjectTabbedPrimaryView(tabs.TabbedPrimaryView):
    __select__ = tabs.TabbedPrimaryView.__select__ & is_instance('SEDABinaryDataObject')
    tabs = [
        'main_tab',
153
        _('seda_bdo_format_identification'),
154
        _('seda_bdo_file_information'),
155
        _('seda_do_relations'),
156
157
158
    ]


159
160
161
162
163
164
165
166
class BinaryDataObjectFormatIdentificationTab(tabs.PrimaryTab):
    """Display format identification information of a binary data object"""
    __regid__ = 'seda_bdo_format_identification'
    __select__ = tabs.PrimaryTab.__select__ & is_instance('SEDABinaryDataObject')

    rsection, display_ctrl = rtags_from_xsd_element('SEDABinaryDataObject', 'FormatIdentification')


167
168
169
170
171
172
173
174
class BinaryDataObjectFileInfoTab(tabs.PrimaryTab):
    """Display file information of a binary data object"""
    __regid__ = 'seda_bdo_file_information'
    __select__ = tabs.PrimaryTab.__select__ & is_instance('SEDABinaryDataObject')

    rsection, display_ctrl = rtags_from_xsd_element('SEDABinaryDataObject', 'FileInfo')


175
176
177
178
class PhysicalDataObjectTabbedPrimaryView(tabs.TabbedPrimaryView):
    __select__ = tabs.TabbedPrimaryView.__select__ & is_instance('SEDAPhysicalDataObject')
    tabs = [
        'main_tab',
179
        _('seda_pdo_dimensions'),
180
        _('seda_do_relations'),
181
    ]
182
183


184
185
186
187
188
189
190
191
class PhysicalDataObjectDimensionsTab(tabs.PrimaryTab):
    """Display physical dimensions of a physical data object"""
    __regid__ = 'seda_pdo_dimensions'
    __select__ = tabs.PrimaryTab.__select__ & is_instance('SEDAPhysicalDataObject')

    rsection, display_ctrl = rtags_from_xsd_element('SEDAPhysicalDataObject', 'PhysicalDimensions')


192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
class DataObjectRelationssTab(tabs.PrimaryTab):
    """Display relations of a binary or physical data object"""
    __regid__ = 'seda_do_relations'
    __select__ = tabs.PrimaryTab.__select__ & is_instance('SEDABinaryDataObject',
                                                          'SEDAPhysicalDataObject')

    def entity_call(self, entity):
        rschema = self._cw.vreg.schema.rschema('seda_relationship')
        if rschema.has_perm(self._cw, 'add', toeid=entity.eid):
            urlparams = {'__redirectparams': 'tab=' + self.__regid__}
            self.w(add_subobject_link(entity, 'seda_relationship', 'object', urlparams,
                                      msg=self._cw._('add a SEDARelationship'),
                                      klass='btn btn-success pull-right'))
            self.w(tags.div(klass='clearfix'))
        rset = entity.related('seda_relationship', 'object')
        if rset:
            self._cw.view('list', rset=rset, parent=entity, w=self.w, tabid=self.__regid__,
                          subvid='seda.listitem')


class RelationshipBusinessValueLinkEntityView(viewlib.BusinessValueLinkEntityView):
    __select__ = viewlib.BusinessValueLinkEntityView.__select__ & is_instance('SEDARelationship')

    def entity_call(self, entity):
        super(RelationshipBusinessValueLinkEntityView, self).entity_call(entity)
        if entity.seda_type_relationship:
            concept = entity.seda_type_relationship[0]
            self.w(self._cw._(', of relationship type %s') % concept.label())
        else:
            self.w(self._cw._(', no relationship type specified'))


224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
class AttachmentTypedBusinessValueEntityView(viewlib.BusinessValueEntityView):
    __select__ = is_instance('SEDAAttachment')

    def entity_call(self, entity):
        super(AttachmentTypedBusinessValueEntityView, self).entity_call(entity)
        attributes = []
        for rtype in ('reverse_seda_uri', 'reverse_seda_filename'):
            values = getattr(entity, rtype)
            if values:
                value = values[0]
                display = value.dc_type()
                if value.user_cardinality == '0..1':
                    display += ' <i>%s</i>' % self._cw._('optional')
                attributes.append(display)
        if attributes:
            self.w(self._cw._(' (attributes: %s)') % ', '.join(attributes))
240
241
242
243
244
245
246
247
248
249
250
251
252


class UnitBusinessValueEntityView(viewlib.BusinessValueEntityView):
    __select__ = is_instance('SEDAWidth', 'SEDAHeight', 'SEDADepth', 'SEDAShape',
                             'SEDADiameter', 'SEDALength', 'SEDAThickness', 'SEDAWeight')

    def entity_call(self, entity):
        super(UnitBusinessValueEntityView, self).entity_call(entity)
        if entity.seda_unit:
            unit = self._cw._('unit: {0}').format(entity.seda_unit[0].label())
        else:
            unit = self._cw._('<no unit specified>')
        self.w(u' (%s)' % xml_escape(unit))