cubicweb: comparison sobjects/parsers.py

equal deleted inserted replaced

-:ae3307cac44e
+:5146c63e8e34
 'cw.entityxml.item-builder', self._cw, node=node,
 parser=self)
 yield builder.build_item()
 def process_item(self, item, rels):
+"""
+item and rels are what's returned by the item builder `build_item` method:
+* `item` is an {attribute: value} dictionary
+* `rels` is for relations and structured as
+{role: {relation: [(related item, related rels)...]}
+"""
 entity = self.extid2entity(str(item.pop('cwuri')),  item.pop('cwtype'),
 cwsource=item.pop('cwsource'), item=item)
 if entity is None:
 return None
 if entity.eid in self._processed_entities:
 self.notify_updated(entity)
 item.pop('eid')
 # XXX check modification date
 attrs = extract_typed_attrs(entity.e_schema, item)
 entity.set_attributes(**attrs)
-for (rtype, role, action), rules in self.source.mapping.get(entity.__regid__, {}).iteritems():
+self.process_relations(entity, rels)
+return entity
+def process_relations(self, entity, rels):
+etype = entity.__regid__
+for (rtype, role, action), rules in self.source.mapping.get(etype, {}).iteritems():
 try:
 related_items = rels[role][rtype]
 except KeyError:
 self.source.error('relation %s-%s not found in xml export of %s',
-rtype, role, entity.__regid__)
+rtype, role, etype)
 continue
 try:
 linker = self.select_linker(action, rtype, role, entity)
 except RegistryException:
 self.source.error('no linker for action %s', action)
 else:
 linker.link_items(related_items, rules)
-return entity
 def before_entity_copy(self, entity, sourceparams):
 """IDataFeedParser callback"""
 attrs = extract_typed_attrs(entity.e_schema, sourceparams['item'])
 entity.cw_edited.update(attrs)
-def complete_url(self, url, etype=None, add_relations=True):
+def complete_url(self, url, etype=None, known_relations=None):
 """append to the url's query string information about relation that should
 be included in the resulting xml, according to source mapping.
 If etype is not specified, try to guess it using the last path part of
 the url, i.e. the format used by default in cubicweb to map all entities
 of a given type as in 'http://mysite.org/EntityType'.
+If `known_relations` is given, it should be a dictionary of already
+known relations, so they don't get queried again.
 """
 try:
 url, qs = url.split('?', 1)
 except ValueError:
 qs = ''
 return url + '?' + self._cw.build_url_params(**params)
 try:
 etype = self._cw.vreg.case_insensitive_etypes[etype.lower()]
 except KeyError:
 return url + '?' + self._cw.build_url_params(**params)
-if add_relations:
+relations = params.setdefault('relation', [])
-relations = params.setdefault('relation', [])
+for rtype, role, _ in self.source.mapping.get(etype, ()):
-for rtype, role, _ in self.source.mapping.get(etype, ()):
+if known_relations and rtype in known_relations.get('role', ()):
-reldef = '%s-%s' % (rtype, role)
+continue
-if not reldef in relations:
+reldef = '%s-%s' % (rtype, role)
-relations.append(reldef)
+if not reldef in relations:
+relations.append(reldef)
 return url + '?' + self._cw.build_url_params(**params)
-def complete_item(self, item, add_relations=True):
+def complete_item(self, item, rels):
 try:
-return self._parsed_urls[(item['cwuri'], add_relations)]
+return self._parsed_urls[item['cwuri']]
 except KeyError:
-itemurl = self.complete_url(item['cwuri'], item['cwtype'],
+itemurl = self.complete_url(item['cwuri'], item['cwtype'], rels)
-add_relations)
 item_rels = list(self.parse(itemurl))
 assert len(item_rels) == 1, 'url %s expected to bring back one '\
 'and only one entity, got %s' % (itemurl, len(item_rels))
-self._parsed_urls[(item['cwuri'], add_relations)] = item_rels[0]
+self._parsed_urls[item['cwuri']] = item_rels[0]
+if rels:
+# XXX (do it better) merge relations
+new_rels = item_rels[0][1]
+new_rels.get('subject', {}).update(rels.get('subject', {}))
+new_rels.get('object', {}).update(rels.get('object', {}))
 return item_rels[0]
 class CWEntityXMLItemBuilder(Component):
 __regid__ = 'cw.entityxml.item-builder'
 super(CWEntityXMLItemBuilder, self).__init__(_cw, **kwargs)
 self.parser = parser
 self.node = node
 def build_item(self):
+"""parse a XML document node and return two dictionaries defining (part
+of) an entity:
+- {attribute: value}
+- {role: {relation: [(related item, related rels)...]}
+"""
 node = self.node
 item = dict(node.attrib.items())
 item['cwtype'] = unicode(node.tag)
 item.setdefault('cwsource', None)
 try:
 for child in node:
 role = child.get('role')
 if role:
 # relation
 related = rels.setdefault(role, {}).setdefault(child.tag, [])
-related += [ritem for ritem, _ in self.parser.parse_etree(child)]
+related += self.parser.parse_etree(child)
 elif child.text:
 # attribute
 item[child.tag] = unicode(child.text)
 else:
 # None attribute (empty tag)
 def link_items(self, others, rules):
 assert not any(x[1] for x in rules), "'copy' action takes no option"
 ttypes = frozenset([x[0] for x in rules])
 eids = [] # local eids
-for item in others:
+for item, rels in others:
 if item['cwtype'] in ttypes:
-item = self.parser.complete_item(item)[0]
+item, rels = self.parser.complete_item(item, rels)
-other_entity = self.parser.process_item(item, [])
+other_entity = self.parser.process_item(item, rels)
 if other_entity is not None:
 eids.append(other_entity.eid)
 if eids:
 self._set_relation(eids)
 else:
 def _related_link(self, ttype, others, searchattrs):
 def issubset(x,y):
 return all(z in y for z in x)
 eids = [] # local eids
 source = self.parser.source
-for item in others:
+for item, rels in others:
 if item['cwtype'] != ttype:
 continue
 if not issubset(searchattrs, item):
-item = self.parser.complete_item(item, False)[0]
+item, rels = self.parser.complete_item(item, rels)
 if not issubset(searchattrs, item):
 source.error('missing attribute, got %s expected keys %s',
 item, searchattrs)
 continue
 # XXX str() needed with python < 2.6
 kwargs = dict((str(attr), item[attr]) for attr in searchattrs)
 targets = self._find_entities(item, kwargs)
-if len(targets) > 1:
+if len(targets) == 1:
-source.error('ambiguous link: found %s entity %s with attributes %s',
+entity = targets[0]
-len(targets), item['cwtype'], kwargs)
+elif not targets and self.create_when_not_found:
-elif len(targets) == 1:
+entity = self._cw.create_entity(item['cwtype'], **kwargs)
-eids.append(targets[0].eid)
-elif self.create_when_not_found:
-eids.append(self._cw.create_entity(item['cwtype'], **kwargs).eid)
 else:
-source.error('can not find %s entity with attributes %s',
+if len(targets) > 1:
-item['cwtype'], kwargs)
+source.error('ambiguous link: found %s entity %s with attributes %s',
+len(targets), item['cwtype'], kwargs)
+else:
+source.error('can not find %s entity with attributes %s',
+item['cwtype'], kwargs)
+continue
+eids.append(entity.eid)
+self.parser.process_relations(entity, rels)
 if eids:
 self._set_relation(eids)
 else:
 self._clear_relation((ttype,))

changeset 7920	5146c63e8e34
parent 7916	54e240c1b419
child 7932	2ad26cc3b5c6