web/views/primary.py
branchtls-sprint
changeset 1516 288d55a7c5e2
parent 1491 742aff97dbf7
child 1554 3a3263df6cdd
equal deleted inserted replaced
1515:f3c26a087672 1516:288d55a7c5e2
    42         # XXX move render_entity implementation here
    42         # XXX move render_entity implementation here
    43         self.render_entity(self.complete_entity(row, col))
    43         self.render_entity(self.complete_entity(row, col))
    44 
    44 
    45     def render_entity(self, entity):
    45     def render_entity(self, entity):
    46         """return html to display the given entity"""
    46         """return html to display the given entity"""
    47         siderelations = []
       
    48         self.render_entity_title(entity)
    47         self.render_entity_title(entity)
    49         self.render_entity_metadata(entity)
    48         self.render_entity_metadata(entity)
    50         # entity's attributes and relations, excluding meta data
    49         # entity's attributes and relations, excluding meta data
    51         # if the entity isn't meta itself
    50         # if the entity isn't meta itself
    52         boxes = self._preinit_side_related(entity, siderelations)
    51         boxes = self._preinit_side_related(entity)
    53         if boxes:
    52         if boxes:
    54             self.w(u'<table width="100%"><tr><td width="75%">')
    53             self.w(u'<table width="100%"><tr><td width="75%">')
    55         self.w(u'<div>')
    54         self.w(u'<div>')
    56         self.w(u'<div class="mainInfo">')
    55         self.w(u'<div class="mainInfo">')
    57         self.render_entity_attributes(entity, siderelations)
    56         try:
       
    57             self.render_entity_attributes(entity)
       
    58         except TypeError: # XXX bw compat
       
    59             warn('siderelations argument of render_entity_attributes is '
       
    60                  'deprecated')
       
    61             self.render_entity_attributes(entity, [])
    58         self.w(u'</div>')
    62         self.w(u'</div>')
    59         self.content_navigation_components('navcontenttop')
    63         self.content_navigation_components('navcontenttop')
    60         if self.main_related_section:
    64         if self.main_related_section:
    61             self.render_entity_relations(entity, siderelations)
    65             try:
       
    66                 self.render_entity_relations(entity)
       
    67             except TypeError: # XXX bw compat
       
    68                 warn('siderelations argument of render_entity_relations is '
       
    69                      'deprecated')
       
    70                 self.render_entity_relations(entity, [])
    62         self.w(u'</div>')
    71         self.w(u'</div>')
    63         if boxes:
    72         if boxes:
    64             self.w(u'</td><td>')
    73             self.w(u'</td><td>')
    65             # side boxes
    74             # side boxes
    66             self.w(u'<div class="primaryRight">')
    75             self.w(u'<div class="primaryRight">')
    67             self.render_side_related(entity, siderelations)
    76             try:
       
    77                 self.render_side_related(entity)
       
    78             except TypeError: # XXX bw compat
       
    79                 warn('siderelations argument of render_entity_relations is '
       
    80                      'deprecated')
       
    81                 self.render_entity_relations(entity, [])
    68             self.w(u'</div>')
    82             self.w(u'</div>')
    69             self.w(u'</td></tr></table>')
    83             self.w(u'</td></tr></table>')
    70         self.content_navigation_components('navcontentbottom')
    84         self.content_navigation_components('navcontentbottom')
    71 
    85 
    72 
    86 
   115 
   129 
   116     def summary(self, entity):
   130     def summary(self, entity):
   117         """default implementation return an empty string"""
   131         """default implementation return an empty string"""
   118         return u''
   132         return u''
   119 
   133 
   120     def render_entity_attributes(self, entity, siderelations):
   134     def render_entity_attributes(self, entity, siderelations=None):
   121         for rschema, targetschema in self.iter_attributes(entity):
   135         for rschema, targetschema in self.iter_attributes(entity):
   122             attr = rschema.type
   136             attr = rschema.type
   123             if targetschema.type in ('Password', 'Bytes'):
   137             if targetschema.type in ('Password', 'Bytes'):
   124                 continue
   138                 continue
   125             try:
   139             try:
   132                 continue
   146                 continue
   133             if rschema.meta:
   147             if rschema.meta:
   134                 continue
   148                 continue
   135             self._render_related_entities(entity, rschema, value)
   149             self._render_related_entities(entity, rschema, value)
   136 
   150 
   137     def _preinit_side_related(self, entity, siderelations):
   151     def _preinit_side_related(self, entity):
   138         self._sideboxes = None
   152         self._sideboxes = []
   139         self._related_entities = []
       
   140         if hasattr(self, 'get_side_boxes_defs'):
   153         if hasattr(self, 'get_side_boxes_defs'):
   141             self._sideboxes = [(label, rset) for label, rset in self.get_side_boxes_defs(entity)
   154             self._sideboxes = [(label, rset, 'sidebox') for label, rset in self.get_side_boxes_defs(entity)
   142                                if rset]
   155                                if rset]
   143         else:
   156         else:
   144             eschema = entity.e_schema
   157             eschema = entity.e_schema
   145             maxrelated = self.req.property_value('navigation.related-limit')
   158             maxrelated = self.req.property_value('navigation.related-limit')
   146             for rschema, targetschemas, x in self.iter_relations(entity):
   159             for rschema, targetschemas, role in self.iter_relations(entity):
       
   160                 if self.is_side_related(rschema, eschema):
       
   161                     try:
       
   162                         related = entity.related(rschema.type, role, limit=maxrelated+1)
       
   163                     except Unauthorized:
       
   164                         continue
       
   165                     if not related:
       
   166                         continue
       
   167                     label = display_name(self.req, rschema.type, role)
       
   168                     self._sideboxes.append((label, related, 'autolimited'))
       
   169         self._contextboxes = list(self.vreg.possible_vobjects('boxes', self.req, self.rset,
       
   170                                                                   row=self.row, view=self,
       
   171                                                                   context='incontext'))
       
   172         return self._sideboxes or self._contextboxes
       
   173 
       
   174     def render_entity_relations(self, entity, siderelations=None):
       
   175         eschema = entity.e_schema
       
   176         for rschema, targetschemas, x in self.iter_relations(entity):
       
   177             if not self.is_side_related(rschema, eschema):
   147                 try:
   178                 try:
   148                     related = entity.related(rschema.type, x, limit=maxrelated+1)
   179                     related = entity.related(rschema.type, x, limit=maxrelated+1)
   149                 except Unauthorized:
   180                 except Unauthorized:
   150                     continue
   181                     continue
   151                 if not related:
       
   152                     continue
       
   153                 if self.is_side_related(rschema, eschema):
       
   154                     siderelations.append((rschema, related, x))
       
   155                     continue
       
   156                 self._related_entities.append((rschema, related, x))
       
   157         self._boxes_in_context = list(self.vreg.possible_vobjects('boxes', self.req, self.rset,
       
   158                                                  row=self.row, view=self,
       
   159                                                  context='incontext'))
       
   160         return self._sideboxes or self._boxes_in_context or self._related_entities or siderelations
       
   161 
       
   162     def render_entity_relations(self, entity, siderelations):
       
   163         if self._related_entities:
       
   164             for rschema, related, x in self._related_entities:
       
   165                 self._render_related_entities(entity, rschema, related, x)
   182                 self._render_related_entities(entity, rschema, related, x)
   166 
   183 
   167 
   184 
   168     def render_side_related(self, entity, siderelations):
   185     def render_side_related(self, entity, siderelations=None):
   169         """display side related relations:
   186         """display side related relations:
   170         non-meta in a first step, meta in a second step
   187         non-meta in a first step, meta in a second step
   171         """
   188         """
   172         if self._sideboxes:
   189         if self._sideboxes:
   173             for label, rset in self._sideboxes:
   190             for label, rset, vid in self._sideboxes:
   174                 self.w(u'<div class="sideRelated">')
   191                 self.w(u'<div class="sideRelated">')
   175                 self.wview('sidebox', rset, title=label)
   192                 self.wview(vid, rset, title=label)
   176                 self.w(u'</div>')
   193                 self.w(u'</div>')
   177         elif siderelations:
   194         if self._contextboxes:
   178             self.w(u'<div class="sideRelated">')
   195             for box in self._contextboxes:
   179             for relatedinfos in siderelations:
       
   180                 # if not relatedinfos[0].meta:
       
   181                 #    continue
       
   182                 self._render_related_entities(entity, *relatedinfos)
       
   183             self.w(u'</div>')
       
   184 
       
   185         if self._boxes_in_context:
       
   186             for box in self._boxes_in_context:
       
   187                 try:
   196                 try:
   188                     box.dispatch(w=self.w, row=self.row)
   197                     box.dispatch(w=self.w, row=self.row)
   189                 except NotImplementedError:
   198                 except NotImplementedError:
   190                     # much probably a context insensitive box, which only implements
   199                     # much probably a context insensitive box, which only implements
   191                     # .call() and not cell_call()
   200                     # .call() and not cell_call()
   201             value = related
   210             value = related
   202             show_label = self.show_attr_label
   211             show_label = self.show_attr_label
   203         else:
   212         else:
   204             if not related:
   213             if not related:
   205                 return
   214                 return
   206             show_label = self.show_rel_label
   215             value = self.view('autolimited', related)
   207             # if not too many entities, show them all in a list
       
   208             maxrelated = self.req.property_value('navigation.related-limit')
       
   209             if related.rowcount <= maxrelated:
       
   210                 if related.rowcount == 1:
       
   211                     value = self.view('incontext', related, row=0)
       
   212                 elif 1 < related.rowcount <= 5:
       
   213                     value = self.view('csv', related)
       
   214                 else:
       
   215                     value = '<div>' + self.view('simplelist', related) + '</div>'
       
   216             # else show links to display related entities
       
   217             else:
       
   218                 rql = related.printable_rql()
       
   219                 related.limit(maxrelated)
       
   220                 value = '<div>' + self.view('simplelist', related)
       
   221                 value += '[<a href="%s">%s</a>]' % (self.build_url(rql=rql),
       
   222                                                     self.req._('see them all'))
       
   223                 value +=  '</div>'
       
   224         label = display_name(self.req, rschema.type, role)
   216         label = display_name(self.req, rschema.type, role)
   225         self.field(label, value, show_label=show_label, tr=False)
   217         self.field(label, value, show_label=show_label, tr=False)
   226 
   218 
       
   219 
       
   220 class RelatedView(EntityView):
       
   221     id = 'autolimited'
       
   222     def call(self):
       
   223         # if not too many entities, show them all in a list
       
   224         maxrelated = self.req.property_value('navigation.related-limit')
       
   225         if self.rset.rowcount <= maxrelated:
       
   226             if self.rset.rowcount == 1:
       
   227                 self.wview('incontext', self.rset, row=0)
       
   228             elif 1 < self.rset.rowcount <= 5:
       
   229                 self.wview('csv', self.rset)
       
   230             else:
       
   231                 self.w(u'<div>')
       
   232                 self.wview('simplelist', self.rset)
       
   233                 self.w(u'</div>')
       
   234         # else show links to display related entities
       
   235         else:
       
   236             rql = self.rset.printable_rql()
       
   237             self.rset.limit(maxself.rset)
       
   238             self.w(u'<div>')
       
   239             self.wview('simplelist', self.rset)
       
   240             self.w(u'[<a href="%s">%s</a>]' % (self.build_url(rql=rql),
       
   241                                                self.req._('see them all')))
       
   242             self.w(u'</div>')