contentdb/app/logic/packages.py

206 lines
6.2 KiB
Python
Raw Normal View History

2021-02-02 22:35:29 +01:00
# ContentDB
# Copyright (C) 2021 rubenwardy
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
import json
2021-02-03 00:58:59 +01:00
import re
2023-06-18 23:21:37 +02:00
import typing
2021-02-03 00:58:59 +01:00
import validators
2023-06-18 23:21:37 +02:00
from flask_babel import lazy_gettext, LazyString
2021-02-02 22:35:29 +01:00
from app.logic.LogicError import LogicError
2021-12-20 22:07:12 +01:00
from app.models import User, Package, PackageType, MetaPackage, Tag, ContentWarning, db, Permission, AuditSeverity, \
License, UserRank, PackageDevState
2023-06-19 22:27:49 +02:00
from app.utils import add_audit_log, has_blocked_domains, diff_dictionaries, describe_difference
from app.utils.url import clean_youtube_url
2021-02-02 22:35:29 +01:00
2023-06-18 23:21:37 +02:00
def check(cond: bool, msg: typing.Union[str, LazyString]):
2021-02-02 23:34:51 +01:00
if not cond:
raise LogicError(400, msg)
def get_license(name):
if type(name) == License:
return name
license = License.query.filter(License.name.ilike(name)).first()
if license is None:
2022-01-14 19:25:28 +01:00
raise LogicError(400, "Unknown license " + name)
2021-02-02 23:34:51 +01:00
return license
name_re = re.compile("^[a-z0-9_]+$")
AnyType = "?"
2021-02-02 23:47:46 +01:00
ALLOWED_FIELDS = {
"type": AnyType,
2021-02-02 23:34:51 +01:00
"title": str,
2021-02-02 23:47:46 +01:00
"name": str,
2021-02-02 23:34:51 +01:00
"short_description": str,
"short_desc": str,
2021-12-20 22:07:12 +01:00
"dev_state": AnyType,
2021-02-02 23:34:51 +01:00
"tags": list,
"content_warnings": list,
"license": AnyType,
"media_license": AnyType,
"long_description": str,
2021-02-02 23:47:46 +01:00
"desc": str,
2021-02-02 23:34:51 +01:00
"repo": str,
"website": str,
"issue_tracker": str,
"issueTracker": str,
"forums": int,
"video_url": str,
2023-03-05 19:13:07 +01:00
"donate_url": str,
"translation_url": str,
2021-02-02 23:34:51 +01:00
}
ALIASES = {
"short_description": "short_desc",
"issue_tracker": "issueTracker",
"long_description": "desc"
}
2021-02-02 23:34:51 +01:00
def is_int(val):
try:
int(val)
return True
except ValueError:
return False
def validate(data: dict):
2021-02-02 23:47:46 +01:00
for key, value in data.items():
if value is not None:
typ = ALLOWED_FIELDS.get(key)
check(typ is not None, key + " is not a known field")
if typ != AnyType:
2021-02-02 23:47:46 +01:00
check(isinstance(value, typ), key + " must be a " + typ.__name__)
2021-02-02 23:34:51 +01:00
if "name" in data:
name = data["name"]
check(isinstance(name, str), "Name must be a string")
check(bool(name_re.match(name)),
2022-01-14 19:25:28 +01:00
lazy_gettext("Name can only contain lower case letters (a-z), digits (0-9), and underscores (_)"))
2021-02-02 23:34:51 +01:00
for key in ["repo", "website", "issue_tracker", "issueTracker"]:
value = data.get(key)
if value is not None:
check(value.startswith("http://") or value.startswith("https://"),
key + " must start with http:// or https://")
check(validators.url(value, public=True), key + " must be a valid URL")
def do_edit_package(user: User, package: Package, was_new: bool, was_web: bool, data: dict,
reason: str = None):
if not package.check_perm(user, Permission.EDIT_PACKAGE):
raise LogicError(403, lazy_gettext("You don't have permission to edit this package"))
2021-02-02 23:34:51 +01:00
2021-02-02 22:35:29 +01:00
if "name" in data and package.name != data["name"] and \
not package.check_perm(user, Permission.CHANGE_NAME):
raise LogicError(403, lazy_gettext("You don't have permission to change the package name"))
2021-02-02 22:35:29 +01:00
before_dict = None
if not was_new:
before_dict = package.as_dict("/")
for alias, to in ALIASES.items():
2021-02-02 22:35:29 +01:00
if alias in data:
data[to] = data[alias]
2021-02-02 23:34:51 +01:00
validate(data)
for field in ["short_desc", "desc", "website", "issueTracker", "repo", "video_url", "donate_url", "translation_url"]:
2023-01-03 13:17:01 +01:00
if field in data and has_blocked_domains(data[field], user.username,
f"{field} of {package.get_id()}"):
2023-01-12 17:43:08 +01:00
raise LogicError(403, lazy_gettext("Linking to blocked sites is not allowed"))
2023-01-03 13:17:01 +01:00
2021-02-02 23:34:51 +01:00
if "type" in data:
data["type"] = PackageType.coerce(data["type"])
2021-12-20 22:07:12 +01:00
if "dev_state" in data:
data["dev_state"] = PackageDevState.coerce(data["dev_state"])
2021-02-02 23:34:51 +01:00
if "license" in data:
data["license"] = get_license(data["license"])
if "media_license" in data:
data["media_license"] = get_license(data["media_license"])
2022-01-26 00:32:51 +01:00
if "video_url" in data and data["video_url"] is not None:
data["video_url"] = clean_youtube_url(data["video_url"]) or data["video_url"]
2022-01-26 00:28:38 +01:00
if "dQw4w9WgXcQ" in data["video_url"]:
raise LogicError(403, "Never gonna give you up / Never gonna let you down / Never gonna run around and desert you")
2021-12-20 22:07:12 +01:00
for key in ["name", "title", "short_desc", "desc", "type", "dev_state", "license", "media_license",
"repo", "website", "issueTracker", "forums", "video_url", "donate_url", "translation_url"]:
2021-02-02 22:35:29 +01:00
if key in data:
setattr(package, key, data[key])
if package.type == PackageType.TXP:
package.license = package.media_license
if was_new and package.type == PackageType.MOD:
m = MetaPackage.GetOrCreate(package.name, {})
package.provides.append(m)
2021-02-02 23:34:51 +01:00
if "tags" in data:
old_tags = list(package.tags)
2021-02-02 23:34:51 +01:00
package.tags.clear()
for tag_id in (data["tags"] or []):
2021-02-02 23:34:51 +01:00
if is_int(tag_id):
tag = Tag.query.get(tag_id)
2021-02-02 23:34:51 +01:00
else:
tag = Tag.query.filter_by(name=tag_id).first()
if tag is None:
raise LogicError(400, "Unknown tag: " + tag_id)
package.tags.append(tag)
2021-02-02 22:35:29 +01:00
if "content_warnings" in data:
package.content_warnings.clear()
for warning_id in (data["content_warnings"] or []):
2021-02-02 23:34:51 +01:00
if is_int(warning_id):
package.content_warnings.append(ContentWarning.query.get(warning_id))
else:
warning = ContentWarning.query.filter_by(name=warning_id).first()
if warning is None:
raise LogicError(400, "Unknown warning: " + warning_id)
package.content_warnings.append(warning)
2021-02-02 22:35:29 +01:00
if not was_new:
after_dict = package.as_dict("/")
diff = diff_dictionaries(before_dict, after_dict)
2021-02-02 22:35:29 +01:00
if reason is None:
msg = "Edited {}".format(package.title)
else:
msg = "Edited {} ({})".format(package.title, reason)
diff_desc = describe_difference(diff, 100 - len(msg) - 3) if diff else None
if diff_desc:
msg += " [" + diff_desc + "]"
2021-02-02 22:35:29 +01:00
severity = AuditSeverity.NORMAL if user in package.maintainers else AuditSeverity.EDITOR
2023-06-19 22:27:49 +02:00
add_audit_log(severity, user, msg, package.get_url("packages.view"), package, json.dumps(diff, indent=4))
2021-02-02 22:35:29 +01:00
db.session.commit()
return package