dataobject.py 12.8 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, view
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
30
from cubes.seda.views import rtags_from_xsd_element, add_subobject_link, parent_and_container
from cubes.seda.views import viewlib
31

32
33
_ = unicode

34
pvs = uicfg.primaryview_section
35
pv_ctrl = uicfg.primaryview_display_ctrl
36
37
rec = uicfg.reledit_ctrl
afs = uicfg.autoform_section
38
39
affk = uicfg.autoform_field_kwargs

40
41

class ContainedRelationFacetWidget(rwdg.RelationFacetWidget):
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    def _render_triggers(self, w, domid, form, field, rtype):
        parent, container = parent_and_container(form.edited_entity)
        req = form._cw
        if container is None:
            w(req._('you must validate first to select a possible value'))
        else:
            try:
                constraint = RDEF_CONSTRAINTS[(form.edited_entity.cw_etype, field.name)]
            except KeyError:
                constraint = RDEF_CONSTRAINTS[field.name]
            rql = 'Any CS WHERE ' + (
                constraint.replace('O in_scheme CS, ', '').replace(', S container AT', ''))
            rql += ', AT eid %(at)s'
            if not req.execute(rql, {'at': container.eid}):
                scheme_relations = [x for x in rql.split() if x.startswith('seda_')]
                if len(scheme_relations) == 1:
                    scheme_relation = req._(scheme_relations[0])
                else:
                    scheme_relation = req.__(scheme_relations[0] + '_object')
                w(req._('you must specify a scheme for {0} to select a value').format(
                    scheme_relation))
            else:
                return super(ContainedRelationFacetWidget, self)._render_triggers(
                    w, domid, form, field, rtype)
66
67
68
69
70
71
72

    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
73
        _, container = parent_and_container(entity)
74
        # and put it as an extra url param
75
76
        if container is not None:
            url_params['container'] = unicode(container.eid)
77
78
79
80
81
82
        return super(ContainedRelationFacetWidget, self).trigger_search_url(entity, url_params)


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

83
84
    has_creation_form = False

85
86
87
88
89
90
91
92
93
    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
94
        rql = 'Any O WHERE ' + baserql.replace('S container AT', 'AT eid %(at)s')
95
96
97
        return self._cw.execute(rql, {'at': int(self._cw.form['container'])})


98
99
# hide some relation from autoform because of limitation of _container_eid
afs.tag_object_of(('*', 'seda_compressed', 'SEDABinaryDataObject'), 'main', 'hidden')
100
pvs.tag_object_of(('*', 'seda_compressed', 'SEDABinaryDataObject'), 'attributes')
101
102
103
104
105
106
107
pvs.tag_object_of(('*', 'seda_data_object_reference_id', 'SEDABinaryDataObject'),
                  'relations')
pv_ctrl.tag_object_of(('*', 'seda_data_object_reference_id', 'SEDABinaryDataObject'),
                      {'vid': 'autolimited',
                       'subvid': 'seda.object-ref.archive-unit',
                       'label': _('referenced by:'),
                       })
108
109
110
111
112
113
114
115
116
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'):
117
118
    afs.tag_object_of(('*', 'seda_data_object_version_from', etype), 'main', 'hidden')
    pvs.tag_object_of(('*', 'seda_data_object_version_from', etype), 'attributes')
119
120
121
122
    rec.tag_object_of(('*', 'seda_data_object_version_from', etype),
                      {'rvid': 'seda.reledit.complexlink',
                       'novalue_label': _('<unauthorized>')})

123
124
    pvs.tag_object_of(('*', 'seda_target', etype), 'hidden')  # in the relationship tab

125

126
127
def uri_cardinality_vocabulary(form, field):
    req = form._cw
128
129
130
131
132
133
134
135
136
137
    if form.edited_entity.has_eid():
        parent_type = form.edited_entity.cw_adapt_to('IContained').parent.cw_etype
    else:
        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]
138
139
140
141
142
143
144
145
    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})


146
147
148
149
150
151
152
for key, rql_expr in RDEF_CONSTRAINTS.items():
    if 'S container AT' in rql_expr:
        try:
            etype, rtype = key
        except ValueError:
            etype = '*'
            rtype = key
153
154
        if rtype == 'seda_rule':
            continue  # managed in mgmt_rules module
155
156
        affk.tag_subject_of((etype, rtype, '*'),
                            {'widget': ContainedRelationFacetWidget(dialog_options={'width': 800})})
157
158
159
160
161
162


class BinaryDataObjectTabbedPrimaryView(tabs.TabbedPrimaryView):
    __select__ = tabs.TabbedPrimaryView.__select__ & is_instance('SEDABinaryDataObject')
    tabs = [
        'main_tab',
163
        _('seda_bdo_format_identification'),
164
        _('seda_bdo_file_information'),
165
        _('seda_do_relations'),
166
167
168
    ]


169
170
171
172
173
174
175
176
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')


177
178
179
180
181
182
183
184
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')


185
186
187
188
class PhysicalDataObjectTabbedPrimaryView(tabs.TabbedPrimaryView):
    __select__ = tabs.TabbedPrimaryView.__select__ & is_instance('SEDAPhysicalDataObject')
    tabs = [
        'main_tab',
189
        _('seda_pdo_dimensions'),
190
        _('seda_do_relations'),
191
    ]
192
193


194
195
196
197
198
199
200
201
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')


Sylvain Thénault's avatar
Sylvain Thénault committed
202
class DataObjectRelationsTab(tabs.PrimaryTab):
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
    """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')
220
221
222
223
224
225
226
        rset = entity.related('seda_target', 'object')
        if rset:
            self.w(u'<h2>{0}</h2>'.format(self._cw._('Relationship target of')))
            self.w(u'<div>{0}</div>'.format(
                self._cw._('This object is used as a relationship target of the following '
                           'entities')))
            self._cw.view('list', rset=rset, subvid='seda.relationship.reverse', w=self.w)
227
228
229
230
231


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

232
233
234
235
236
237
    def entity_value(self, entity):
        target = entity.seda_target[0] if entity.seda_target else None
        if target:
            value = tags.a(target.dc_title(), href=target.absolute_url())
        else:
            value = xml_escape(self._cw._('<no data-object specified>'))
238
239
        if entity.seda_type_relationship:
            concept = entity.seda_type_relationship[0]
240
            msg = self._cw._(', of relationship type %s') % concept.label()
241
        else:
242
243
244
            msg = self._cw._(', no relationship type specified')
        value += xml_escape(msg)
        return value
245
246


247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
class RelationshipReverseEntityView(view.EntityView):
    __regid__ = 'seda.relationship.reverse'
    __select__ = is_instance('SEDARelationship')

    def entity_call(self, entity):
        target = entity.seda_relationship[0]
        self.w(tags.a(target.dc_title(), href=target.absolute_url()))
        if entity.seda_type_relationship:
            concept = entity.seda_type_relationship[0]
            msg = self._cw._(', of relationship type %s') % concept.label()
        else:
            msg = self._cw._(', no relationship type specified')
        self.w(xml_escape(msg))


262
263
264
265
266
267
268
269
270
271
272
class ObjectReferencepArchiveUnitEntityView(view.EntityView):
    __regid__ = 'seda.object-ref.archive-unit'
    __select__ = is_instance('SEDADataObjectReference')

    def entity_call(self, entity):
        au_seq = entity.seda_data_object_reference[0]
        au_choice = au_seq.reverse_seda_seq_alt_archive_unit_archive_unit_ref_id_management[0]
        archive_unit = au_choice.reverse_seda_alt_archive_unit_archive_unit_ref_id[0]
        self._cw.view('listitem', rset=archive_unit.as_rset(), w=self.w)


Sylvain Thénault's avatar
Sylvain Thénault committed
273
class AttachmentBusinessValueEntityView(viewlib.BusinessValueEntityView):
274
275
276
    __select__ = is_instance('SEDAAttachment')

    def entity_call(self, entity):
Sylvain Thénault's avatar
Sylvain Thénault committed
277
        super(AttachmentBusinessValueEntityView, self).entity_call(entity)
278
279
280
281
282
283
284
285
286
287
288
        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))
289
290
291
292
293
294
295
296
297
298
299
300
301


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