def file_preview(entity_id: int) -> str:
size = app.config['IMAGE_SIZE']['table']
parameter = f"loading='lazy' alt='image' width='{size}'"
if icon_path := get_file_path(entity_id,
app.config['IMAGE_SIZE']['table']):
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' {parameter}>"
def file_preview(entity_id: int) -> str:
icon_path = get_file_path(entity_id, app.config['IMAGE_SIZE']['table'])
size = app.config['IMAGE_SIZE']['table']
parameter = f"loading='lazy' alt='image' width='{size}'"
if icon_path:
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' {parameter}>"
path = get_file_path(entity_id)
if path and ImageProcessing.check_processed_image(path.name):
icon_path = get_file_path(entity_id, app.config['IMAGE_SIZE']['table'])
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' {parameter}>"
return ''
def file_preview(entity_id: int) -> str:
icon_path = get_file_path(entity_id, app.config['IMAGE_SIZE']['table'])
size = app.config['IMAGE_SIZE']['table']
if icon_path:
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' loading='lazy'>" ""
path = get_file_path(entity_id)
if not path:
return ''
if ImageProcessing.check_processed_image(path.name):
icon_path = get_file_path(entity_id, app.config['IMAGE_SIZE']['table'])
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' loading='lazy' alt='image'>"
return ''
def __init__(self, row) -> None:
self.id = row.id
self.name = row.name if hasattr(row, 'name') else ''
self.image_id = row.image_id
self.place_id = row.place_id
self.bounding_box = row.bounding_box
path = get_file_path(row.image_id)
self.image_name = os.path.basename(path) if path else False
def __init__(self, row: Dict[str, Any]) -> None:
self.id = row['id']
self.name = row['name'] if 'name' in row else ''
self.image_id = row['image_id']
self.place_id = row['place_id']
self.bounding_box = row['bounding_box']
path = get_file_path(row['image_id'])
self.image_name = path.name if path else False
def display_profile_image(self, image_id):
if not image_id:
return ''
src = url_for('display_file', filename=os.path.basename(get_file_path(image_id)))
return """
<div id="profile_image_div">
<a href="/file/view/{id}">
<img style="max-width:{width}px;" alt="profile image" src="{src}" />
</a>
</div>""".format(id=image_id, src=src, width=session['settings']['profile_image_width'])
def file_delete(id_=None):
g.cursor.execute('BEGIN')
try:
EntityMapper.delete(id_)
logger.log_user(id_, 'delete')
g.cursor.execute('COMMIT')
except Exception as e: # pragma: no cover
g.cursor.execute('ROLLBACK')
logger.log('error', 'database', 'transaction failed', e)
flash(_('error transaction'), 'error')
try:
path = get_file_path(id_)
if path:
os.remove(get_file_path(id_))
except Exception as e: # pragma: no cover
logger.log('error', 'file', 'file deletion failed', e)
flash(_('error file delete'), 'error')
flash(_('entity deleted'), 'info')
return redirect(url_for('file_index'))
def admin_logo(action: Optional[str] = None) -> str:
if action == 'remove':
SettingsMapper.set_logo()
return redirect(url_for('admin_logo'))
if session['settings']['logo_file_id']:
path = get_file_path(int(session['settings']['logo_file_id']))
return render_template('admin/logo.html',
filename=os.path.basename(path) if path else False)
form = LogoForm()
if form.validate_on_submit():
SettingsMapper.set_logo(form.file.data)
return redirect(url_for('admin_logo'))
return render_template('admin/logo.html', form=form)
def display_profile_image(self, image_id: int) -> str:
if not image_id:
return ''
src = url_for('display_file',
filename=os.path.basename(get_file_path(image_id)))
return """
<div id="profile_image_div">
<a href="/file/view/{id}">
<img style="max-width:{width}px;" alt="profile image" src="{src}" />
</a>
</div>
""".format(id=image_id,
src=src,
width=session['settings']['profile_image_width'])
def admin_orphans() -> str:
header = ['name', 'class', 'type', 'system type', 'created', 'updated', 'description']
tables = {'orphans': Table(header),
'unlinked': Table(header),
'missing_files': Table(header),
'circular': Table(['entity']),
'nodes': Table(['name', 'root']),
'orphaned_files': Table(['name', 'size', 'date', 'ext'])}
tables['circular'].rows = [[link(entity)] for entity in EntityMapper.get_circular()]
for entity in EntityMapper.get_orphans():
name = 'unlinked' if entity.class_.code in app.config['CODE_CLASS'].keys() else 'orphans'
tables[name].rows.append([link(entity),
link(entity.class_),
entity.print_base_type(),
entity.system_type,
format_date(entity.created),
format_date(entity.modified),
truncate_string(entity.description)])
for node in NodeMapper.get_orphans():
tables['nodes'].rows.append([link(node), link(g.nodes[node.root[-1]])])
# Get orphaned file entities (no corresponding file)
file_ids = []
for entity in EntityMapper.get_by_system_type('file', nodes=True):
file_ids.append(str(entity.id))
if not get_file_path(entity):
tables['missing_files'].rows.append([link(entity),
link(entity.class_),
entity.print_base_type(),
entity.system_type,
format_date(entity.created),
format_date(entity.modified),
truncate_string(entity.description)])
# Get orphaned files (no corresponding entity)
for file in os.scandir(app.config['UPLOAD_FOLDER_PATH']):
name = file.name
if name != '.gitignore' and splitext(file.name)[0] not in file_ids:
confirm = ' onclick="return confirm(\'' + _('Delete %(name)s?', name=name) + '\')"'
tables['orphaned_files'].rows.append([
name,
convert_size(file.stat().st_size),
format_date(datetime.datetime.utcfromtimestamp(file.stat().st_ctime)),
splitext(name)[1],
'<a href="' + url_for('download_file', filename=name) + '">' + uc_first(
_('download')) + '</a>',
'<a href="' + url_for('admin_file_delete', filename=name) + '" ' +
confirm + '>' + uc_first(_('delete')) + '</a>'])
return render_template('admin/orphans.html', tables=tables)
def file_delete(id_: Optional[int] = None) -> str:
try:
EntityMapper.delete(id_)
logger.log_user(id_, 'delete')
except Exception as e: # pragma: no cover
logger.log('error', 'database', 'Deletion failed', e)
flash(_('error database'), 'error')
try:
path = get_file_path(id_)
if path:
os.remove(path)
except Exception as e: # pragma: no cover
logger.log('error', 'file', 'file deletion failed', e)
flash(_('error file delete'), 'error')
flash(_('entity deleted'), 'info')
return redirect(url_for('file_index'))
def get_file(links_inverse: List[Link]) -> Optional[List[Dict[str, str]]]:
files = []
for link in links_inverse:
if link.domain.class_.name != 'file':
continue
path = get_file_path(link.domain.id)
files.append({
'@id':
url_for('api.entity', id_=link.domain.id, _external=True),
'title':
link.domain.name,
'license':
get_license(link.domain),
'url':
url_for('api.display', filename=path.name, _external=True)
if path else "N/A"
})
return files if files else None
def get_file(
links_inverse: list[Link],
parser: dict[str, Any]) -> list[dict[str, Any]]:
files = []
for link in links_inverse:
if link.domain.class_.name != 'file':
continue
path = get_file_path(link.domain.id)
files.append({
'id': link.domain.id,
'name': link.domain.name,
'fileName': path.name if path else None,
'license': get_license(link.domain),
'source':
link.domain.description if link.domain.description else None})
if parser['format'] == 'xml':
return [{'file': file} for file in files]
return files
def file_view(id_, unlink_id=None):
file = EntityMapper.get_by_id(id_)
if unlink_id:
LinkMapper.delete_by_id(unlink_id)
flash(_('link removed'), 'info')
path = get_file_path(file.id)
tables = {'info': get_entity_data(file)}
for name in [
'source', 'event', 'actor', 'place', 'feature',
'stratigraphic-unit', 'find', 'reference'
]:
header = app.config['TABLE_HEADERS'][name] + (['page'] if name
== 'reference' else [])
tables[name] = {'id': name, 'data': [], 'header': header}
for link_ in file.get_links('P67'):
view_name = get_view_name(link_.range)
view_name = view_name if view_name != 'place' else link_.range.system_type.replace(
' ', '-')
data = get_base_table_data(link_.range)
if is_authorized('editor'):
unlink_url = url_for('file_view', id_=file.id,
unlink_id=link_.id) + '#tab-' + view_name
data.append(display_remove_link(unlink_url, link_.range.name))
tables[view_name]['data'].append(data)
for link_ in file.get_links('P67', True):
data = get_base_table_data(link_.domain)
data.append(link_.description)
if is_authorized('editor'):
update_url = url_for('reference_link_update',
link_id=link_.id,
origin_id=file.id)
data.append('<a href="' + update_url + '">' + uc_first(_('edit')) +
'</a>')
unlink_url = url_for('file_view', id_=file.id,
unlink_id=link_.id) + '#tab-reference'
data.append(display_remove_link(unlink_url, link_.domain.name))
tables['reference']['data'].append(data)
return render_template(
'file/view.html',
missing_file=False if path else True,
entity=file,
tables=tables,
preview=True if path and preview_file(path) else False,
filename=os.path.basename(path) if path else False)
def file_view(id_: int) -> str:
file = EntityMapper.get_by_id(id_, nodes=True)
path = get_file_path(file.id)
tables = {'info': get_entity_data(file)}
for name in [
'source', 'event', 'actor', 'place', 'feature',
'stratigraphic-unit', 'find', 'reference'
]:
tables[name] = Table(Table.HEADERS[name] +
(['page'] if name == 'reference' else []))
for link_ in file.get_links('P67'):
range_ = link_.range
data = get_base_table_data(range_)
view_name = range_.view_name
view_name = view_name if view_name != 'place' else range_.system_type.replace(
' ', '-')
if is_authorized('contributor'):
url = url_for('link_delete', id_=link_.id, origin_id=file.id)
data.append(
display_remove_link(url + '#tab-' + view_name, range_.name))
tables[view_name].rows.append(data)
for link_ in file.get_links('P67', True):
data = get_base_table_data(link_.domain)
data.append(link_.description)
if is_authorized('contributor'):
update_url = url_for('reference_link_update',
link_id=link_.id,
origin_id=file.id)
data.append('<a href="' + update_url + '">' + uc_first(_('edit')) +
'</a>')
unlink_url = url_for('link_delete',
id_=link_.id,
origin_id=file.id)
data.append(
display_remove_link(unlink_url + '#tab-reference',
link_.domain.name))
tables['reference'].rows.append(data)
return render_template(
'file/view.html',
missing_file=False if path else True,
entity=file,
tables=tables,
preview=True if path and preview_file(path) else False,
filename=os.path.basename(path) if path else False)
def add_tabs_for_file(entity: Entity) -> dict[str, Tab]:
tabs = {}
for name in [
'source', 'event', 'actor', 'place', 'feature',
'stratigraphic_unit', 'artifact', 'human_remains', 'reference',
'type']:
tabs[name] = Tab(name, entity=entity)
entity.image_id = entity.id if get_file_path(entity.id) else None
for link_ in entity.get_links('P67'):
range_ = link_.range
data = get_base_table_data(range_)
data.append(
remove_link(range_.name, link_, entity, range_.class_.name))
tabs[range_.class_.view].table.rows.append(data)
for link_ in entity.get_links('P67', True):
data = get_base_table_data(link_.domain)
data.append(link_.description)
data.append(edit_link(
url_for('link_update', id_=link_.id, origin_id=entity.id)))
data.append(remove_link(link_.domain.name, link_, entity, 'reference'))
tabs['reference'].table.rows.append(data)
return tabs
])
else:
classes = 'place' if view == 'place' else g.view_class_mapping[view]
entities = Entity.get_by_class(classes, types=True, aliases=True)
table.rows = [get_base_table_data(entity) for entity in entities]
return table
def file_preview(entity_id: int) -> str:
size = app.config['IMAGE_SIZE']['table']
parameter = f"loading='lazy' alt='image' width='{size}'"
if icon_path := get_file_path(entity_id,
app.config['IMAGE_SIZE']['table']):
url = url_for('display_file', filename=icon_path.name, size=size)
return f"<img src='{url}' {parameter}>"
path = get_file_path(entity_id)
if path and check_processed_image(path.name):
if icon := get_file_path(entity_id, app.config['IMAGE_SIZE']['table']):
url = url_for('display_file', filename=icon.name, size=size)
return f"<img src='{url}' {parameter}>"
return ''
def delete_entity(id_: int) -> Optional[str]:
url = None
entity = Entity.get_by_id(id_)
if not is_authorized(entity.class_.write_access):
abort(403) # pragma: no cover
if isinstance(entity, ReferenceSystem):
if entity.system:
abort(403)
def admin_orphans(delete=None):
if delete:
count = EntityMapper.delete_orphans(delete)
flash(_('info orphans deleted:') + ' ' + str(count), 'info')
return redirect(url_for('admin_orphans'))
header = [
'name', 'class', 'type', 'system type', 'created', 'updated',
'description'
]
tables = {
'orphans': {
'id': 'orphans',
'header': header,
'data': []
},
'unlinked': {
'id': 'unlinked',
'header': header,
'data': []
},
'nodes': {
'id': 'nodes',
'header': ['name', 'root'],
'data': []
},
'missing_files': {
'id': 'missing_files',
'header': header,
'data': []
},
'orphaned_files': {
'id': 'orphaned_files',
'data': [],
'header': ['name', 'size', 'date', 'ext']
}
}
for entity in EntityMapper.get_orphans():
name = 'unlinked' if entity.class_.code in app.config[
'CODE_CLASS'].keys() else 'orphans'
tables[name]['data'].append([
link(entity),
link(entity.class_),
entity.print_base_type(), entity.system_type,
format_date(entity.created),
format_date(entity.modified),
truncate_string(entity.description)
])
for node in NodeMapper.get_orphans():
tables['nodes']['data'].append(
[link(node), link(g.nodes[node.root[-1]])])
file_ids = []
# Get orphaned file entities (no corresponding file)
for entity in EntityMapper.get_by_system_type('file'):
file_ids.append(str(entity.id))
if not get_file_path(entity):
tables['missing_files']['data'].append([
link(entity),
link(entity.class_),
entity.print_base_type(), entity.system_type,
format_date(entity.created),
format_date(entity.modified),
truncate_string(entity.description)
])
# Get orphaned files (no corresponding entity)
path = app.config['UPLOAD_FOLDER_PATH']
for file in [
f for f in os.listdir(path)
if os.path.isfile(os.path.join(path, f))
]:
name = basename(file)
file_path = path + '/' + name
if name != '.gitignore' and splitext(name)[0] not in file_ids:
tables['orphaned_files']['data'].append([
name,
convert_size(os.path.getsize(file_path)),
format_date(
datetime.datetime.fromtimestamp(
os.path.getmtime(file_path))),
splitext(name)[1],
'<a href="' + url_for('download_file', filename=name) + '">' +
uc_first(_('download')) + '</a>'
])
return render_template('admin/orphans.html', tables=tables)
def delete_files(id_: int) -> None:
path = get_file_path(id_)
if path: # Only delete existing files to prevent a missing file error
path.unlink()
for path in app.config['RESIZED_IMAGES'].glob(f'**/{id_}.*'):
path.unlink()
def admin_orphans() -> str:
header = [
'name', 'class', 'type', 'system type', 'created', 'updated',
'description'
]
tabs = {
'orphans':
Tab('orphans', table=Table(header)),
'unlinked':
Tab('unlinked', table=Table(header)),
'types':
Tab('type',
table=Table(
['name', 'root'],
[[link(type_), link(g.types[type_.root[0]])]
for type_ in Type.get_type_orphans()])),
'missing_files':
Tab('missing_files', table=Table(header)),
'orphaned_files':
Tab('orphaned_files', table=Table(['name', 'size', 'date', 'ext'])),
'circular':
Tab('circular_dependencies',
table=Table(['entity'],
[[link(e)]
for e in Entity.get_entities_linked_to_itself()]))
}
for entity in filter(lambda x: not isinstance(x, ReferenceSystem),
Entity.get_orphans()):
tabs['unlinked' if entity.class_.
view else 'orphans'].table.rows.append([
link(entity),
link(entity.class_),
link(entity.standard_type), entity.class_.label,
format_date(entity.created),
format_date(entity.modified), entity.description
])
# Orphaned file entities with no corresponding file
entity_file_ids = []
for entity in Entity.get_by_class('file', types=True):
entity_file_ids.append(entity.id)
if not get_file_path(entity):
tabs['missing_files'].table.rows.append([
link(entity),
link(entity.class_),
link(entity.standard_type), entity.class_.label,
format_date(entity.created),
format_date(entity.modified), entity.description
])
# Orphaned files with no corresponding entity
for file in app.config['UPLOAD_DIR'].iterdir():
if file.name != '.gitignore' \
and os.path.isfile(file) \
and int(file.stem) not in entity_file_ids:
tabs['orphaned_files'].table.rows.append([
file.stem,
convert_size(file.stat().st_size),
format_date(
datetime.datetime.utcfromtimestamp(file.stat().st_ctime)),
file.suffix,
link(_('download'), url_for('download_file',
filename=file.name)),
delete_link(file.name,
url_for('admin_file_delete', filename=file.name))
])
for tab in tabs.values():
tab.buttons = [manual('admin/data_integrity_checks')]
if not tab.table.rows:
tab.content = _('Congratulations, everything looks fine!')
if tabs['orphaned_files'].table.rows and is_authorized('admin'):
text = uc_first(_('delete all files without corresponding entities?'))
tabs['orphaned_files'].buttons.append(
button(_('delete all files'),
url_for('admin_file_delete', filename='all'),
onclick=f"return confirm('{text}')"))
return render_template(
'tabs.html',
tabs=tabs,
title=_('admin'),
crumbs=[[_('admin'), f"{url_for('admin_index')}#tab-data"],
_('orphans')])
def entity_view(id_: int) -> Union[str, Response]:
if id_ in g.nodes: # Nodes have their own view
entity = g.nodes[id_]
if not entity.root:
if entity.class_.name == 'administrative_unit':
tab_hash = '#menu-tab-places_collapse-'
elif entity.standard:
tab_hash = '#menu-tab-standard_collapse-'
elif entity.value_type:
tab_hash = '#menu-tab-value_collapse-'
else:
tab_hash = '#menu-tab-custom_collapse-'
return redirect(f"{url_for('node_index')}{tab_hash}{id_}")
elif id_ in g.reference_systems:
entity = g.reference_systems[id_]
else:
entity = Entity.get_by_id(id_, nodes=True, aliases=True)
if not entity.class_.view:
flash(_("This entity can't be viewed directly."), 'error')
abort(400)
event_links = None # Needed for actor
overlays = None # Needed for place
tabs = {'info': Tab('info')}
if isinstance(entity, Node):
tabs['subs'] = Tab('subs', entity=entity)
tabs['entities'] = Tab('entities', entity=entity)
root = g.nodes[entity.root[-1]] if entity.root else None
if root and root.value_type: # pragma: no cover
tabs['entities'].table.header = [
_('name'), _('value'),
_('class'), _('info')
]
for item in entity.get_linked_entities(['P2', 'P89'],
inverse=True,
nodes=True):
if item.class_.name in ['location', 'reference_system']:
continue # pragma: no cover
if item.class_.name == 'object_location': # pragma: no cover
item = item.get_linked_entity_safe('P53', inverse=True)
data = [link(item)]
if root and root.value_type: # pragma: no cover
data.append(format_number(item.nodes[entity]))
data.append(item.class_.label)
data.append(item.description)
tabs['entities'].table.rows.append(data)
for sub_id in entity.subs:
sub = g.nodes[sub_id]
tabs['subs'].table.rows.append(
[link(sub), sub.count, sub.description])
if not tabs['entities'].table.rows:
# If no entities available get links with this type_id
tabs['entities'].table.header = [_('domain'), _('range')]
for row in Link.get_entities_by_node(entity):
tabs['entities'].table.rows.append([
link(Entity.get_by_id(row['domain_id'])),
link(Entity.get_by_id(row['range_id']))
])
elif isinstance(entity, ReferenceSystem):
for form_id, form in entity.get_forms().items():
tabs[form['name']] = Tab(form['name'], entity=entity)
tabs[form['name']].table = \
Table([_('entity'), 'id', _('precision')])
for link_ in entity.get_links('P67'):
name = link_.description
if entity.resolver_url:
name = \
f'<a href="{entity.resolver_url + name}"' \
f' target="_blank" rel="noopener noreferrer">{name}</a>'
tab_name = link_.range.class_.name
tabs[tab_name].table.rows.append(
[link(link_.range), name, link_.type.name])
for form_id, form in entity.get_forms().items():
tabs[form['name']].buttons = []
if not tabs[form['name']].table.rows and is_authorized('manager'):
tabs[form['name']].buttons = [
button(
_('remove'),
url_for('reference_system_remove_form',
system_id=entity.id,
form_id=form_id))
]
elif entity.class_.view == 'actor':
for name in [
'source', 'event', 'relation', 'member_of', 'member',
'artifact'
]:
tabs[name] = Tab(name, entity=entity)
event_links = entity.get_links(['P11', 'P14', 'P22', 'P23', 'P25'],
True)
for link_ in event_links:
event = link_.domain
places = event.get_linked_entities(['P7', 'P26', 'P27'])
link_.object_ = None # Needed for first/last appearance
for place in places:
object_ = place.get_linked_entity_safe('P53', True)
entity.linked_places.append(object_)
link_.object_ = object_
first = link_.first
if not link_.first and event.first:
first = f'<span class="inactive">{event.first}</span>'
last = link_.last
if not link_.last and event.last:
last = f'<span class="inactive">{event.last}</span>'
data = [
link(event), event.class_.label,
_('moved') if link_.property.code == 'P25' else link(
link_.type), first, last, link_.description
]
if link_.property.code == 'P25':
data += ['']
else:
add_edit_link(
data,
url_for('involvement_update',
id_=link_.id,
origin_id=entity.id))
add_remove_link(data, link_.domain.name, link_, entity, 'event')
tabs['event'].table.rows.append(data)
for link_ in entity.get_links('OA7') + entity.get_links('OA7', True):
type_ = ''
if entity.id == link_.domain.id:
related = link_.range
if link_.type:
type_ = link(link_.type.get_name_directed(),
url_for('entity_view', id_=link_.type.id))
else:
related = link_.domain
if link_.type:
type_ = link(link_.type.get_name_directed(True),
url_for('entity_view', id_=link_.type.id))
data = [
type_,
link(related), link_.first, link_.last, link_.description
]
add_edit_link(
data,
url_for('relation_update', id_=link_.id, origin_id=entity.id))
add_remove_link(data, related.name, link_, entity, 'relation')
tabs['relation'].table.rows.append(data)
for link_ in entity.get_links('P107', True):
data = [
link(link_.domain),
link(link_.type), link_.first, link_.last, link_.description
]
add_edit_link(
data,
url_for('member_update', id_=link_.id, origin_id=entity.id))
add_remove_link(data, link_.domain.name, link_, entity,
'member-of')
tabs['member_of'].table.rows.append(data)
if entity.class_.name != 'group':
del tabs['member']
else:
for link_ in entity.get_links('P107'):
data = [
link(link_.range),
link(link_.type), link_.first, link_.last,
link_.description
]
add_edit_link(
data,
url_for('member_update', id_=link_.id,
origin_id=entity.id))
add_remove_link(data, link_.range.name, link_, entity,
'member')
tabs['member'].table.rows.append(data)
for link_ in entity.get_links('P52', True):
data = [
link(link_.domain), link_.domain.class_.label,
link(link_.domain.standard_type), link_.domain.first,
link_.domain.last, link_.domain.description
]
tabs['artifact'].table.rows.append(data)
elif entity.class_.view == 'artifact':
tabs['source'] = Tab('source', entity=entity)
elif entity.class_.view == 'event':
for name in ['subs', 'source', 'actor']:
tabs[name] = Tab(name, entity=entity)
for sub_event in entity.get_linked_entities('P117',
inverse=True,
nodes=True):
tabs['subs'].table.rows.append(get_base_table_data(sub_event))
tabs['actor'].table.header.insert(5, _('activity')) # Activity column
for link_ in entity.get_links(['P11', 'P14', 'P22', 'P23']):
first = link_.first
if not link_.first and entity.first:
first = f'<span class="inactive">{entity.first}</span>'
last = link_.last
if not link_.last and entity.last:
last = f'<span class="inactive">{entity.last}</span>'
data = [
link(link_.range), link_.range.class_.label,
link_.type.name if link_.type else '', first, last,
g.properties[link_.property.code].name_inverse,
link_.description
]
add_edit_link(
data,
url_for('involvement_update',
id_=link_.id,
origin_id=entity.id))
add_remove_link(data, link_.range.name, link_, entity, 'actor')
tabs['actor'].table.rows.append(data)
entity.linked_places = [
location.get_linked_entity_safe('P53', True)
for location in entity.get_linked_entities(['P7', 'P26', 'P27'])
]
elif entity.class_.view == 'file':
for name in [
'source', 'event', 'actor', 'place', 'feature',
'stratigraphic_unit', 'artifact', 'human_remains', 'reference',
'type'
]:
tabs[name] = Tab(name, entity=entity)
entity.image_id = entity.id if get_file_path(entity.id) else None
for link_ in entity.get_links('P67'):
range_ = link_.range
data = get_base_table_data(range_)
add_remove_link(data, range_.name, link_, entity,
range_.class_.name)
tabs[range_.class_.view].table.rows.append(data)
for link_ in entity.get_links('P67', True):
data = get_base_table_data(link_.domain)
data.append(link_.description)
add_edit_link(
data,
url_for('reference_link_update',
link_id=link_.id,
origin_id=entity.id))
add_remove_link(data, link_.domain.name, link_, entity,
'reference')
tabs['reference'].table.rows.append(data)
elif entity.class_.view == 'place':
tabs['source'] = Tab('source', entity=entity)
if entity.class_.name == 'place':
tabs['event'] = Tab('event', entity=entity)
tabs['reference'] = Tab('reference', entity=entity)
if entity.class_.name == 'place':
tabs['actor'] = Tab('actor', entity=entity)
tabs['feature'] = Tab('feature', entity=entity)
elif entity.class_.name == 'feature':
tabs['stratigraphic_unit'] = Tab('stratigraphic_unit',
entity=entity)
elif entity.class_.name == 'stratigraphic_unit':
tabs['find'] = Tab('find', entity=entity)
tabs['human_remains'] = Tab('human_remains', entity=entity)
entity.location = entity.get_linked_entity_safe('P53', nodes=True)
event_ids = [] # Keep track of inserted events to prevent doubles
for event in entity.location.get_linked_entities(['P7', 'P26', 'P27'],
inverse=True):
tabs['event'].table.rows.append(get_base_table_data(event))
event_ids.append(event.id)
for event in entity.get_linked_entities('P24', inverse=True):
if event.id not in event_ids: # Don't add again if already in table
tabs['event'].table.rows.append(get_base_table_data(event))
if 'actor' in tabs:
for link_ in entity.location.get_links(['P74', 'OA8', 'OA9'],
inverse=True):
actor = Entity.get_by_id(link_.domain.id)
tabs['actor'].table.rows.append([
link(actor), g.properties[link_.property.code].name,
actor.class_.name, actor.first, actor.last,
actor.description
])
elif entity.class_.view == 'reference':
for name in [
'source', 'event', 'actor', 'place', 'feature',
'stratigraphic_unit', 'human_remains', 'artifact', 'file'
]:
tabs[name] = Tab(name, entity=entity)
for link_ in entity.get_links('P67'):
range_ = link_.range
data = get_base_table_data(range_)
data.append(link_.description)
add_edit_link(
data,
url_for('reference_link_update',
link_id=link_.id,
origin_id=entity.id))
add_remove_link(data, range_.name, link_, entity,
range_.class_.name)
tabs[range_.class_.view].table.rows.append(data)
elif entity.class_.view == 'source':
for name in [
'actor', 'artifact', 'feature', 'event', 'human_remains',
'place', 'stratigraphic_unit', 'text'
]:
tabs[name] = Tab(name, entity=entity)
for text in entity.get_linked_entities('P73', nodes=True):
tabs['text'].table.rows.append([
link(text),
next(iter(text.nodes)).name if text.nodes else '',
text.description
])
for link_ in entity.get_links('P67'):
range_ = link_.range
data = get_base_table_data(range_)
add_remove_link(data, range_.name, link_, entity,
range_.class_.name)
tabs[range_.class_.view].table.rows.append(data)
if entity.class_.view in [
'actor', 'artifact', 'event', 'place', 'source', 'type'
]:
if entity.class_.view != 'reference' and not isinstance(entity, Node):
tabs['reference'] = Tab('reference', entity=entity)
if entity.class_.view == 'artifact':
tabs['event'] = Tab('event', entity=entity)
for link_ in entity.get_links('P25', True):
data = get_base_table_data(link_.domain)
tabs['event'].table.rows.append(data)
tabs['file'] = Tab('file', entity=entity)
entity.image_id = entity.get_profile_image_id()
if entity.class_.view == 'place' and is_authorized('editor') and \
current_user.settings['module_map_overlay']:
tabs['file'].table.header.append(uc_first(_('overlay')))
for link_ in entity.get_links('P67', inverse=True):
domain = link_.domain
data = get_base_table_data(domain)
if domain.class_.view == 'file': # pragma: no cover
extension = data[3]
data.append(
get_profile_image_table_link(domain, entity, extension,
entity.image_id))
if not entity.image_id \
and extension in app.config['DISPLAY_FILE_EXTENSIONS']:
entity.image_id = domain.id
if entity.class_.view == 'place' \
and is_authorized('editor') \
and current_user.settings['module_map_overlay']:
overlays = Overlay.get_by_object(entity)
if extension in app.config['DISPLAY_FILE_EXTENSIONS']:
if domain.id in overlays:
add_edit_link(
data,
url_for('overlay_update',
id_=overlays[domain.id].id))
else:
data.append(
link(
_('link'),
url_for('overlay_insert',
image_id=domain.id,
place_id=entity.id,
link_id=link_.id)))
else: # pragma: no cover
data.append('')
if domain.class_.view not in ['source', 'file']:
data.append(link_.description)
add_edit_link(
data,
url_for('reference_link_update',
link_id=link_.id,
origin_id=entity.id))
if domain.class_.view == 'reference_system':
entity.reference_systems.append(link_)
continue
add_remove_link(data, domain.name, link_, entity,
domain.class_.view)
tabs[domain.class_.view].table.rows.append(data)
structure = None # Needed for place
gis_data = None # Needed for place
if entity.class_.view in ['artifact', 'place']:
structure = get_structure(entity)
if structure:
for item in structure['subunits']:
tabs[item.class_.name].table.rows.append(
get_base_table_data(item))
gis_data = Gis.get_all([entity], structure)
if gis_data['gisPointSelected'] == '[]' \
and gis_data['gisPolygonSelected'] == '[]' \
and gis_data['gisLineSelected'] == '[]' \
and (not structure or not structure['super_id']):
gis_data = {}
if not gis_data:
gis_data = Gis.get_all(entity.linked_places) \
if entity.linked_places else None
entity.info_data = get_entity_data(entity, event_links=event_links)
tabs['note'] = Tab('note', entity=entity)
for note in current_user.get_notes_by_entity_id(entity.id):
data = [
format_date(note['created']),
uc_first(_('public'))
if note['public'] else uc_first(_('private')),
link(User.get_by_id(note['user_id'])), note['text'],
f'<a href="{url_for("note_view", id_=note["id"])}">'
f'{uc_first(_("view"))}</a>'
]
tabs['note'].table.rows.append(data)
if 'file' in tabs and current_user.settings['table_show_icons'] and \
session['settings']['image_processing']:
tabs['file'].table.header.insert(1, uc_first(_('icon')))
for row in tabs['file'].table.rows:
row.insert(
1,
file_preview(
int(row[0].replace('<a href="/entity/',
'').split('"')[0])))
tabs['info'].content = render_template(
'entity/view.html',
buttons=add_buttons(entity),
entity=entity,
gis_data=gis_data,
structure=structure, # Needed for place views
overlays=overlays, # Needed for place views
title=entity.name)
return render_template('tabs.html',
tabs=tabs,
gis_data=gis_data,
crumbs=add_crumbs(entity, structure),
entity=entity)
def delete_files(id_: int) -> None:
if path := get_file_path(id_): # Prevent missing file warning
path.unlink()
