# SPDX-License-Identifier: GPL-3.0-or-later
# Proxy web UI package/library management.
#
# This file is part of Hydrilla&Haketilo.
#
# Copyright (C) 2022 Wojtek Kosior
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#
#
# I, Wojtek Kosior, thereby promise not to sue for violation of this
# file's license. Although I request that you do not make use of this
# code in a proprietary program, I am not going to enforce this in
# court.
"""
.....
"""
import typing as t
from urllib.parse import unquote
import flask
import werkzeug
from ... import item_infos
from .. import state as st
from . import _app
bp = flask.Blueprint('items', __package__)
@bp.route('/packages')
def packages() -> werkzeug.Response:
store = _app.get_haketilo_state().mapping_store()
html = flask.render_template(
'items/packages.html.jinja',
display_infos = store.get_display_infos()
)
return flask.make_response(html, 200)
@bp.route('/libraries')
def libraries() -> werkzeug.Response:
store = _app.get_haketilo_state().resource_store()
html = flask.render_template(
'items/libraries.html.jinja',
display_infos = store.get_display_infos()
)
return flask.make_response(html, 200)
def item_store(state: st.HaketiloState, item_type: item_infos.ItemType) \
-> t.Union[st.MappingStore, st.ResourceStore]:
if item_type == item_infos.ItemType.RESOURCE:
return state.resource_store()
else:
return state.mapping_store()
def show_item(
item_id: str,
item_type: item_infos.ItemType,
errors: t.Mapping[str, bool] = {}
) -> werkzeug.Response:
try:
store = item_store(_app.get_haketilo_state(), item_type)
display_info = store.get(str(item_id)).get_display_info()
html = flask.render_template(
f'items/{item_type.alt_name}_view.html.jinja',
display_info = display_info,
**errors
)
return flask.make_response(html, 200)
except st.MissingItemError:
flask.abort(404)
@bp.route('/libraries/view/<string:item_id>')
def show_library(item_id: str) -> werkzeug.Response:
return show_item(item_id, item_infos.ItemType.RESOURCE)
@bp.route('/packages/view/<string:item_id>')
def show_package(item_id: str) -> werkzeug.Response:
return show_item(item_id, item_infos.ItemType.MAPPING)
def alter_item(item_id: str, item_type: item_infos.ItemType) \
-> werkzeug.Response:
form_data = flask.request.form
action = form_data['action']
try:
store = item_store(_app.get_haketilo_state(), item_type)
item_ref = store.get(item_id)
if action == 'disable_item':
assert isinstance(item_ref, st.MappingRef)
item_ref.update_status(st.EnabledStatus.DISABLED)
elif action == 'unenable_item':
assert isinstance(item_ref, st.MappingRef)
item_ref.update_status(st.EnabledStatus.NO_MARK)
elif action in ('enable_item', 'unfreeze_item'):
assert isinstance(item_ref, st.MappingRef)
item_ref.update_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.NOT_FROZEN,
)
elif action == 'freeze_to_repo':
assert isinstance(item_ref, st.MappingRef)
item_ref.update_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.REPOSITORY,
)
elif action == 'freeze_to_version':
assert isinstance(item_ref, st.MappingRef)
item_ref.update_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.EXACT_VERSION,
)
else:
raise ValueError()
except st.RepoCommunicationError:
return show_item(item_id, item_type, {'repo_communication_error': True})
except st.FileInstallationError:
return show_item(item_id, item_type, {'file_installation_error': True})
except st.ImpossibleSituation:
errors = {'impossible_situation_error': True}
return show_item(item_id, item_type, errors)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(
flask.url_for(f'.show_{item_type.alt_name}', item_id=item_id)
)
@bp.route('/libraries/view/<string:item_id>', methods=['POST'])
def alter_library(item_id: str) -> werkzeug.Response:
return alter_item(item_id, item_infos.ItemType.RESOURCE)
@bp.route('/packages/view/<string:item_id>', methods=['POST'])
def alter_package(item_id: str) -> werkzeug.Response:
return alter_item(item_id, item_infos.ItemType.MAPPING)
ItemVersionDisplayInfo = t.Union[
st.MappingVersionDisplayInfo,
st.ResourceVersionDisplayInfo
]
def item_version_store(
state: st.HaketiloState,
item_type: item_infos.ItemType
) -> t.Union[st.MappingVersionStore, st.ResourceVersionStore]:
if item_type == item_infos.ItemType.RESOURCE:
return state.resource_version_store()
else:
return state.mapping_version_store()
def show_item_version(
item_version_id: str,
item_type: item_infos.ItemType,
errors: t.Mapping[str, bool] = {}
) -> werkzeug.Response:
state = _app.get_haketilo_state()
try:
store = item_version_store(state, item_type)
version_ref = store.get(item_version_id)
display_info = version_ref.get_item_display_info()
this_info: t.Optional[ItemVersionDisplayInfo] = None
for info in display_info.all_versions:
if info.ref == version_ref:
this_info = info
assert this_info is not None
html = flask.render_template(
f'items/{item_type.alt_name}_viewversion.html.jinja',
display_info = display_info,
version_display_info = this_info,
**errors
)
return flask.make_response(html, 200)
except st.MissingItemError:
flask.abort(404)
@bp.route('/libraries/viewversion/<string:item_version_id>')
def show_library_version(item_version_id: str) -> werkzeug.Response:
return show_item_version(item_version_id, item_infos.ItemType.RESOURCE)
@bp.route('/packages/viewversion/<string:item_version_id>')
def show_package_version(item_version_id: str) -> werkzeug.Response:
return show_item_version(item_version_id, item_infos.ItemType.MAPPING)
def alter_item_version(item_version_id: str, item_type: item_infos.ItemType) \
-> werkzeug.Response:
form_data = flask.request.form
action = form_data['action']
try:
store = item_version_store(_app.get_haketilo_state(), item_type)
item_version_ref = store.get(item_version_id)
if action == 'disable_item':
assert isinstance(item_version_ref, st.MappingVersionRef)
item_version_ref.update_mapping_status(st.EnabledStatus.DISABLED)
elif action == 'unenable_item':
assert isinstance(item_version_ref, st.MappingVersionRef)
item_version_ref.update_mapping_status(st.EnabledStatus.NO_MARK)
elif action in ('enable_item_version', 'freeze_to_version'):
assert isinstance(item_version_ref, st.MappingVersionRef)
item_version_ref.update_mapping_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.EXACT_VERSION,
)
elif action == 'unfreeze_item':
assert isinstance(item_version_ref, st.MappingVersionRef)
item_version_ref.update_mapping_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.NOT_FROZEN,
)
elif action == 'freeze_to_repo':
assert isinstance(item_version_ref, st.MappingVersionRef)
item_version_ref.update_mapping_status(
enabled = st.EnabledStatus.ENABLED,
frozen = st.FrozenStatus.REPOSITORY,
)
elif action == 'install_item_version':
item_version_ref.install()
elif action == 'uninstall_item_version':
item_version_ref_after = item_version_ref.uninstall()
if item_version_ref_after is None:
url = flask.url_for(f'.{item_type.alt_name_plural}')
return flask.redirect(url)
else:
return show_item_version(item_version_id, item_type)
else:
raise ValueError()
except st.RepoCommunicationError:
return show_item_version(
item_version_id = item_version_id,
item_type = item_type,
errors = {'repo_communication_error': True}
)
except st.FileInstallationError:
return show_item_version(
item_version_id = item_version_id,
item_type = item_type,
errors = {'file_installation_error': True}
)
except st.ImpossibleSituation:
return show_item_version(
item_version_id = item_version_id,
item_type = item_type,
errors = {'impossible_situation_error': True}
)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(
flask.url_for(
f'.show_{item_type.alt_name}_version',
item_version_id = item_version_id
)
)
@bp.route('/libraries/viewversion/<string:item_version_id>', methods=['POST'])
def alter_library_version(item_version_id: str) -> werkzeug.Response:
return alter_item_version(item_version_id, item_infos.ItemType.RESOURCE)
@bp.route('/packages/viewversion/<string:item_version_id>', methods=['POST'])
def alter_package_version(item_version_id: str) -> werkzeug.Response:
return alter_item_version(item_version_id, item_infos.ItemType.MAPPING)
def show_file(
item_version_id: str,
item_type: item_infos.ItemType,
file_type: str,
name: str,
) -> werkzeug.Response:
if file_type not in ('license', 'web_resource'):
flask.abort(404)
try:
store = item_version_store(_app.get_haketilo_state(), item_type)
item_version_ref = store.get(item_version_id)
try:
if file_type == 'license':
file_data = item_version_ref.get_license_file(name)
else:
assert isinstance(item_version_ref, st.ResourceVersionRef)
file_data = item_version_ref.get_resource_file(name)
return werkzeug.Response(
file_data.contents,
mimetype = file_data.mime_type
)
except st.MissingItemError:
if file_type == 'license':
url = item_version_ref.get_upstream_license_file_url(name)
else:
assert isinstance(item_version_ref, st.ResourceVersionRef)
url = item_version_ref.get_upstream_resource_file_url(name)
return flask.redirect(url)
except st.MissingItemError:
flask.abort(404)
@bp.route('/packages/viewversion/<string:item_version_id>/<string:file_type>/<path:name>')
def show_mapping_file(item_version_id: str, file_type: str, name: str) \
-> werkzeug.Response:
item_type = item_infos.ItemType.MAPPING
return show_file(item_version_id, item_type, file_type, name)
@bp.route('/libraries/viewversion/<string:item_version_id>/<string:file_type>/<path:name>')
def show_resource_file(item_version_id: str, file_type: str, name: str) \
-> werkzeug.Response:
item_type = item_infos.ItemType.RESOURCE
return show_file(item_version_id, item_type, file_type, name)
@bp.route('/libraries/viewdep/<string:item_version_id>/<string:dep_identifier>')
def show_library_dep(item_version_id: str, dep_identifier: str) \
-> werkzeug.Response:
state = _app.get_haketilo_state()
try:
store = state.resource_version_store()
dep_id = store.get(item_version_id).get_dependency(dep_identifier).id
url = flask.url_for('.show_library_version', item_version_id=dep_id)
except st.MissingItemError:
try:
versionless_store = state.resource_store()
item_ref = versionless_store.get_by_identifier(dep_identifier)
url = flask.url_for('.show_library', item_id=item_ref.id)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(url)
@bp.route('/<string:item_type>/viewrequired/<string:item_version_id>/<string:required_identifier>')
def show_required_mapping(
item_type: str,
item_version_id: str,
required_identifier: str
) -> werkzeug.Response:
state = _app.get_haketilo_state()
if item_type not in ('package', 'library'):
flask.abort(404)
found = False
if item_type == 'package':
try:
ref = state.mapping_version_store().get(item_version_id)
mapping_ver_id = ref.get_required_mapping(required_identifier).id
url = flask.url_for(
'.show_package_version',
item_version_id = mapping_ver_id
)
found = True
except st.MissingItemError:
pass
if not found:
try:
versionless_store = state.mapping_store()
mapping_ref = versionless_store\
.get_by_identifier(required_identifier)
url = flask.url_for('.show_package', item_id=mapping_ref.id)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(url)
@bp.route('/package/viewlibrary/<string:item_version_id>/<string:pattern>/<string:lib_identifier>')
def show_package_library(item_version_id: str, pattern: str, lib_identifier: str) \
-> werkzeug.Response:
state = _app.get_haketilo_state()
try:
ref = state.mapping_version_store().get(item_version_id)
try:
resource_ver_ref = \
ref.get_payload_resource(unquote(pattern), lib_identifier)
url = flask.url_for(
'.show_library_version',
item_version_id = resource_ver_ref.id
)
except st.MissingItemError:
resource_ref = state.resource_store().get_by_identifier(
lib_identifier
)
url = flask.url_for('.show_library', item_id=resource_ref.id)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(url)
@bp.route('/package/viewbypayload/<string:payload_id>/<string:package_identifier>')
def show_payload_package(payload_id: str, package_identifier: str) \
-> werkzeug.Response:
state = _app.get_haketilo_state()
try:
ref = state.payload_store().get(payload_id)
try:
mapping_ver_ref = ref.get_display_info().mapping_info.ref
url = flask.url_for(
'.show_package_version',
item_version_id = mapping_ver_ref.id
)
except st.MissingItemError:
mapping_ref = state.mapping_store().get_by_identifier(
package_identifier
)
url = flask.url_for('.show_package', item_id=mapping_ref.id)
except st.MissingItemError:
flask.abort(404)
return flask.redirect(url)
