def get_links(entity: Entity) -> Dict[Any, list]:
d = defaultdict(list)
for link in Link.get_links(entity.id):
d[link.property.i18n['en'].replace(' ', '_') + '_' +
link.range.class_.name].append(link.range.name)
for link in Link.get_links(entity.id, inverse=True):
d[link.property.i18n_inverse['en'].replace(' ', '_') + '_' +
link.domain.class_.name if link.property.i18n_inverse['en'] else
link.property.i18n['en'].replace(' ', '_') + '_' +
link.domain.class_.name].append(link.domain.name)
d.pop('has_type_type', None)
return d
def get_links(entity: Entity) -> Dict[str, Any]:
links: Dict[str, Any] = defaultdict(list)
for link in Link.get_links(entity.id):
key = f"""{link.property.i18n['en'].replace(' ', '_')}
_{link.range.class_.name}"""
links[key].append(link.range.name)
for link in Link.get_links(entity.id, inverse=True):
key = f"""{link.property.i18n['en'].replace(' ', '_')}
_{link.range.class_.name}"""
if link.property.i18n_inverse['en']:
key = link.property.i18n_inverse['en'].replace(' ', '_')
key += '_' + link.domain.class_.name
links[key].append(link.domain.name)
links.pop('has_type_type', None)
return links
def test_member(self) -> None:
with app.app_context():
with app.test_request_context():
app.preprocess_request() # type: ignore
actor = Entity.insert('person', 'Ripley')
group = Entity.insert('group', 'Space Marines')
# Add membership
rv = self.app.get(url_for('member_insert', origin_id=group.id))
assert b'Actor function' in rv.data
rv = self.app.post(url_for('member_insert',
origin_id=actor.id,
code='membership'),
data={'group': str([group.id])},
follow_redirects=True)
assert b'Space Marines' in rv.data
rv = self.app.post(url_for('member_insert',
origin_id=actor.id,
code='membership'),
data={
'group': str([group.id]),
'continue_': 'yes'
},
follow_redirects=True)
assert b'Space Marines' in rv.data
rv = self.app.post(url_for('member_insert',
origin_id=group.id,
code='membership'),
data={'group': str([group.id])})
assert b"link to itself" in rv.data
rv = self.app.post(url_for('member_insert', origin_id=actor.id),
data={'actor': str([actor.id])},
follow_redirects=True)
assert b"link to itself" in rv.data
# Add member to group
data = {'actor': str([actor.id])}
rv = self.app.post(url_for('member_insert', origin_id=group.id),
data=data,
follow_redirects=True)
assert b'Ripley' in rv.data
data['continue_'] = 'yes'
rv = self.app.post(url_for('member_insert', origin_id=group.id),
data=data,
follow_redirects=True)
assert b'Ripley' in rv.data
# Update
with app.test_request_context():
app.preprocess_request() # type: ignore
link_id = Link.get_links(group.id, 'P107')[0].id
rv = self.app.get(
url_for('member_update', id_=link_id, origin_id=group.id))
assert b'Ripley' in rv.data
rv = self.app.post(
url_for('member_update', id_=link_id, origin_id=group.id),
data={'description': 'We are here to help you.'},
follow_redirects=True)
assert b'here to help' in rv.data
def get_links(entity: Entity) -> Optional[List[Dict[str, str]]]:
links = []
for link in Link.get_links(entity.id):
links.append({
'label':
link.range.name,
'relationTo':
url_for('entity', id_=link.range.id, _external=True),
'relationType':
'crm:' + link.property.code + '_' +
link.property.i18n['en'].replace(' ', '_'),
'relationSystemClass':
link.range.class_.name,
'type':
link.type.name if link.type else None,
'when': {
'timespans': [GeoJsonEntity.get_time(link)]
}
})
for link in Link.get_links(entity.id, inverse=True):
link_property = link.property.i18n_inverse[
'en'] if link.property.i18n_inverse[
'en'] else link.property.i18n['en']
links.append({
'label':
link.domain.name,
'relationTo':
url_for('entity', id_=link.domain.id, _external=True),
'relationType':
'crm:' + link.property.code + 'i_' +
link_property.replace(' ', '_'),
'relationSystemClass':
link.domain.class_.name,
'type':
link.type.name if link.type else None,
'when': {
'timespans': [GeoJsonEntity.get_time(link)]
}
})
return links if links else None
def get_node(entity: Entity) -> Dict[Any, List[Any]]:
nodes: Dict[str, Any] = defaultdict(list)
for node in entity.nodes:
hierarchy = [g.nodes[root].name for root in node.root]
hierarchy.reverse()
value = ''
for link in Link.get_links(entity.id):
if link.range.id == node.id and link.description:
value += link.description
if link.range.id == node.id and node.description:
value += node.description
key = ' > '.join(map(str, hierarchy))
nodes[key].append(node.name + (': ' + value if value else ''))
return nodes
def get_reference_systems(
entity: Entity) -> Optional[List[Dict[str, Union[str, Any]]]]:
ref = []
for link in Link.get_links(entity.id, codes="P67", inverse=True):
if isinstance(link.domain, ReferenceSystem):
system = g.reference_systems[link.domain.id]
ref.append({
'identifier':
(system.resolver_url if system.resolver_url else '') +
link.description,
'type':
g.nodes[link.type.id].name,
'reference_system':
system.name
})
return ref if ref else None
def get_file(entity: Entity) -> Optional[List[Dict[str, str]]]:
files = []
for link in Link.get_links(entity.id, codes="P67", inverse=True):
if link.domain.class_.name == 'file':
path = get_file_path(link.domain.id)
files.append({
'@id':
url_for('entity', id_=link.domain.id, _external=True),
'title':
link.domain.name,
'license':
GeoJsonEntity.get_license(link.domain.id),
'url':
url_for('display_file_api',
filename=path.name,
_external=True) if path else "N/A"
})
return files if files else None
def get_node(entity: Entity) -> Optional[List[Dict[str, Any]]]:
nodes = []
for node in entity.nodes:
nodes_dict = {
'identifier': url_for('entity', id_=node.id, _external=True),
'label': node.name
}
for link in Link.get_links(entity.id):
if link.range.id == node.id and link.description:
nodes_dict['value'] = link.description
if link.range.id == node.id and node.description:
nodes_dict['unit'] = node.description
hierarchy = []
for root in node.root:
hierarchy.append(g.nodes[root].name)
hierarchy.reverse()
nodes_dict['hierarchy'] = ' > '.join(map(str, hierarchy))
nodes.append(nodes_dict)
return nodes if nodes else None
def get_links(self, codes: Union[str, List[str]], inverse: bool = False) -> List[Link]:
return Link.get_links(self.id, codes, inverse)
def get_license(entity_id: int) -> str:
file_license = ""
for link in Link.get_links(entity_id):
if link.property.code == "P2":
file_license = link.range.name
return file_license
def test_relation(self) -> None:
with app.app_context(): # type: ignore
with app.test_request_context():
app.preprocess_request() # type: ignore
actor = Entity.insert('person', 'Connor MacLeod')
related = Entity.insert('person', 'The Kurgan')
# Add relationship
rv = self.app.get(url_for('relation_insert', origin_id=actor.id))
assert b'Actor actor relation' in rv.data
relation_id = Node.get_hierarchy('Actor actor relation').id
relation_sub_id = g.nodes[relation_id].subs[0]
relation_sub_id2 = g.nodes[relation_id].subs[1]
data = {
'actor': str([related.id]),
relation_id: relation_sub_id,
'inverse': None,
'begin_year_from': '-1949',
'begin_month_from': '10',
'begin_day_from': '8',
'begin_year_to': '-1948',
'end_year_from': '2049',
'end_year_to': '2050'
}
rv = self.app.post(url_for('relation_insert', origin_id=actor.id),
data=data,
follow_redirects=True)
assert b'The Kurgan' in rv.data
rv = self.app.get(url_for('entity_view', id_=relation_sub_id))
assert b'Connor' in rv.data
data['continue_'] = 'yes'
data['inverse'] = True
rv = self.app.post(url_for('relation_insert', origin_id=actor.id),
data=data,
follow_redirects=True)
assert b'The Kurgan' in rv.data
rv = self.app.get(url_for('entity_view', id_=actor.id))
assert b'The Kurgan' in rv.data
rv = self.app.post(url_for('relation_insert',
origin_id=related.id),
data=data,
follow_redirects=True)
assert b"link to itself" in rv.data
# Relation types
rv = self.app.get(
url_for('node_move_entities', id_=relation_sub_id))
assert b'The Kurgan' in rv.data
# Update relationship
with app.test_request_context():
app.preprocess_request() # type: ignore
link_id = Link.get_links(actor.id, 'OA7')[0].id
link_id2 = Link.get_links(actor.id, 'OA7', True)[0].id
rv = self.app.post(url_for('node_move_entities',
id_=relation_sub_id),
follow_redirects=True,
data={
relation_id: relation_sub_id2,
'selection': [link_id],
'checkbox_values': str([link_id])
})
assert b'Entities were updated' in rv.data
rv = self.app.post(url_for('node_move_entities',
id_=relation_sub_id2),
data={
relation_id: '',
'selection': [link_id],
'checkbox_values': str([link_id])
},
follow_redirects=True)
assert b'Entities were updated' in rv.data
rv = self.app.get(
url_for('relation_update', id_=link_id, origin_id=related.id))
assert b'Connor' in rv.data
rv = self.app.post(url_for('relation_update',
id_=link_id,
origin_id=actor.id),
data={
'description': 'There can be only one!',
'inverse': True
},
follow_redirects=True)
assert b'only one' in rv.data
rv = self.app.post(url_for('relation_update',
id_=link_id2,
origin_id=actor.id),
data={
'description': 'There can be only one!',
'inverse': None
},
follow_redirects=True)
assert b'only one' in rv.data
def test_involvement(self) -> None:
with app.app_context():
rv: Any = self.app.post(url_for('insert', class_='acquisition'),
data={
'name': 'Event Horizon',
'begin_year_from': '949',
'begin_month_from': '10',
'begin_day_from': '8',
'end_year_from': '1951',
self.precision_geonames: '',
self.precision_wikidata: ''
})
event_id = int(rv.location.split('/')[-1])
with app.test_request_context():
app.preprocess_request() # type: ignore
actor = Entity.insert('person', 'Captain Miller')
involvement = Type.get_hierarchy('Involvement')
# Add involvement
rv = self.app.get(url_for('involvement_insert',
origin_id=actor.id))
assert b'Involvement' in rv.data
rv = self.app.post(url_for('involvement_insert',
origin_id=actor.id),
data={
'event': str([event_id]),
'activity': 'P11',
'begin_year_from': '950',
'end_year_from': '1950',
involvement.id: involvement.id
},
follow_redirects=True)
assert b'Event Horizon' in rv.data
rv = self.app.post(url_for('involvement_insert',
origin_id=event_id),
data={
'actor': str([actor.id]),
'continue_': 'yes',
'activity': 'P22'
},
follow_redirects=True)
assert b'Event Horizon' in rv.data
rv = self.app.get(url_for('view', id_=event_id))
assert b'Event Horizon' in rv.data
rv = self.app.get(url_for('view', id_=actor.id))
assert b'Appears first' in rv.data
# Update involvement
with app.test_request_context():
app.preprocess_request() # type: ignore
link_id = Link.get_links(event_id, 'P22')[0].id
rv = self.app.get(
url_for('link_update', id_=link_id, origin_id=event_id))
assert b'Captain' in rv.data
rv = self.app.post(url_for('link_update',
id_=link_id,
origin_id=actor.id),
data={
'description':
'Infinite Space - Infinite Terror',
'activity': 'P23'
},
follow_redirects=True)
assert b'Infinite Space - Infinite Terror' in rv.data
rv = self.app.get(url_for('view', id_=actor.id))
assert b'Appears first' in rv.data
rv = self.app.get(url_for('view', id_=event_id))
assert b'Infinite Space - Infinite Terror' in rv.data
def get_all_links_inverse(entities: Union[int, list[int]]) -> list[Link]:
links_inverse = []
for link in Link.get_links(entities, list(g.properties), inverse=True):
links_inverse.append(link)
return links_inverse
def get_all_links(entities: Union[int, list[int]]) -> list[Link]:
links = []
for link in Link.get_links(entities, list(g.properties)):
links.append(link)
return links
def get_all_links_inverse(entities: Union[int, list[int]]) -> list[Link]:
return Link.get_links(entities, list(g.properties), inverse=True)
def get_all_links(entities: Union[int, list[int]]) -> list[Link]:
return Link.get_links(entities, list(g.properties))
