test/jcloude
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update @frappe.whitelist - @jingrow.whitelist

Browse Source
This commit is contained in:
jingrow 2025-12-23 19:42:34 +08:00
parent 1facfe4eb3
commit ccd83d0a7d
136 changed files with 917 additions and 917 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
press/api/__init__.py
View File

@ -4,17 +4,17 @@ from press.api.client import dashboard_whitelist
from press.utils import get_full_chain_cert_of_domain, get_minified_script, get_minified_script_2, log_error from press.utils import get_full_chain_cert_of_domain, get_minified_script, get_minified_script_2, log_error
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def script(): def script():
return get_minified_script() return get_minified_script()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def script_2(): def script_2():
return get_minified_script_2() return get_minified_script_2()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def handle_suspended_site_redirection(): def handle_suspended_site_redirection():
from press.saas.doctype.product_trial_request.product_trial_request import ( from press.saas.doctype.product_trial_request.product_trial_request import (
get_app_trial_page_url, get_app_trial_page_url,

2
press/api/access.py
View File

@ -6,7 +6,7 @@ from frappe.utils import caching, typing_validations
from press.access import support_access from press.access import support_access
@frappe.whitelist() @jingrow.whitelist()
@caching.redis_cache(ttl=60, user=True) @caching.redis_cache(ttl=60, user=True)
@typing_validations.validate_argument_types @typing_validations.validate_argument_types
def status(doctype: str, docname: str): def status(doctype: str, docname: str):

134
press/api/account.py
View File

@ -36,7 +36,7 @@ if TYPE_CHECKING:
from press.press.doctype.account_request.account_request import AccountRequest from press.press.doctype.account_request.account_request import AccountRequest
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def signup(email: str, product: str | None = None, referrer: str | None = None) -> str: def signup(email: str, product: str | None = None, referrer: str | None = None) -> str:
frappe.utils.validate_email_address(email, True) frappe.utils.validate_email_address(email, True)
@ -73,7 +73,7 @@ def signup(email: str, product: str | None = None, referrer: str | None = None)
return account_request return account_request
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def verify_otp(account_request: str, otp: str) -> str: def verify_otp(account_request: str, otp: str) -> str:
from frappe.auth import get_login_attempt_tracker from frappe.auth import get_login_attempt_tracker
@ -98,7 +98,7 @@ def verify_otp(account_request: str, otp: str) -> str:
return account_request.request_key return account_request.request_key
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def verify_otp_and_login(email: str, otp: str): def verify_otp_and_login(email: str, otp: str):
from frappe.auth import get_login_attempt_tracker from frappe.auth import get_login_attempt_tracker
@ -121,7 +121,7 @@ def verify_otp_and_login(email: str, otp: str):
return frappe.local.login_manager.login_as(email) return frappe.local.login_manager.login_as(email)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
def resend_otp(account_request: str, for_2fa_keys: bool = False): def resend_otp(account_request: str, for_2fa_keys: bool = False):
account_request: "AccountRequest" = frappe.get_pg("Account Request", account_request) account_request: "AccountRequest" = frappe.get_pg("Account Request", account_request)
@ -140,7 +140,7 @@ def resend_otp(account_request: str, for_2fa_keys: bool = False):
account_request.send_otp_mail(for_login=not for_2fa_keys) account_request.send_otp_mail(for_login=not for_2fa_keys)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
def send_otp(email: str, for_2fa_keys: bool = False): def send_otp(email: str, for_2fa_keys: bool = False):
account_request = frappe.db.get_value("Account Request", {"email": email}, "name") account_request = frappe.db.get_value("Account Request", {"email": email}, "name")
@ -161,7 +161,7 @@ def send_otp(email: str, for_2fa_keys: bool = False):
account_request.send_otp_mail(for_login=not for_2fa_keys) account_request.send_otp_mail(for_login=not for_2fa_keys)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def setup_account( # noqa: C901 def setup_account( # noqa: C901
key, key,
first_name=None, first_name=None,
@ -238,7 +238,7 @@ def setup_account( # noqa: C901
return account_request.name return account_request.name
@frappe.whitelist() @jingrow.whitelist()
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def accept_team_invite(key: str): def accept_team_invite(key: str):
account_request = get_account_request_from_key(key) account_request = get_account_request_from_key(key)
@ -261,7 +261,7 @@ def accept_team_invite(key: str):
return team_pg.create_user_for_member(first_name, last_name, email, password, role, press_roles) return team_pg.create_user_for_member(first_name, last_name, email, password, role, press_roles)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def send_login_link(email): def send_login_link(email):
if not frappe.db.exists("User", email): if not frappe.db.exists("User", email):
@ -288,7 +288,7 @@ def send_login_link(email):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def login_using_key(key): def login_using_key(key):
cache_key = f"one_time_login_key:{key}" cache_key = f"one_time_login_key:{key}"
@ -308,13 +308,13 @@ def login_using_key(key):
) )
@frappe.whitelist() @jingrow.whitelist()
def active_servers(): def active_servers():
team = get_current_team() team = get_current_team()
return frappe.get_all("Server", {"team": team, "status": "Active"}, ["title", "name"]) return frappe.get_all("Server", {"team": team, "status": "Active"}, ["title", "name"])
@frappe.whitelist() @jingrow.whitelist()
def disable_account(totp_code: str | None): def disable_account(totp_code: str | None):
user = frappe.session.user user = frappe.session.user
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -331,12 +331,12 @@ def disable_account(totp_code: str | None):
team.disable_account() team.disable_account()
@frappe.whitelist() @jingrow.whitelist()
def has_active_servers(team): def has_active_servers(team):
return frappe.db.exists("Server", {"status": "Active", "team": team}) return frappe.db.exists("Server", {"status": "Active", "team": team})
@frappe.whitelist() @jingrow.whitelist()
def enable_account(): def enable_account():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
if frappe.session.user != team.user: if frappe.session.user != team.user:
@ -344,14 +344,14 @@ def enable_account():
team.enable_account() team.enable_account()
@frappe.whitelist() @jingrow.whitelist()
def request_team_deletion(): def request_team_deletion():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
pg = frappe.get_pg({"doctype": "Team Deletion Request", "team": team.name}).insert() pg = frappe.get_pg({"doctype": "Team Deletion Request", "team": team.name}).insert()
return pg.name return pg.name
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def delete_team(team): def delete_team(team):
from frappe.utils.verified_command import verify_request from frappe.utils.verified_command import verify_request
@ -396,7 +396,7 @@ def delete_team(team):
return respond_as_web_page("confirmed") return respond_as_web_page("confirmed")
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def validate_request_key(key, timezone=None): def validate_request_key(key, timezone=None):
from press.utils.country_timezone import get_country_from_timezone from press.utils.country_timezone import get_country_from_timezone
@ -429,7 +429,7 @@ def validate_request_key(key, timezone=None):
return None return None
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def country_list(): def country_list():
def get_country_list(): def get_country_list():
return frappe.db.get_all("Country", fields=["name", "code"]) return frappe.db.get_all("Country", fields=["name", "code"])
@ -441,7 +441,7 @@ def clear_country_list_cache():
frappe.cache().delete_value("country_list") frappe.cache().delete_value("country_list")
@frappe.whitelist() @jingrow.whitelist()
def set_country(country): def set_country(country):
team_pg = get_current_team(get_pg=True) team_pg = get_current_team(get_pg=True)
team_pg.country = country team_pg.country = country
@ -461,7 +461,7 @@ def get_account_request_from_key(key: str):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def get(): def get():
cached = frappe.cache.get_value("cached-account.get", user=frappe.session.user) cached = frappe.cache.get_value("cached-account.get", user=frappe.session.user)
if cached: if cached:
@ -523,7 +523,7 @@ def _get():
} }
@frappe.whitelist() @jingrow.whitelist()
def current_team(): def current_team():
user = frappe.session.user user = frappe.session.user
if not frappe.db.exists("User", user): if not frappe.db.exists("User", user):
@ -551,7 +551,7 @@ def get_permissions():
return {perm.document_name: perm.actions.split(",") for perm in docperms if perm.actions} return {perm.document_name: perm.actions.split(",") for perm in docperms if perm.actions}
@frappe.whitelist() @jingrow.whitelist()
def has_method_permission(doctype, docname, method) -> bool: def has_method_permission(doctype, docname, method) -> bool:
from press.press.doctype.press_permission_group.press_permission_group import ( from press.press.doctype.press_permission_group.press_permission_group import (
has_method_permission, has_method_permission,
@ -560,7 +560,7 @@ def has_method_permission(doctype, docname, method) -> bool:
return has_method_permission(doctype, docname, method) return has_method_permission(doctype, docname, method)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def signup_settings(product=None, fetch_countries=False, timezone=None): def signup_settings(product=None, fetch_countries=False, timezone=None):
from press.utils.country_timezone import get_country_from_timezone from press.utils.country_timezone import get_country_from_timezone
@ -591,14 +591,14 @@ def signup_settings(product=None, fetch_countries=False, timezone=None):
return data return data
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def guest_feature_flags(): def guest_feature_flags():
return { return {
"enable_google_oauth": frappe.db.get_single_value("Press Settings", "enable_google_oauth"), "enable_google_oauth": frappe.db.get_single_value("Press Settings", "enable_google_oauth"),
} }
@frappe.whitelist() @jingrow.whitelist()
def create_child_team(title): def create_child_team(title):
team = title.strip() team = title.strip()
@ -657,7 +657,7 @@ def get_ssh_key(user):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def update_profile(first_name=None, last_name=None, email=None): def update_profile(first_name=None, last_name=None, email=None):
if email: if email:
frappe.utils.validate_email_address(email, True) frappe.utils.validate_email_address(email, True)
@ -673,7 +673,7 @@ def update_profile(first_name=None, last_name=None, email=None):
return pg return pg
@frappe.whitelist() @jingrow.whitelist()
def update_profile_picture(): def update_profile_picture():
user = frappe.session.user user = frappe.session.user
_file = frappe.get_pg( _file = frappe.get_pg(
@ -692,7 +692,7 @@ def update_profile_picture():
frappe.db.set_value("User", user, "user_image", _file.file_url) frappe.db.set_value("User", user, "user_image", _file.file_url)
@frappe.whitelist() @jingrow.whitelist()
def update_feature_flags(values=None): def update_feature_flags(values=None):
frappe.only_for("Press Admin") frappe.only_for("Press Admin")
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -709,7 +709,7 @@ def update_feature_flags(values=None):
team.save() team.save()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
@mfa.verify(user_key="email", raise_error=True) @mfa.verify(user_key="email", raise_error=True)
def send_reset_password_email(email: str): def send_reset_password_email(email: str):
@ -738,12 +738,12 @@ def send_reset_password_email(email: str):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def reset_password(key, password): def reset_password(key, password):
return update_password(new_password=password, key=key) return update_password(new_password=password, key=key)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=60 * 60) @rate_limit(limit=10, seconds=60 * 60)
def get_user_for_reset_password_key(key): def get_user_for_reset_password_key(key):
if not key or not isinstance(key, str): if not key or not isinstance(key, str):
@ -769,13 +769,13 @@ def get_user_for_reset_password_key(key):
return user_pg.name return user_pg.name
@frappe.whitelist() @jingrow.whitelist()
def remove_team_member(user_email): def remove_team_member(user_email):
team = get_current_team(True) team = get_current_team(True)
team.remove_team_member(user_email) team.remove_team_member(user_email)
@frappe.whitelist() @jingrow.whitelist()
def remove_child_team(child_team): def remove_child_team(child_team):
team = frappe.get_pg("Team", child_team) team = frappe.get_pg("Team", child_team)
sites = frappe.get_all("Site", {"status": ("!=", "Archived"), "team": team.name}, pluck="name") sites = frappe.get_all("Site", {"status": ("!=", "Archived"), "team": team.name}, pluck="name")
@ -787,7 +787,7 @@ def remove_child_team(child_team):
team.save(ignore_permissions=True) team.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def can_switch_to_team(team): def can_switch_to_team(team):
if not frappe.db.exists("Team", team): if not frappe.db.exists("Team", team):
return False return False
@ -798,7 +798,7 @@ def can_switch_to_team(team):
return False return False
@frappe.whitelist() @jingrow.whitelist()
def switch_team(team): def switch_team(team):
user_is_part_of_team = frappe.db.exists("Team Member", {"parent": team, "user": frappe.session.user}) user_is_part_of_team = frappe.db.exists("Team Member", {"parent": team, "user": frappe.session.user})
user_is_system_user = frappe.session.data.user_type == "System User" user_is_system_user = frappe.session.data.user_type == "System User"
@ -812,7 +812,7 @@ def switch_team(team):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def leave_team(team): def leave_team(team):
team_to_leave = frappe.get_pg("Team", team) team_to_leave = frappe.get_pg("Team", team)
cur_team = frappe.session.user cur_team = frappe.session.user
@ -823,7 +823,7 @@ def leave_team(team):
team_to_leave.remove_team_member(cur_team) team_to_leave.remove_team_member(cur_team)
@frappe.whitelist() @jingrow.whitelist()
def get_billing_information(timezone=None): def get_billing_information(timezone=None):
from press.utils.country_timezone import get_country_from_timezone from press.utils.country_timezone import get_country_from_timezone
@ -840,7 +840,7 @@ def get_billing_information(timezone=None):
return billing_details return billing_details
@frappe.whitelist() @jingrow.whitelist()
def update_billing_information(billing_details): def update_billing_information(billing_details):
try: try:
billing_details = frappe._dict(billing_details) billing_details = frappe._dict(billing_details)
@ -883,7 +883,7 @@ def validate_pincode(billing_details):
frappe.throw(f"Postal Code {billing_details.postal_code} is not associated with {billing_details.state}") frappe.throw(f"Postal Code {billing_details.postal_code} is not associated with {billing_details.state}")
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def feedback(team, message, note, rating, route=None): def feedback(team, message, note, rating, route=None):
feedback = frappe.new_pg("Press Feedback") feedback = frappe.new_pg("Press Feedback")
team_pg = frappe.get_pg("Team", team) team_pg = frappe.get_pg("Team", team)
@ -905,12 +905,12 @@ def feedback(team, message, note, rating, route=None):
feedback.insert(ignore_permissions=True) feedback.insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def get_site_count(team): def get_site_count(team):
return frappe.db.count("Site", {"team": team, "status": ("=", "Active")}) return frappe.db.count("Site", {"team": team, "status": ("=", "Active")})
@frappe.whitelist() @jingrow.whitelist()
def user_prompts(): def user_prompts():
if frappe.local.dev_server: if frappe.local.dev_server:
return None return None
@ -966,7 +966,7 @@ def get_frappe_io_auth_url() -> str | None:
return None return None
@frappe.whitelist() @jingrow.whitelist()
def get_emails(): def get_emails():
team = get_current_team(get_pg=False) team = get_current_team(get_pg=False)
return frappe.get_all( return frappe.get_all(
@ -980,7 +980,7 @@ def get_emails():
) )
@frappe.whitelist() @jingrow.whitelist()
def update_emails(data): def update_emails(data):
from frappe.utils import validate_email_address from frappe.utils import validate_email_address
@ -993,19 +993,19 @@ def update_emails(data):
team_pg.save() team_pg.save()
@frappe.whitelist() @jingrow.whitelist()
def add_key(key): def add_key(key):
frappe.get_pg({"doctype": "User SSH Key", "user": frappe.session.user, "ssh_public_key": key}).insert() frappe.get_pg({"doctype": "User SSH Key", "user": frappe.session.user, "ssh_public_key": key}).insert()
@frappe.whitelist() @jingrow.whitelist()
def mark_key_as_default(key_name): def mark_key_as_default(key_name):
key = frappe.get_pg("User SSH Key", key_name) key = frappe.get_pg("User SSH Key", key_name)
key.is_default = True key.is_default = True
key.save() key.save()
@frappe.whitelist() @jingrow.whitelist()
def create_api_secret(): def create_api_secret():
user = frappe.get_pg("User", frappe.session.user) user = frappe.get_pg("User", frappe.session.user)
@ -1022,12 +1022,12 @@ def create_api_secret():
return {"api_key": api_key, "api_secret": api_secret} return {"api_key": api_key, "api_secret": api_secret}
@frappe.whitelist() @jingrow.whitelist()
def me(): def me():
return {"user": frappe.session.user, "team": get_current_team()} return {"user": frappe.session.user, "team": get_current_team()}
@frappe.whitelist() @jingrow.whitelist()
def fuse_list(): def fuse_list():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
query = f""" query = f"""
@ -1055,7 +1055,7 @@ def fuse_list():
# Permissions # Permissions
@frappe.whitelist() @jingrow.whitelist()
def get_permission_options(name, ptype): def get_permission_options(name, ptype):
""" """
[{'doctype': 'Site', 'name': 'ccc.frappe.cloud', title: '', 'perms': 'press.api.site.get'}, ...] [{'doctype': 'Site', 'name': 'ccc.frappe.cloud', title: '', 'perms': 'press.api.site.get'}, ...]
@ -1097,7 +1097,7 @@ def get_permission_options(name, ptype):
return {"options": options, "actions": available_actions()} return {"options": options, "actions": available_actions()}
@frappe.whitelist() @jingrow.whitelist()
def update_permissions(user, ptype, updated): def update_permissions(user, ptype, updated):
values = [] values = []
drop = [] drop = []
@ -1145,12 +1145,12 @@ def update_permissions(user, ptype, updated):
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def groups(): def groups():
return frappe.get_all("Press Permission Group", {"team": get_current_team()}, ["name", "title"]) return frappe.get_all("Press Permission Group", {"team": get_current_team()}, ["name", "title"])
@frappe.whitelist() @jingrow.whitelist()
def permission_group_users(name): def permission_group_users(name):
if get_current_team() != frappe.db.get_value("Press Permission Group", name, "team"): if get_current_team() != frappe.db.get_value("Press Permission Group", name, "team"):
frappe.throw("You are not allowed to view this group") frappe.throw("You are not allowed to view this group")
@ -1158,7 +1158,7 @@ def permission_group_users(name):
return frappe.get_all("Press Permission Group User", {"parent": name}, pluck="user") return frappe.get_all("Press Permission Group User", {"parent": name}, pluck="user")
@frappe.whitelist() @jingrow.whitelist()
def add_permission_group(title): def add_permission_group(title):
pg = frappe.get_pg( pg = frappe.get_pg(
{"doctype": "Press Permission Group", "team": get_current_team(), "title": title} {"doctype": "Press Permission Group", "team": get_current_team(), "title": title}
@ -1166,14 +1166,14 @@ def add_permission_group(title):
return {"name": pg.name, "title": pg.title} return {"name": pg.name, "title": pg.title}
@frappe.whitelist() @jingrow.whitelist()
@protected("Press Permission Group") @protected("Press Permission Group")
def remove_permission_group(name): def remove_permission_group(name):
frappe.db.delete("Press User Permission", {"group": name}) frappe.db.delete("Press User Permission", {"group": name})
frappe.delete_pg("Press Permission Group", name) frappe.delete_pg("Press Permission Group", name)
@frappe.whitelist() @jingrow.whitelist()
@protected("Press Permission Group") @protected("Press Permission Group")
def add_permission_group_user(name, user): def add_permission_group_user(name, user):
pg = frappe.get_pg("Press Permission Group", name) pg = frappe.get_pg("Press Permission Group", name)
@ -1181,7 +1181,7 @@ def add_permission_group_user(name, user):
pg.save(ignore_permissions=True) pg.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
@protected("Press Permission Group") @protected("Press Permission Group")
def remove_permission_group_user(name, user): def remove_permission_group_user(name, user):
pg = frappe.get_pg("Press Permission Group", name) pg = frappe.get_pg("Press Permission Group", name)
@ -1192,7 +1192,7 @@ def remove_permission_group_user(name, user):
break break
@frappe.whitelist() @jingrow.whitelist()
def get_permission_roles(): def get_permission_roles():
PressRole = frappe.qb.DocType("Press Role") PressRole = frappe.qb.DocType("Press Role")
PressRoleUser = frappe.qb.DocType("Press Role User") PressRoleUser = frappe.qb.DocType("Press Role User")
@ -1221,7 +1221,7 @@ def get_permission_roles():
) )
@frappe.whitelist() @jingrow.whitelist()
def get_user_ssh_keys(): def get_user_ssh_keys():
return frappe.db.get_list( return frappe.db.get_list(
"User SSH Key", "User SSH Key",
@ -1231,13 +1231,13 @@ def get_user_ssh_keys():
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=20, seconds=60 * 60) @rate_limit(limit=20, seconds=60 * 60)
def is_2fa_enabled(user: str) -> bool: def is_2fa_enabled(user: str) -> bool:
return bool(frappe.db.get_value("User 2FA", user, "enabled")) return bool(frappe.db.get_value("User 2FA", user, "enabled"))
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def verify_2fa(user, totp_code): def verify_2fa(user, totp_code):
user_totp_secret = get_decrypted_password("User 2FA", user, "totp_secret") user_totp_secret = get_decrypted_password("User 2FA", user, "totp_secret")
@ -1251,7 +1251,7 @@ def verify_2fa(user, totp_code):
return verified return verified
@frappe.whitelist() @jingrow.whitelist()
def get_2fa_qr_code_url(): def get_2fa_qr_code_url():
"""Get the QR code URL for 2FA provisioning""" """Get the QR code URL for 2FA provisioning"""
@ -1272,7 +1272,7 @@ def get_2fa_qr_code_url():
) )
@frappe.whitelist() @jingrow.whitelist()
def enable_2fa(totp_code): def enable_2fa(totp_code):
"""Enable 2FA for the user after verifying the TOTP code""" """Enable 2FA for the user after verifying the TOTP code"""
@ -1314,7 +1314,7 @@ def enable_2fa(totp_code):
] ]
@frappe.whitelist() @jingrow.whitelist()
def disable_2fa(totp_code): def disable_2fa(totp_code):
"""Disable 2FA for the user after verifying the TOTP code""" """Disable 2FA for the user after verifying the TOTP code"""
@ -1329,7 +1329,7 @@ def disable_2fa(totp_code):
frappe.throw("Invalid TOTP code") frappe.throw("Invalid TOTP code")
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def recover_2fa(user: str, recovery_code: str): def recover_2fa(user: str, recovery_code: str):
"""Recover 2FA using a recovery code.""" """Recover 2FA using a recovery code."""
@ -1361,7 +1361,7 @@ def recover_2fa(user: str, recovery_code: str):
two_fa.save(ignore_permissions=True) two_fa.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def get_2fa_recovery_codes(verification_code: int): def get_2fa_recovery_codes(verification_code: int):
"""Get the recovery codes for the user.""" """Get the recovery codes for the user."""
@ -1393,7 +1393,7 @@ def get_2fa_recovery_codes(verification_code: int):
return recovery_codes return recovery_codes
@frappe.whitelist() @jingrow.whitelist()
def reset_2fa_recovery_codes(): def reset_2fa_recovery_codes():
"""Reset the recovery codes for the user.""" """Reset the recovery codes for the user."""
@ -1423,7 +1423,7 @@ def reset_2fa_recovery_codes():
return recovery_codes return recovery_codes
@frappe.whitelist() @jingrow.whitelist()
def get_user_banners(): def get_user_banners():
team = get_current_team() team = get_current_team()
@ -1476,7 +1476,7 @@ def get_user_banners():
return visible_banners return visible_banners
@frappe.whitelist() @jingrow.whitelist()
def dismiss_banner(banner_name): def dismiss_banner(banner_name):
user = frappe.session.user user = frappe.session.user
banner = frappe.get_pg("Dashboard Banner", banner_name) banner = frappe.get_pg("Dashboard Banner", banner_name)

34
press/api/analytics.py
View File

@ -522,7 +522,7 @@ def get_metrics(
frappe.throw("Unable to fetch metrics") frappe.throw("Unable to fetch metrics")
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_fs_read_bytes(name: str, timezone: str, duration: str = "24h"): def get_fs_read_bytes(name: str, timezone: str, duration: str = "24h"):
promql_query = ( promql_query = (
@ -537,7 +537,7 @@ def get_fs_read_bytes(name: str, timezone: str, duration: str = "24h"):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_fs_write_bytes(name: str, timezone: str, duration: str = "24h"): def get_fs_write_bytes(name: str, timezone: str, duration: str = "24h"):
promql_query = ( promql_query = (
@ -552,7 +552,7 @@ def get_fs_write_bytes(name: str, timezone: str, duration: str = "24h"):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_outgoing_network_traffic(name: str, timezone: str, duration: str = "24h"): def get_outgoing_network_traffic(name: str, timezone: str, duration: str = "24h"):
promql_query = 'sum by (name) (rate(container_network_transmit_bytes_total{{job="cadvisor", name=~"{benches}"}}[5m]))' promql_query = 'sum by (name) (rate(container_network_transmit_bytes_total{{job="cadvisor", name=~"{benches}"}}[5m]))'
@ -565,7 +565,7 @@ def get_outgoing_network_traffic(name: str, timezone: str, duration: str = "24h"
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_incoming_network_traffic(name: str, timezone: str, duration: str = "24h"): def get_incoming_network_traffic(name: str, timezone: str, duration: str = "24h"):
promql_query = ( promql_query = (
@ -580,7 +580,7 @@ def get_incoming_network_traffic(name: str, timezone: str, duration: str = "24h"
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_memory_usage(name: str, timezone: str, duration: str = "24h"): def get_memory_usage(name: str, timezone: str, duration: str = "24h"):
promql_query = 'sum by (name) (avg_over_time(container_memory_usage_bytes{{job="cadvisor", name=~"{benches}"}}[5m]) / 1024 / 1024 / 1024)' promql_query = 'sum by (name) (avg_over_time(container_memory_usage_bytes{{job="cadvisor", name=~"{benches}"}}[5m]) / 1024 / 1024 / 1024)'
@ -593,7 +593,7 @@ def get_memory_usage(name: str, timezone: str, duration: str = "24h"):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_cpu_usage(name: str, timezone: str, duration: str = "24h"): def get_cpu_usage(name: str, timezone: str, duration: str = "24h"):
promql_query = ( promql_query = (
@ -608,7 +608,7 @@ def get_cpu_usage(name: str, timezone: str, duration: str = "24h"):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def get(name, timezone, duration="7d"): def get(name, timezone, duration="7d"):
@ -659,7 +659,7 @@ def get_additional_duration_reports(
return reports return reports
@frappe.whitelist() @jingrow.whitelist()
def get_advanced_analytics(name, timezone, duration="7d", max_no_of_paths=MAX_NO_OF_PATHS): def get_advanced_analytics(name, timezone, duration="7d", max_no_of_paths=MAX_NO_OF_PATHS):
timespan, timegrain = TIMESPAN_TIMEGRAIN_MAP[duration] timespan, timegrain = TIMESPAN_TIMEGRAIN_MAP[duration]
@ -714,7 +714,7 @@ def get_advanced_analytics(name, timezone, duration="7d", max_no_of_paths=MAX_NO
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def daily_usage(name, timezone): def daily_usage(name, timezone):
@ -852,7 +852,7 @@ def get_background_job_by_(
).run() ).run()
@frappe.whitelist() @jingrow.whitelist()
def get_slow_logs_by_query( def get_slow_logs_by_query(
name: str, name: str,
agg_type: str, agg_type: str,
@ -1147,7 +1147,7 @@ def get_current_cpu_usage_for_sites_on_server(server):
return result return result
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@site.feature("monitor_access") @site.feature("monitor_access")
def request_logs(site, timezone, date, sort=None, start=0): def request_logs(site, timezone, date, sort=None, start=0):
@ -1214,7 +1214,7 @@ def request_logs(site, timezone, date, sort=None, start=0):
return result return result
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@site.feature("monitor_access") @site.feature("monitor_access")
def binary_logs(site, start_time, end_time, pattern: str = ".*", max_lines: int = 4000): def binary_logs(site, start_time, end_time, pattern: str = ".*", max_lines: int = 4000):
@ -1230,7 +1230,7 @@ def binary_logs(site, start_time, end_time, pattern: str = ".*", max_lines: int
return get_binary_log_data(filters) return get_binary_log_data(filters)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@site.feature("monitor_access") @site.feature("monitor_access")
def mariadb_processlist(site): def mariadb_processlist(site):
@ -1243,7 +1243,7 @@ def mariadb_processlist(site):
return rows return rows
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@site.feature("monitor_access") @site.feature("monitor_access")
def mariadb_slow_queries( def mariadb_slow_queries(
@ -1270,7 +1270,7 @@ def mariadb_slow_queries(
return {"columns": columns, "data": data} return {"columns": columns, "data": data}
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@site.feature("monitor_access") @site.feature("monitor_access")
def deadlock_report(site, start_datetime, stop_datetime, max_log_size=500): def deadlock_report(site, start_datetime, stop_datetime, max_log_size=500):
@ -1289,7 +1289,7 @@ def deadlock_report(site, start_datetime, stop_datetime, max_log_size=500):
# MARKETPLACE - Plausible # MARKETPLACE - Plausible
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@protected("Marketplace App") @protected("Marketplace App")
def plausible_analytics(name): def plausible_analytics(name):
response = {} response = {}
@ -1341,7 +1341,7 @@ def get_doctype_name(table_name: str) -> str:
return table_name.removeprefix("tab") return table_name.removeprefix("tab")
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def mariadb_add_suggested_index(name, table, column): def mariadb_add_suggested_index(name, table, column):
record_exists = frappe.db.exists( record_exists = frappe.db.exists(

2
press/api/app.py
View File

@ -15,7 +15,7 @@ if TYPE_CHECKING:
from press.press.doctype.release_group.release_group import ReleaseGroup from press.press.doctype.release_group.release_group import ReleaseGroup
@frappe.whitelist() @jingrow.whitelist()
def new(app): def new(app):
if isinstance(app, str): if isinstance(app, str):
app = json.loads(app) app = json.loads(app)

106
press/api/bench.py
View File

@ -44,7 +44,7 @@ if TYPE_CHECKING:
from press.press.doctype.deploy_candidate_build.deploy_candidate_build import DeployCandidateBuild from press.press.doctype.deploy_candidate_build.deploy_candidate_build import DeployCandidateBuild
@frappe.whitelist() @jingrow.whitelist()
def new(bench): def new(bench):
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
if not team.enabled: if not team.enabled:
@ -72,7 +72,7 @@ def new(bench):
return group.name return group.name
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get(name): def get(name):
group = frappe.get_pg("Release Group", name) group = frappe.get_pg("Release Group", name)
@ -102,7 +102,7 @@ def get_group_status(name):
return "Active" if active_benches else "Awaiting Deploy" return "Active" if active_benches else "Awaiting Deploy"
@frappe.whitelist() @jingrow.whitelist()
def all(server=None, bench_filter=None): def all(server=None, bench_filter=None):
if bench_filter is None: if bench_filter is None:
bench_filter = {"status": "", "tag": ""} bench_filter = {"status": "", "tag": ""}
@ -163,7 +163,7 @@ def all(server=None, bench_filter=None):
return private_groups return private_groups
@frappe.whitelist() @jingrow.whitelist()
def bench_tags(): def bench_tags():
team = get_current_team() team = get_current_team()
return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Release Group"}, pluck="tag") return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Release Group"}, pluck="tag")
@ -190,13 +190,13 @@ def get_app_counts_for_groups(rg_names):
return app_counts_map return app_counts_map
@frappe.whitelist() @jingrow.whitelist()
def exists(title): def exists(title):
team = get_current_team() team = get_current_team()
return bool(frappe.db.exists("Release Group", {"title": title, "team": team, "enabled": True})) return bool(frappe.db.exists("Release Group", {"title": title, "team": team, "enabled": True}))
@frappe.whitelist() @jingrow.whitelist()
def get_default_apps(): def get_default_apps():
press_settings = frappe.get_single("Press Settings") press_settings = frappe.get_single("Press Settings")
default_apps = press_settings.get_default_apps() default_apps = press_settings.get_default_apps()
@ -249,7 +249,7 @@ def get_app_versions_list(only_frappe=False):
return version_list, rows return version_list, rows
@frappe.whitelist() @jingrow.whitelist()
def options(): def options():
version_list, rows = get_app_versions_list(only_frappe=True) version_list, rows = get_app_versions_list(only_frappe=True)
approved_apps = frappe.get_all("Marketplace App", filters={"frappe_approved": 1}, pluck="app") approved_apps = frappe.get_all("Marketplace App", filters={"frappe_approved": 1}, pluck="app")
@ -287,7 +287,7 @@ def options():
return {"versions": versions, "clusters": clusters} return {"versions": versions, "clusters": clusters}
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def bench_config(name): def bench_config(name):
rg = frappe.get_pg("Release Group", name) rg = frappe.get_pg("Release Group", name)
@ -321,7 +321,7 @@ def bench_config(name):
return config return config
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def update_config(name, config): def update_config(name, config):
sanitized_common_site_config, sanitized_bench_config = [], [] sanitized_common_site_config, sanitized_bench_config = [], []
@ -360,7 +360,7 @@ def format_config_value(group: str, c: frappe._dict):
c.value = frappe.get_value("Site Config", {"key": c.key, "parent": group}, "value") c.value = frappe.get_value("Site Config", {"key": c.key, "parent": group}, "value")
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def dependencies(name: str): def dependencies(name: str):
rg: ReleaseGroup = frappe.get_pg("Release Group", name) rg: ReleaseGroup = frappe.get_pg("Release Group", name)
@ -385,7 +385,7 @@ def dependencies(name: str):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def update_dependencies(name: str, dependencies: str): def update_dependencies(name: str, dependencies: str):
dependencies = frappe.parse_json(dependencies) dependencies = frappe.parse_json(dependencies)
@ -407,7 +407,7 @@ def update_dependencies(name: str, dependencies: str):
rg.save() rg.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def apps(name): def apps(name):
group = frappe.get_pg("Release Group", name) group = frappe.get_pg("Release Group", name)
@ -472,7 +472,7 @@ def apps(name):
return apps return apps
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def installable_apps(name): def installable_apps(name):
release_group = frappe.get_pg("Release Group", name) release_group = frappe.get_pg("Release Group", name)
@ -483,7 +483,7 @@ def installable_apps(name):
return [app for app in apps if app["name"] not in installed_apps] return [app for app in apps if app["name"] not in installed_apps]
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def all_apps(name): def all_apps(name):
"""Return all apps in the marketplace that are not installed in the release group for adding new apps""" """Return all apps in the marketplace that are not installed in the release group for adding new apps"""
@ -535,19 +535,19 @@ def all_apps(name):
return marketplace_apps return marketplace_apps
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def fetch_latest_app_update(name, app): def fetch_latest_app_update(name, app):
frappe.get_pg("Release Group", name).fetch_latest_app_update(app) frappe.get_pg("Release Group", name).fetch_latest_app_update(app)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def add_app(name, source, app): def add_app(name, source, app):
add_apps(name, [{"app": app, "source": source}]) add_apps(name, [{"app": app, "source": source}])
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def add_apps(name, apps): def add_apps(name, apps):
release_group: "ReleaseGroup" = frappe.get_pg("Release Group", name) release_group: "ReleaseGroup" = frappe.get_pg("Release Group", name)
@ -556,13 +556,13 @@ def add_apps(name, apps):
release_group.update_source(frappe._dict(name=source, app=app_name)) release_group.update_source(frappe._dict(name=source, app=app_name))
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def remove_app(name, app): def remove_app(name, app):
return frappe.get_pg("Release Group", name).remove_app(app) return frappe.get_pg("Release Group", name).remove_app(app)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def versions(name): def versions(name):
Bench = frappe.qb.DocType("Bench") Bench = frappe.qb.DocType("Bench")
@ -636,7 +636,7 @@ def versions(name):
return deployed_versions return deployed_versions
@frappe.whitelist() @jingrow.whitelist()
@protected("Bench") @protected("Bench")
def get_installed_apps_in_version(name): def get_installed_apps_in_version(name):
apps = frappe.db.get_all( apps = frappe.db.get_all(
@ -660,7 +660,7 @@ def get_installed_apps_in_version(name):
return apps return apps
@frappe.whitelist() @jingrow.whitelist()
@protected("Bench") @protected("Bench")
def get_processes(name): def get_processes(name):
bench: "Bench" = frappe.get_pg("Bench", name) bench: "Bench" = frappe.get_pg("Bench", name)
@ -670,7 +670,7 @@ def get_processes(name):
return bench.supervisorctl_status() return bench.supervisorctl_status()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def candidates(filters=None, order_by=None, limit_start=None, limit_page_length=None): def candidates(filters=None, order_by=None, limit_start=None, limit_page_length=None):
# TODO: Status is redundant here. # TODO: Status is redundant here.
@ -697,7 +697,7 @@ def candidates(filters=None, order_by=None, limit_start=None, limit_page_length=
return candidates.values() return candidates.values()
@frappe.whitelist() @jingrow.whitelist()
def candidate(name): def candidate(name):
if not name: if not name:
return None return None
@ -736,14 +736,14 @@ def candidate(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def deploy_information(name): def deploy_information(name):
rg: ReleaseGroup = frappe.get_pg("Release Group", name) rg: ReleaseGroup = frappe.get_pg("Release Group", name)
return rg.deploy_information() return rg.deploy_information()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def deploy(name, apps): def deploy(name, apps):
team = get_current_team(True) team = get_current_team(True)
@ -761,7 +761,7 @@ def deploy(name, apps):
return deploy_candidate_build["name"] return deploy_candidate_build["name"]
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def deploy_and_update( def deploy_and_update(
name: str, name: str,
@ -778,7 +778,7 @@ def deploy_and_update(
).deploy(run_will_fail_check) ).deploy(run_will_fail_check)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def update_inplace( def update_inplace(
name: str, name: str,
@ -794,7 +794,7 @@ def update_inplace(
).update_inplace() ).update_inplace()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def create_deploy_candidate(name, apps_to_ignore=None): def create_deploy_candidate(name, apps_to_ignore=None):
apps_to_ignore = [] if apps_to_ignore is None else apps_to_ignore apps_to_ignore = [] if apps_to_ignore is None else apps_to_ignore
@ -802,7 +802,7 @@ def create_deploy_candidate(name, apps_to_ignore=None):
return rg.create_deploy_candidate(apps_to_ignore) return rg.create_deploy_candidate(apps_to_ignore)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None): def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
benches = frappe.get_all("Bench", {"group": filters["name"]}, pluck="name") benches = frappe.get_all("Bench", {"group": filters["name"]}, pluck="name")
@ -823,7 +823,7 @@ def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return jobs return jobs
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def running_jobs(name): def running_jobs(name):
benches = frappe.get_all("Bench", {"group": name}, pluck="name") benches = frappe.get_all("Bench", {"group": name}, pluck="name")
@ -834,7 +834,7 @@ def running_jobs(name):
return [job_detail(job.name) for job in jobs] return [job_detail(job.name) for job in jobs]
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def recent_deploys(name): def recent_deploys(name):
return frappe.get_all( return frappe.get_all(
@ -846,7 +846,7 @@ def recent_deploys(name):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def change_branch(name: str, app: str, to_branch: str): def change_branch(name: str, app: str, to_branch: str):
"""Switch to `to_branch` for `app` in release group `name`""" """Switch to `to_branch` for `app` in release group `name`"""
@ -854,7 +854,7 @@ def change_branch(name: str, app: str, to_branch: str):
rg.change_app_branch(app, to_branch) rg.change_app_branch(app, to_branch)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def branch_list(name: str, app: str) -> list[dict]: def branch_list(name: str, app: str) -> list[dict]:
"""Return a list of git branches available for the `app`""" """Return a list of git branches available for the `app`"""
@ -910,7 +910,7 @@ def belongs_to_current_team(app: str) -> bool:
return marketplace_app.team == current_team return marketplace_app.team == current_team
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def regions(name): def regions(name):
rg = frappe.get_pg("Release Group", name) rg = frappe.get_pg("Release Group", name)
@ -920,7 +920,7 @@ def regions(name):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def available_regions(name): def available_regions(name):
rg = frappe.get_pg("Release Group", name) rg = frappe.get_pg("Release Group", name)
@ -928,13 +928,13 @@ def available_regions(name):
return Cluster.get_all_for_new_bench({"name": ("not in", cluster_names)}) return Cluster.get_all_for_new_bench({"name": ("not in", cluster_names)})
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def add_region(name, region): def add_region(name, region):
frappe.get_pg("Release Group", name).add_region(region) frappe.get_pg("Release Group", name).add_region(region)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def archive(name): def archive(name):
benches = frappe.get_all("Bench", filters={"group": name, "status": "Active"}, pluck="name") benches = frappe.get_all("Bench", filters={"group": name, "status": "Active"}, pluck="name")
@ -949,25 +949,25 @@ def archive(name):
group.save() group.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Bench") @protected("Bench")
def restart(name): def restart(name):
frappe.get_pg("Bench", name).restart() frappe.get_pg("Bench", name).restart()
@frappe.whitelist() @jingrow.whitelist()
@protected("Bench") @protected("Bench")
def rebuild(name): def rebuild(name):
frappe.get_pg("Bench", name).rebuild() frappe.get_pg("Bench", name).rebuild()
@frappe.whitelist() @jingrow.whitelist()
@protected("Bench") @protected("Bench")
def update(name): def update(name):
frappe.get_pg("Bench", name).update_all_sites() frappe.get_pg("Bench", name).update_all_sites()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def update_all_sites(name): def update_all_sites(name):
benches = frappe.get_all("Bench", {"group": name, "status": "Active"}) benches = frappe.get_all("Bench", {"group": name, "status": "Active"})
@ -975,7 +975,7 @@ def update_all_sites(name):
frappe.get_cached_pg("Bench", bench).update_all_sites() frappe.get_cached_pg("Bench", bench).update_all_sites()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def logs(name, bench): def logs(name, bench):
from press.agent import AgentRequestSkippedException from press.agent import AgentRequestSkippedException
@ -989,7 +989,7 @@ def logs(name, bench):
return [] return []
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def log(name, bench, log): def log(name, bench, log):
if frappe.db.get_value("Bench", bench, "group") != name: if frappe.db.get_value("Bench", bench, "group") != name:
@ -997,19 +997,19 @@ def log(name, bench, log):
return frappe.get_pg("Bench", bench).get_server_log(log) return frappe.get_pg("Bench", bench).get_server_log(log)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def certificate(name): def certificate(name):
return frappe.get_pg("Release Group", name).get_certificate() return frappe.get_pg("Release Group", name).get_certificate()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def generate_certificate(name): def generate_certificate(name):
return frappe.get_pg("Release Group", name).generate_certificate() return frappe.get_pg("Release Group", name).generate_certificate()
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def get_title_and_creation(name): def get_title_and_creation(name):
result = frappe.db.get_value("Release Group", name, ["title", "creation"], as_dict=True) result = frappe.db.get_value("Release Group", name, ["title", "creation"], as_dict=True)
@ -1020,13 +1020,13 @@ def get_title_and_creation(name):
return result return result
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def rename(name, title): def rename(name, title):
return frappe.db.set_value("Release Group", name, "title", title) return frappe.db.set_value("Release Group", name, "title", title)
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def apply_patch(release_group: str, app: str, patch_config: dict) -> list[str]: def apply_patch(release_group: str, app: str, patch_config: dict) -> list[str]:
team = get_current_team() team = get_current_team()
@ -1039,7 +1039,7 @@ def apply_patch(release_group: str, app: str, patch_config: dict) -> list[str]:
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def fail_build(dn: str): def fail_build(dn: str):
failed = fail_remote_job(dn) failed = fail_remote_job(dn)
@ -1048,7 +1048,7 @@ def fail_build(dn: str):
frappe.throw("No running job found!") frappe.throw("No running job found!")
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def fail_and_redeploy(name: str, dc_name: str): def fail_and_redeploy(name: str, dc_name: str):
res = fail_and_redeploy_build(dc_name) res = fail_and_redeploy_build(dc_name)
@ -1061,7 +1061,7 @@ def fail_and_redeploy(name: str, dc_name: str):
return res.get("message") return res.get("message")
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def show_app_versions(name: str, dc_name: str) -> dict[str, str]: def show_app_versions(name: str, dc_name: str) -> dict[str, str]:
"""Get app versions from the deploy candidate""" """Get app versions from the deploy candidate"""
@ -1095,7 +1095,7 @@ def show_app_versions(name: str, dc_name: str) -> dict[str, str]:
] ]
@frappe.whitelist() @jingrow.whitelist()
@protected("Release Group") @protected("Release Group")
def redeploy(name: str, dc_name: str) -> str: def redeploy(name: str, dc_name: str) -> str:
response = redeploy_candidate(dc_name) response = redeploy_candidate(dc_name)
@ -1106,7 +1106,7 @@ def redeploy(name: str, dc_name: str) -> str:
return response["message"] return response["message"]
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def confirm_bench_transfer(key: str): def confirm_bench_transfer(key: str):
from frappe import _ from frappe import _

74
press/api/billing.py
View File

@ -42,7 +42,7 @@ from press.utils.mpesa_utils import create_mpesa_request_log
# from press.press.doctype.paymob_callback_log.paymob_callback_log import create_payment_partner_transaction # from press.press.doctype.paymob_callback_log.paymob_callback_log import create_payment_partner_transaction
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_publishable_key_and_setup_intent(): def get_publishable_key_and_setup_intent():
team = get_current_team() team = get_current_team()
@ -52,7 +52,7 @@ def get_publishable_key_and_setup_intent():
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def upcoming_invoice(): def upcoming_invoice():
team = get_current_team(True) team = get_current_team(True)
@ -70,34 +70,34 @@ def upcoming_invoice():
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_balance_credit(): def get_balance_credit():
team = get_current_team(True) team = get_current_team(True)
return team.get_balance() return team.get_balance()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def past_invoices(): def past_invoices():
return get_current_team(True).get_past_invoices() return get_current_team(True).get_past_invoices()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def invoices_and_payments(): def invoices_and_payments():
team = get_current_team(True) team = get_current_team(True)
return team.get_past_invoices() return team.get_past_invoices()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def refresh_invoice_link(invoice): def refresh_invoice_link(invoice):
pg = frappe.get_pg("Invoice", invoice) pg = frappe.get_pg("Invoice", invoice)
return pg.refresh_stripe_payment_link() return pg.refresh_stripe_payment_link()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def balances(): def balances():
team = get_current_team() team = get_current_team()
@ -201,7 +201,7 @@ def is_added_credits_bt(bt):
return not bt.description.startswith("Reverse") return not bt.description.startswith("Reverse")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def details(): def details():
team = get_current_team(True) team = get_current_team(True)
@ -226,7 +226,7 @@ def details():
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def fetch_invoice_items(invoice): def fetch_invoice_items(invoice):
team = get_current_team() team = get_current_team()
@ -250,7 +250,7 @@ def fetch_invoice_items(invoice):
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_customer_details(team): def get_customer_details(team):
"""This method is called by framework.jingrow.com for creating Customer and Address""" """This method is called by framework.jingrow.com for creating Customer and Address"""
@ -261,7 +261,7 @@ def get_customer_details(team):
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def create_payment_intent_for_micro_debit(): def create_payment_intent_for_micro_debit():
team = get_current_team(True) team = get_current_team(True)
@ -284,7 +284,7 @@ def create_payment_intent_for_micro_debit():
return {"client_secret": intent["client_secret"]} return {"client_secret": intent["client_secret"]}
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def create_payment_intent_for_partnership_fees(): def create_payment_intent_for_partnership_fees():
team = get_current_team(True) team = get_current_team(True)
@ -312,7 +312,7 @@ def create_payment_intent_for_partnership_fees():
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def create_payment_intent_for_buying_credits(amount): def create_payment_intent_for_buying_credits(amount):
team = get_current_team(True) team = get_current_team(True)
@ -342,7 +342,7 @@ def create_payment_intent_for_buying_credits(amount):
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def create_payment_intent_for_prepaid_app(amount, metadata): def create_payment_intent_for_prepaid_app(amount, metadata):
stripe = get_stripe() stripe = get_stripe()
@ -400,21 +400,21 @@ def create_payment_intent_for_prepaid_app(amount, metadata):
} }
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_payment_methods(): def get_payment_methods():
team = get_current_team() team = get_current_team()
return frappe.get_pg("Team", team).get_payment_methods() return frappe.get_pg("Team", team).get_payment_methods()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def set_as_default(name): def set_as_default(name):
payment_method = frappe.get_pg("Stripe Payment Method", {"name": name, "team": get_current_team()}) payment_method = frappe.get_pg("Stripe Payment Method", {"name": name, "team": get_current_team()})
payment_method.set_default() payment_method.set_default()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def remove_payment_method(name): def remove_payment_method(name):
team = get_current_team() team = get_current_team()
@ -428,7 +428,7 @@ def remove_payment_method(name):
return None return None
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def finalize_invoices(): def finalize_invoices():
unsettled_invoices = frappe.get_all( unsettled_invoices = frappe.get_all(
@ -442,7 +442,7 @@ def finalize_invoices():
inv_pg.finalize_invoice() inv_pg.finalize_invoice()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def unpaid_invoices(): def unpaid_invoices():
team = get_current_team() team = get_current_team()
@ -458,7 +458,7 @@ def unpaid_invoices():
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_unpaid_invoices(): def get_unpaid_invoices():
team = get_current_team() team = get_current_team()
@ -476,7 +476,7 @@ def get_unpaid_invoices():
return unpaid_invoices # noqa: RET504 return unpaid_invoices # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def change_payment_mode(mode): def change_payment_mode(mode):
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -494,7 +494,7 @@ def change_payment_mode(mode):
return return
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def prepaid_credits_via_onboarding(): def prepaid_credits_via_onboarding():
"""When prepaid credits are bought, the balance is not immediately reflected. """When prepaid credits are bought, the balance is not immediately reflected.
@ -514,7 +514,7 @@ def prepaid_credits_via_onboarding():
team.save() team.save()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_invoice_usage(invoice): def get_invoice_usage(invoice):
team = get_current_team() team = get_current_team()
@ -527,7 +527,7 @@ def get_invoice_usage(invoice):
return out return out
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_summary(): def get_summary():
team = get_current_team() team = get_current_team()
@ -581,13 +581,13 @@ def get_grouped_invoice_items(invoices: list[str]) -> dict:
return invoice_items_map return invoice_items_map
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def after_card_add(): def after_card_add():
clear_setup_intent() clear_setup_intent()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def setup_intent_success(setup_intent, address=None): def setup_intent_success(setup_intent, address=None):
setup_intent = frappe._dict(setup_intent) setup_intent = frappe._dict(setup_intent)
@ -614,7 +614,7 @@ def setup_intent_success(setup_intent, address=None):
return {"payment_method_name": payment_method.name} return {"payment_method_name": payment_method.name}
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def validate_gst(address, method=None): def validate_gst(address, method=None):
if isinstance(address, dict): if isinstance(address, dict):
@ -640,7 +640,7 @@ def validate_gst(address, method=None):
validate_gstin_check_digit(address.gstin) validate_gstin_check_digit(address.gstin)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_latest_unpaid_invoice(): def get_latest_unpaid_invoice():
team = get_current_team() team = get_current_team()
@ -671,13 +671,13 @@ def team_has_balance_for_invoice(prepaid_mode_invoice):
return team.get_balance() >= prepaid_mode_invoice.amount_due return team.get_balance() >= prepaid_mode_invoice.amount_due
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def is_paypal_enabled() -> bool: def is_paypal_enabled() -> bool:
return frappe.db.get_single_value("Press Settings", "paypal_enabled") return frappe.db.get_single_value("Press Settings", "paypal_enabled")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def create_razorpay_order(amount, transaction_type, pg_name=None) -> dict | None: def create_razorpay_order(amount, transaction_type, pg_name=None) -> dict | None:
if not transaction_type: if not transaction_type:
@ -776,7 +776,7 @@ def _validate_invoice_payment(amount, pg_name, currency):
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def handle_razorpay_payment_success(response): def handle_razorpay_payment_success(response):
client = get_razorpay_client() client = get_razorpay_client()
@ -797,7 +797,7 @@ def handle_razorpay_payment_success(response):
payment_record.save(ignore_permissions=True) payment_record.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def handle_razorpay_payment_failed(response): def handle_razorpay_payment_failed(response):
payment_record = frappe.get_pg( payment_record = frappe.get_pg(
@ -811,7 +811,7 @@ def handle_razorpay_payment_failed(response):
payment_record.save(ignore_permissions=True) payment_record.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def total_unpaid_amount(): def total_unpaid_amount():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -829,7 +829,7 @@ def total_unpaid_amount():
) + negative_balance ) + negative_balance
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def get_current_billing_amount(): def get_current_billing_amount():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -896,7 +896,7 @@ def generate_stk_push(**kwargs):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def verify_m_pesa_transaction(**kwargs): def verify_m_pesa_transaction(**kwargs):
"""Verify the transaction result received via callback from STK.""" """Verify the transaction result received via callback from STK."""
transaction_response, request_id = parse_transaction_response(kwargs) transaction_response, request_id = parse_transaction_response(kwargs)
@ -960,7 +960,7 @@ def handle_transaction_result(transaction_response, integration_request):
return status return status
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def request_for_payment(**kwargs): def request_for_payment(**kwargs):
"""request for payments""" """request for payments"""
@ -1118,7 +1118,7 @@ def parse_datetime(date):
return datetime.strptime(str(date), "%Y%m%d%H%M%S") return datetime.strptime(str(date), "%Y%m%d%H%M%S")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("billing") @role_guard.api("billing")
def billing_forecast(): def billing_forecast():
""" """

2
press/api/callbacks.py
View File

@ -96,7 +96,7 @@ def handle_job_updates(server: str, job_identifier: str):
frappe.set_user(current_user) frappe.set_user(current_user)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def callback(job_id: str): def callback(job_id: str):
""" """
Handle job updates sent from agent. Handle job updates sent from agent.

12
press/api/central.py
View File

@ -15,7 +15,7 @@ from press.press.doctype.site.pool import get as get_pooled_site
from press.press.doctype.team.team import Team from press.press.doctype.team.team import Team
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def account_request( def account_request(
subdomain, email, first_name, last_name, phone_number, country, url_args=None subdomain, email, first_name, last_name, phone_number, country, url_args=None
): ):
@ -64,7 +64,7 @@ def account_request(
frappe.session.data = current_session_data frappe.session.data = current_session_data
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def setup_account(key, business_data=None): def setup_account(key, business_data=None):
account_request = get_account_request_from_key(key) account_request = get_account_request_from_key(key)
if not account_request: if not account_request:
@ -121,7 +121,7 @@ def setup_account(key, business_data=None):
return site.name return site.name
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def check_subdomain_availability(subdomain): def check_subdomain_availability(subdomain):
exists = bool( exists = bool(
frappe.db.exists( frappe.db.exists(
@ -139,7 +139,7 @@ def check_subdomain_availability(subdomain):
return True return True
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def options_for_regional_data(key): def options_for_regional_data(key):
account_request = get_account_request_from_key(key) account_request = get_account_request_from_key(key)
if not account_request: if not account_request:
@ -155,7 +155,7 @@ def options_for_regional_data(key):
return data return data
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_trial_end_date(site): def get_trial_end_date(site):
if not site or not isinstance(site, str): if not site or not isinstance(site, str):
frappe.throw("Invalid Site") frappe.throw("Invalid Site")
@ -163,7 +163,7 @@ def get_trial_end_date(site):
return frappe.db.get_value("Site", site, "trial_end_date") return frappe.db.get_value("Site", site, "trial_end_date")
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def send_login_link(site): def send_login_link(site):
if not site or not isinstance(site, str) or not frappe.db.exists("Site", site): if not site or not isinstance(site, str) or not frappe.db.exists("Site", site):
frappe.throw("Invalid site") frappe.throw("Invalid site")

14
press/api/client.py
View File

@ -98,7 +98,7 @@ ALLOWED_DOCTYPES = [
whitelisted_methods = set() whitelisted_methods = set()
@frappe.whitelist() @jingrow.whitelist()
def get_list( def get_list(
doctype: str, doctype: str,
fields: list | None = None, fields: list | None = None,
@ -199,7 +199,7 @@ def get_list_query(
return query return query
@frappe.whitelist() @jingrow.whitelist()
@role_guard.document( @role_guard.document(
document_type=lambda args: str(args.get("doctype")), document_type=lambda args: str(args.get("doctype")),
document_name=lambda args: str(args.get("name")), document_name=lambda args: str(args.get("name")),
@ -237,7 +237,7 @@ def get(doctype, name):
return dashboard_access_rules(_pg) return dashboard_access_rules(_pg)
@frappe.whitelist(methods=["POST", "PUT"]) @jingrow.whitelist(methods=["POST", "PUT"])
def insert(pg=None): def insert(pg=None):
if not pg or not pg.get("doctype"): if not pg or not pg.get("doctype"):
frappe.throw(frappe._("pg.doctype is required")) frappe.throw(frappe._("pg.doctype is required"))
@ -272,7 +272,7 @@ def insert(pg=None):
return get(_pg.doctype, _pg.name) return get(_pg.doctype, _pg.name)
@frappe.whitelist(methods=["POST", "PUT"]) @jingrow.whitelist(methods=["POST", "PUT"])
def set_value(doctype: str, name: str, fieldname: dict | str, value: str | None = None): def set_value(doctype: str, name: str, fieldname: dict | str, value: str | None = None):
check_permissions(doctype) check_permissions(doctype)
check_document_access(doctype, name) check_document_access(doctype, name)
@ -287,7 +287,7 @@ def set_value(doctype: str, name: str, fieldname: dict | str, value: str | None
return get(doctype, name) return get(doctype, name)
@frappe.whitelist(methods=["DELETE", "POST"]) @jingrow.whitelist(methods=["DELETE", "POST"])
def delete(doctype: str, name: str): def delete(doctype: str, name: str):
method = "delete" method = "delete"
@ -298,7 +298,7 @@ def delete(doctype: str, name: str):
_run_pg_method(dt=doctype, dn=name, method=method, args=None) _run_pg_method(dt=doctype, dn=name, method=method, args=None)
@frappe.whitelist() @jingrow.whitelist()
def run_pg_method(dt: str, dn: str, method: str, args: dict | None = None): def run_pg_method(dt: str, dn: str, method: str, args: dict | None = None):
check_permissions(dt) check_permissions(dt)
check_document_access(dt, dn) check_document_access(dt, dn)
@ -314,7 +314,7 @@ def run_pg_method(dt: str, dn: str, method: str, args: dict | None = None):
frappe.response.docs = [get(dt, dn)] frappe.response.docs = [get(dt, dn)]
@frappe.whitelist() @jingrow.whitelist()
def search_link( def search_link(
doctype: str, doctype: str,
query: str | None = None, query: str | None = None,

4
press/api/config.py
View File

@ -3,7 +3,7 @@ import jingrow
from press.utils import get_client_blacklisted_keys from press.utils import get_client_blacklisted_keys
@frappe.whitelist() @jingrow.whitelist()
def standard_keys(): def standard_keys():
return frappe.get_all( return frappe.get_all(
"Site Config Key", "Site Config Key",
@ -12,7 +12,7 @@ def standard_keys():
) )
@frappe.whitelist() @jingrow.whitelist()
def is_valid(keys): def is_valid(keys):
keys = frappe.parse_json(keys) keys = frappe.parse_json(keys)

2
press/api/cookies.py
View File

@ -7,7 +7,7 @@ from frappe.auth import CookieManager
from frappe.oauth import get_cookie_dict_from_headers from frappe.oauth import get_cookie_dict_from_headers
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def update_preferences(preferences): def update_preferences(preferences):
preferences_dict = json.loads(preferences) preferences_dict = json.loads(preferences)

8
press/api/dashboard.py
View File

@ -9,7 +9,7 @@ from press.api.site import protected
from press.utils import get_current_team from press.utils import get_current_team
@frappe.whitelist() @jingrow.whitelist()
def all(): def all():
sites = frappe.get_list( sites = frappe.get_list(
"Site", "Site",
@ -20,7 +20,7 @@ def all():
return {"sites": sites} return {"sites": sites}
@frappe.whitelist() @jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"]) @protected(["Site", "Release Group", "Server", "Database Server"])
def create_new_tag(name, doctype, tag): def create_new_tag(name, doctype, tag):
team = get_current_team() team = get_current_team()
@ -39,7 +39,7 @@ def create_new_tag(name, doctype, tag):
return tag return tag
@frappe.whitelist() @jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"]) @protected(["Site", "Release Group", "Server", "Database Server"])
def add_tag(name, doctype, tag): def add_tag(name, doctype, tag):
pg = frappe.get_pg(doctype, name) pg = frappe.get_pg(doctype, name)
@ -48,7 +48,7 @@ def add_tag(name, doctype, tag):
return tag return tag
@frappe.whitelist() @jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"]) @protected(["Site", "Release Group", "Server", "Database Server"])
def remove_tag(name, doctype, tag): def remove_tag(name, doctype, tag):
pg = frappe.get_pg(doctype, name) pg = frappe.get_pg(doctype, name)

18
press/api/developer/marketplace.py
View File

@ -179,56 +179,56 @@ class SessionManager:
# ------------------------------------------------------------ # ------------------------------------------------------------
# API ENDPOINTS # API ENDPOINTS
# ------------------------------------------------------------ # ------------------------------------------------------------
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_subscription_status(secret_key: str) -> str: def get_subscription_status(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription_status() return api_handler.get_subscription_status()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_subscription_info(secret_key: str) -> Dict: def get_subscription_info(secret_key: str) -> Dict:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription_info() return api_handler.get_subscription_info()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_subscription(secret_key: str) -> str: def get_subscription(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription() return api_handler.get_subscription()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_plans(secret_key: str, subscription: str) -> List: def get_plans(secret_key: str, subscription: str) -> List:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_plans(subscription) return api_handler.get_plans(subscription)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def update_billing_info(secret_key: str, data) -> str: def update_billing_info(secret_key: str, data) -> str:
data = frappe.parse_json(data) data = frappe.parse_json(data)
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.update_billing_info(data) return api_handler.update_billing_info(data)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_publishable_key_and_setup_intent(secret_key: str) -> str: def get_publishable_key_and_setup_intent(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_publishable_key_and_setup_intent() return api_handler.get_publishable_key_and_setup_intent()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def setup_intent_success(secret_key: str, setup_intent) -> str: def setup_intent_success(secret_key: str, setup_intent) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.setup_intent_success(setup_intent) return api_handler.setup_intent_success(setup_intent)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def change_site_plan(secret_key: str, plan: str) -> str: def change_site_plan(secret_key: str, plan: str) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.change_site_plan(plan) return api_handler.change_site_plan(plan)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def send_login_link(secret_key: str) -> str: def send_login_link(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key) api_handler = DeveloperApiHandler(secret_key)
return api_handler.send_login_link() return api_handler.send_login_link()

16
press/api/developer/saas.py
View File

@ -82,30 +82,30 @@ class SaasApiHandler:
# ------------------------------------------------------------ # ------------------------------------------------------------
# API ENDPOINTS # API ENDPOINTS
# ------------------------------------------------------------ # ------------------------------------------------------------
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def ping(): def ping():
return "pong" return "pong"
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_subscription_status(secret_key): def get_subscription_status(secret_key):
api_handler = SaasApiHandler(secret_key) api_handler = SaasApiHandler(secret_key)
return api_handler.get_subscription_status() return api_handler.get_subscription_status()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_plan_config(secret_key): def get_plan_config(secret_key):
api_handler = SaasApiHandler(secret_key) api_handler = SaasApiHandler(secret_key)
return api_handler.get_plan_config() return api_handler.get_plan_config()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_subscription_info(secret_key): def get_subscription_info(secret_key):
api_handler = SaasApiHandler(secret_key) api_handler = SaasApiHandler(secret_key)
return api_handler.get_subscription_info() return api_handler.get_subscription_info()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_trial_expiry(secret_key): def get_trial_expiry(secret_key):
api_handler = SaasApiHandler(secret_key) api_handler = SaasApiHandler(secret_key)
return api_handler.get_trial_expiry() return api_handler.get_trial_expiry()
@ -122,7 +122,7 @@ It can potentially break the integrations.
""" """
@frappe.whitelist(allow_guest=True, methods=["POST"]) @jingrow.whitelist(allow_guest=True, methods=["POST"])
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def send_verification_code(domain: str, route: str = ""): def send_verification_code(domain: str, route: str = ""):
from press.utils.otp import generate_otp from press.utils.otp import generate_otp
@ -165,7 +165,7 @@ def send_verification_code(domain: str, route: str = ""):
} }
@frappe.whitelist(allow_guest=True, methods=["POST"]) @jingrow.whitelist(allow_guest=True, methods=["POST"])
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def verify_verification_code(domain: str, verification_code: str, route: str = "dashboard"): def verify_verification_code(domain: str, verification_code: str, route: str = "dashboard"):
otp_hash = frappe.cache.get_value(f"otp_hash_for_fc_login_via_saas_flow:{domain}", expires=True) otp_hash = frappe.cache.get_value(f"otp_hash_for_fc_login_via_saas_flow:{domain}", expires=True)
@ -188,7 +188,7 @@ def verify_verification_code(domain: str, verification_code: str, route: str = "
frappe.response["login_token"] = login_token frappe.response["login_token"] = login_token
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
def login_to_fc(token: str): def login_to_fc(token: str):
email_cache_key = f"saas_fc_login_token:{token}" email_cache_key = f"saas_fc_login_token:{token}"

8
press/api/email.py
View File

@ -42,7 +42,7 @@ class SpamDetectionError(ValidationError):
http_status_code = 422 http_status_code = 422
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def email_ping(): def email_ping():
return "pong" return "pong"
@ -78,7 +78,7 @@ def setup(site):
frappe.get_pg({"doctype": "Mail Setup", "site": site, "is_complete": 1}).insert(ignore_permissions=True) frappe.get_pg({"doctype": "Mail Setup", "site": site, "is_complete": 1}).insert(ignore_permissions=True)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_analytics(**data): def get_analytics(**data):
""" """
send data for a specific month send data for a specific month
@ -206,7 +206,7 @@ def check_recipients(recipients: str | list[str]):
validate_email_address(recipient, throw=True) validate_email_address(recipient, throw=True)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def send_mime_mail(**data): def send_mime_mail(**data):
""" """
send api request to mailgun send api request to mailgun
@ -261,7 +261,7 @@ def is_valid_mailgun_event(event_data):
return True return True
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def event_log(): def event_log():
""" """
log the webhook and forward it to site log the webhook and forward it to site

12
press/api/github.py
View File

@ -20,7 +20,7 @@ if TYPE_CHECKING:
from press.press.doctype.github_webhook_log.github_webhook_log import GitHubWebhookLog from press.press.doctype.github_webhook_log.github_webhook_log import GitHubWebhookLog
@frappe.whitelist(allow_guest=True, xss_safe=True) @jingrow.whitelist(allow_guest=True, xss_safe=True)
def hook(*args, **kwargs): def hook(*args, **kwargs):
user = frappe.session.user user = frappe.session.user
# set user to Administrator, to not have to do ignore_permissions everywhere # set user to Administrator, to not have to do ignore_permissions everywhere
@ -81,7 +81,7 @@ def get_access_token(installation_id: str | None = None):
return response.get("token") return response.get("token")
@frappe.whitelist() @jingrow.whitelist()
def clear_token_and_get_installation_url(): def clear_token_and_get_installation_url():
clear_current_team_access_token() clear_current_team_access_token()
public_link = frappe.db.get_single_value("Press Settings", "github_app_public_link") public_link = frappe.db.get_single_value("Press Settings", "github_app_public_link")
@ -93,7 +93,7 @@ def clear_current_team_access_token():
frappe.db.set_value("Team", team, "github_access_token", "") # clear access token frappe.db.set_value("Team", team, "github_access_token", "") # clear access token
@frappe.whitelist() @jingrow.whitelist()
def options(): def options():
team = get_current_team() team = get_current_team()
token = frappe.db.get_value("Team", team, "github_access_token") token = frappe.db.get_value("Team", team, "github_access_token")
@ -162,7 +162,7 @@ def repositories(installation, token):
return repositories return repositories
@frappe.whitelist() @jingrow.whitelist()
def repository(owner, name, installation=None): def repository(owner, name, installation=None):
token = "" token = ""
if not installation: if not installation:
@ -197,7 +197,7 @@ def repository(owner, name, installation=None):
return repo return repo
@frappe.whitelist() @jingrow.whitelist()
def app(owner, repository, branch, installation=None): def app(owner, repository, branch, installation=None):
headers = get_auth_headers(installation) headers = get_auth_headers(installation)
response = requests.get( response = requests.get(
@ -235,7 +235,7 @@ def app(owner, repository, branch, installation=None):
return {"name": app_name, "title": title} return {"name": app_name, "title": title}
@frappe.whitelist() @jingrow.whitelist()
def branches(owner, name, installation=None): def branches(owner, name, installation=None):
if installation: if installation:
token = get_access_token(installation) token = get_access_token(installation)

4
press/api/google.py
View File

@ -14,7 +14,7 @@ from press.utils import log_error
from press.utils.telemetry import capture from press.utils.telemetry import capture
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def login(product=None): def login(product=None):
flow = google_oauth_flow() flow = google_oauth_flow()
authorization_url, state = flow.authorization_url() authorization_url, state = flow.authorization_url()
@ -26,7 +26,7 @@ def login(product=None):
return authorization_url return authorization_url
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def callback(code=None, state=None): # noqa: C901 def callback(code=None, state=None): # noqa: C901
cached_key = f"google_oauth_flow:{state}" cached_key = f"google_oauth_flow:{state}"
payload = frappe.cache().get_value(cached_key) payload = frappe.cache().get_value(cached_key)

2
press/api/log_browser.py
View File

@ -315,7 +315,7 @@ FORMATTER_MAP = {
} }
@frappe.whitelist() @jingrow.whitelist()
@protected(["Site", "Bench"]) @protected(["Site", "Bench"])
def get_log(log_type: LOG_TYPE, pg_name: str, log_name: str) -> list: def get_log(log_type: LOG_TYPE, pg_name: str, log_name: str) -> list:
MULTILINE_LOGS = ("database.log", "scheduler.log", "worker", "ipython", "frappe.log") MULTILINE_LOGS = ("database.log", "scheduler.log", "worker", "ipython", "frappe.log")

114
press/api/marketplace.py
View File

@ -29,7 +29,7 @@ if TYPE_CHECKING:
from press.press.doctype.app_source.app_source import AppSource from press.press.doctype.app_source.app_source import AppSource
@frappe.whitelist() @jingrow.whitelist()
def get(app): def get(app):
record = frappe.get_pg("Marketplace App", app) record = frappe.get_pg("Marketplace App", app)
return { return {
@ -41,7 +41,7 @@ def get(app):
} }
@frappe.whitelist() @jingrow.whitelist()
def get_install_app_options(marketplace_app: str) -> dict: def get_install_app_options(marketplace_app: str) -> dict:
"""Get options for installing a marketplace app""" """Get options for installing a marketplace app"""
@ -315,7 +315,7 @@ def create_site_on_private_bench(
return site_group_deploy # noqa: RET504 return site_group_deploy # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def create_site_for_app( def create_site_for_app(
subdomain: str, subdomain: str,
apps: list[dict], apps: list[dict],
@ -338,7 +338,7 @@ def create_site_for_app(
return create_site_on_private_bench(subdomain, apps, cluster) return create_site_on_private_bench(subdomain, apps, cluster)
@frappe.whitelist() @jingrow.whitelist()
def options_for_quick_install(marketplace_app: str): def options_for_quick_install(marketplace_app: str):
app_name, title, frappe_approved = frappe.db.get_value( app_name, title, frappe_approved = frappe.db.get_value(
"Marketplace App", marketplace_app, ["app", "title", "frappe_approved"] "Marketplace App", marketplace_app, ["app", "title", "frappe_approved"]
@ -419,7 +419,7 @@ def get_candidate_sites(app_name: str) -> list[str]:
return sites.run(pluck="name") return sites.run(pluck="name")
@frappe.whitelist() @jingrow.whitelist()
def become_publisher(): def become_publisher():
"""Turn on marketplace developer mode for current team""" """Turn on marketplace developer mode for current team"""
current_team = get_current_team(get_pg=True) current_team = get_current_team(get_pg=True)
@ -427,13 +427,13 @@ def become_publisher():
current_team.save() current_team.save()
@frappe.whitelist() @jingrow.whitelist()
def frappe_versions(): def frappe_versions():
"""Return a list of Frappe Version names""" """Return a list of Frappe Version names"""
return frappe.get_all("Frappe Version", pluck="name", order_by="name desc") return frappe.get_all("Frappe Version", pluck="name", order_by="name desc")
@frappe.whitelist() @jingrow.whitelist()
def get_apps() -> list[dict]: def get_apps() -> list[dict]:
"""Return list of apps developed by the current team""" """Return list of apps developed by the current team"""
team = get_current_team() team = get_current_team()
@ -447,7 +447,7 @@ def get_apps() -> list[dict]:
return apps # noqa: RET504 return apps # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@protected("Marketplace App") @protected("Marketplace App")
def get_app(name: str) -> dict: def get_app(name: str) -> dict:
"""Return the `Marketplace App` document with name""" """Return the `Marketplace App` document with name"""
@ -460,7 +460,7 @@ def get_app(name: str) -> dict:
return app return app
@frappe.whitelist() @jingrow.whitelist()
@protected("Marketplace App") @protected("Marketplace App")
def deploy_information(name: str): def deploy_information(name: str):
"""Return the deploy information for marketplace app `app`""" """Return the deploy information for marketplace app `app`"""
@ -468,12 +468,12 @@ def deploy_information(name: str):
return marketplace_app.get_deploy_information() return marketplace_app.get_deploy_information()
@frappe.whitelist() @jingrow.whitelist()
def profile_image_url(app: str) -> str: def profile_image_url(app: str) -> str:
return frappe.db.get_value("Marketplace App", app, "image") return frappe.db.get_value("Marketplace App", app, "image")
@frappe.whitelist() @jingrow.whitelist()
def update_app_image() -> str: def update_app_image() -> str:
"""Handles App Image Upload""" """Handles App Image Upload"""
file_content = frappe.local.uploaded_file file_content = frappe.local.uploaded_file
@ -519,7 +519,7 @@ def convert_to_webp(file_content: bytes) -> bytes:
return image_bytes.getvalue() return image_bytes.getvalue()
@frappe.whitelist() @jingrow.whitelist()
def add_app_screenshot() -> str: def add_app_screenshot() -> str:
"""Handles App Image Upload""" """Handles App Image Upload"""
file_content = frappe.local.uploaded_file file_content = frappe.local.uploaded_file
@ -556,7 +556,7 @@ def add_app_screenshot() -> str:
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def remove_app_screenshot(name, file): def remove_app_screenshot(name, file):
app_pg = frappe.get_pg("Marketplace App", name) app_pg = frappe.get_pg("Marketplace App", name)
@ -579,7 +579,7 @@ def validate_app_image_dimensions(file_content):
frappe.throw("Logo must be a square image atleast 300x300px in size") frappe.throw("Logo must be a square image atleast 300x300px in size")
@frappe.whitelist() @jingrow.whitelist()
def update_app_title(name: str, title: str) -> MarketplaceApp: def update_app_title(name: str, title: str) -> MarketplaceApp:
"""Update `title` and `category`""" """Update `title` and `category`"""
app: MarketplaceApp = frappe.get_pg("Marketplace App", name) app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
@ -589,7 +589,7 @@ def update_app_title(name: str, title: str) -> MarketplaceApp:
return app return app
@frappe.whitelist() @jingrow.whitelist()
def update_app_links(name: str, links: dict) -> None: def update_app_links(name: str, links: dict) -> None:
"""Update links related to app""" """Update links related to app"""
app: MarketplaceApp = frappe.get_pg("Marketplace App", name) app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
@ -597,7 +597,7 @@ def update_app_links(name: str, links: dict) -> None:
app.save(ignore_permissions=True) app.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def update_app_summary(name: str, summary: str) -> None: def update_app_summary(name: str, summary: str) -> None:
"""Update the `description` of Marketplace App `name`""" """Update the `description` of Marketplace App `name`"""
app: MarketplaceApp = frappe.get_pg("Marketplace App", name) app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
@ -605,7 +605,7 @@ def update_app_summary(name: str, summary: str) -> None:
app.save(ignore_permissions=True) app.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def update_app_description(name: str, description: str) -> None: def update_app_description(name: str, description: str) -> None:
"""Update the `long_description` of Marketplace App `name`""" """Update the `long_description` of Marketplace App `name`"""
app: MarketplaceApp = frappe.get_pg("Marketplace App", name) app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
@ -613,7 +613,7 @@ def update_app_description(name: str, description: str) -> None:
app.save(ignore_permissions=True) app.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def releases(filters=None, order_by=None, limit_start=None, limit_page_length=None) -> list[dict]: def releases(filters=None, order_by=None, limit_start=None, limit_page_length=None) -> list[dict]:
"""Return list of App Releases for this `app` and `source` in order of creation time""" """Return list of App Releases for this `app` and `source` in order of creation time"""
@ -641,32 +641,32 @@ def releases(filters=None, order_by=None, limit_start=None, limit_page_length=No
return app_releases return app_releases
@frappe.whitelist() @jingrow.whitelist()
def get_app_source(name: str) -> AppSource: def get_app_source(name: str) -> AppSource:
"""Return `App Source` document having `name`""" """Return `App Source` document having `name`"""
return frappe.get_pg("App Source", name) return frappe.get_pg("App Source", name)
@frappe.whitelist() @jingrow.whitelist()
def latest_approved_release(source: None | str) -> AppRelease: def latest_approved_release(source: None | str) -> AppRelease:
"""Return the latest app release with `approved` status""" """Return the latest app release with `approved` status"""
return get_last_pg("App Release", {"source": source, "status": "Approved"}) return get_last_pg("App Release", {"source": source, "status": "Approved"})
@frappe.whitelist() @jingrow.whitelist()
@protected("Marketplace App") @protected("Marketplace App")
def create_approval_request(name, app_release: str): def create_approval_request(name, app_release: str):
"""Create a new Approval Request for given `app_release`""" """Create a new Approval Request for given `app_release`"""
frappe.get_pg("Marketplace App", name).create_approval_request(app_release) frappe.get_pg("Marketplace App", name).create_approval_request(app_release)
@frappe.whitelist() @jingrow.whitelist()
def cancel_approval_request(app_release: str): def cancel_approval_request(app_release: str):
"""Cancel Approval Request for given `app_release`""" """Cancel Approval Request for given `app_release`"""
get_latest_approval_request(app_release).cancel() get_latest_approval_request(app_release).cancel()
@frappe.whitelist() @jingrow.whitelist()
def reason_for_rejection(app_release: str) -> str: def reason_for_rejection(app_release: str) -> str:
"""Return feedback given on a `Rejected` approval request""" """Return feedback given on a `Rejected` approval request"""
approval_request = get_latest_approval_request(app_release) approval_request = get_latest_approval_request(app_release)
@ -695,7 +695,7 @@ def get_latest_approval_request(app_release: str):
return approval_request # noqa: RET504 return approval_request # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def options_for_marketplace_app() -> dict[str, dict]: # noqa: C901 def options_for_marketplace_app() -> dict[str, dict]: # noqa: C901
# Get versions (along with apps and associated sources) # Get versions (along with apps and associated sources)
# which belong to the current team # which belong to the current team
@ -744,7 +744,7 @@ def options_for_marketplace_app() -> dict[str, dict]: # noqa: C901
return marketplace_options return marketplace_options
@frappe.whitelist() @jingrow.whitelist()
def get_marketplace_apps_for_onboarding() -> list[dict]: def get_marketplace_apps_for_onboarding() -> list[dict]:
apps = frappe.get_all( apps = frappe.get_all(
"Marketplace App", "Marketplace App",
@ -763,7 +763,7 @@ def is_on_marketplace(app: str) -> bool:
return frappe.db.exists("Marketplace App", app) return frappe.db.exists("Marketplace App", app)
@frappe.whitelist() @jingrow.whitelist()
def new_app(app: dict): def new_app(app: dict):
name = app["name"] name = app["name"]
team = get_current_team() team = get_current_team()
@ -784,7 +784,7 @@ def new_app(app: dict):
return add_app(source.name, app_pg.name) return add_app(source.name, app_pg.name)
@frappe.whitelist() @jingrow.whitelist()
def add_app(source: str, app: str): def add_app(source: str, app: str):
if not is_on_marketplace(app): if not is_on_marketplace(app):
supported_versions = frappe.get_all("App Source Version", filters={"parent": source}, pluck="version") supported_versions = frappe.get_all("App Source Version", filters={"parent": source}, pluck="version")
@ -821,14 +821,14 @@ def add_app(source: str, app: str):
return marketplace_app.name return marketplace_app.name
@frappe.whitelist() @jingrow.whitelist()
@protected("Marketplace App") @protected("Marketplace App")
def analytics(name: str): def analytics(name: str):
marketplace_app_pg: MarketplaceApp = frappe.get_pg("Marketplace App", name) marketplace_app_pg: MarketplaceApp = frappe.get_pg("Marketplace App", name)
return marketplace_app_pg.get_analytics() return marketplace_app_pg.get_analytics()
@frappe.whitelist() @jingrow.whitelist()
def get_promotional_banners() -> list: def get_promotional_banners() -> list:
promotionalBanner = frappe.qb.DocType("Marketplace Promotional Banner") promotionalBanner = frappe.qb.DocType("Marketplace Promotional Banner")
marketplaceApp = frappe.qb.DocType("Marketplace App") marketplaceApp = frappe.qb.DocType("Marketplace App")
@ -858,7 +858,7 @@ def get_promotional_banners() -> list:
# like 'api/marketplace/billing.py') # like 'api/marketplace/billing.py')
@frappe.whitelist() @jingrow.whitelist()
def get_marketplace_subscriptions_for_site(site: str): def get_marketplace_subscriptions_for_site(site: str):
subscriptions = frappe.db.get_all( subscriptions = frappe.db.get_all(
"Subscription", "Subscription",
@ -887,17 +887,17 @@ def get_marketplace_subscriptions_for_site(site: str):
return subscriptions return subscriptions
@frappe.whitelist() @jingrow.whitelist()
def get_app_plans(app: str, include_disabled=True): def get_app_plans(app: str, include_disabled=True):
return get_plans_for_app(app, include_disabled=include_disabled) return get_plans_for_app(app, include_disabled=include_disabled)
@frappe.whitelist() @jingrow.whitelist()
def get_app_info(app: str): def get_app_info(app: str):
return frappe.db.get_value("Marketplace App", app, ["name", "title", "image", "team"], as_dict=True) return frappe.db.get_value("Marketplace App", app, ["name", "title", "image", "team"], as_dict=True)
@frappe.whitelist() @jingrow.whitelist()
def get_apps_with_plans(apps, release_group: str): def get_apps_with_plans(apps, release_group: str):
if isinstance(apps, str): if isinstance(apps, str):
apps = json.loads(apps) apps = json.loads(apps)
@ -927,7 +927,7 @@ def get_apps_with_plans(apps, release_group: str):
return apps_with_plans return apps_with_plans
@frappe.whitelist() @jingrow.whitelist()
def change_app_plan(subscription, new_plan): def change_app_plan(subscription, new_plan):
is_free = frappe.db.get_value("Marketplace App Plan", new_plan, "price_usd") <= 0 is_free = frappe.db.get_value("Marketplace App Plan", new_plan, "price_usd") <= 0
if not is_free: if not is_free:
@ -943,7 +943,7 @@ def change_app_plan(subscription, new_plan):
subscription.save(ignore_permissions=True) subscription.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def get_publisher_profile_info(): def get_publisher_profile_info():
publisher_profile_info = {} publisher_profile_info = {}
@ -960,7 +960,7 @@ def get_publisher_profile_info():
return publisher_profile_info return publisher_profile_info
@frappe.whitelist() @jingrow.whitelist()
def update_publisher_profile(profile_data=None): def update_publisher_profile(profile_data=None):
"""Update if exists, otherwise create""" """Update if exists, otherwise create"""
team = get_current_team() team = get_current_team()
@ -978,7 +978,7 @@ def update_publisher_profile(profile_data=None):
profile_pg.insert(ignore_permissions=True) profile_pg.insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def submit_user_review(title, rating, app, review): def submit_user_review(title, rating, app, review):
return frappe.get_pg( return frappe.get_pg(
{ {
@ -992,7 +992,7 @@ def submit_user_review(title, rating, app, review):
).insert(ignore_permissions=True) ).insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def submit_developer_reply(review, reply): def submit_developer_reply(review, reply):
return frappe.get_pg( return frappe.get_pg(
{ {
@ -1004,7 +1004,7 @@ def submit_developer_reply(review, reply):
).insert(ignore_permissions=True) ).insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def get_subscriptions_list(marketplace_app: str) -> list: def get_subscriptions_list(marketplace_app: str) -> list:
app_sub = frappe.qb.DocType("Subscription") app_sub = frappe.qb.DocType("Subscription")
app_plan = frappe.qb.DocType("Marketplace App Plan") app_plan = frappe.qb.DocType("Marketplace App Plan")
@ -1045,7 +1045,7 @@ def get_subscriptions_list(marketplace_app: str) -> list:
return result # noqa: RET504 return result # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def create_app_plan(marketplace_app: str, plan_data: dict): def create_app_plan(marketplace_app: str, plan_data: dict):
app_plan_pg = frappe.get_pg( app_plan_pg = frappe.get_pg(
{ {
@ -1062,7 +1062,7 @@ def create_app_plan(marketplace_app: str, plan_data: dict):
return app_plan_pg.insert(ignore_permissions=True) return app_plan_pg.insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def update_app_plan(app_plan_name: str, updated_plan_data: dict): def update_app_plan(app_plan_name: str, updated_plan_data: dict):
if not updated_plan_data.get("title"): if not updated_plan_data.get("title"):
frappe.throw("Plan title is required") frappe.throw("Plan title is required")
@ -1115,7 +1115,7 @@ def reset_features_for_plan(app_plan_pg: MarketplaceAppPlan, feature_list: list[
app_plan_pg.save(ignore_permissions=True) app_plan_pg.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def get_payouts_list() -> list[dict]: def get_payouts_list() -> list[dict]:
team = get_current_team() team = get_current_team()
payouts = frappe.get_all( payouts = frappe.get_all(
@ -1135,7 +1135,7 @@ def get_payouts_list() -> list[dict]:
return payouts # noqa: RET504 return payouts # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def get_payout_details(name: str) -> dict: def get_payout_details(name: str) -> dict:
order_items = frappe.get_all( order_items = frappe.get_all(
"Payout Order Item", "Payout Order Item",
@ -1197,7 +1197,7 @@ def get_discount_percent(plan, discount=0.0):
return discount return discount
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def login_via_token(token: str, team: str, site: str): def login_via_token(token: str, team: str, site: str):
if not token or not isinstance(token, str): if not token or not isinstance(token, str):
frappe.throw("Invalid Token") frappe.throw("Invalid Token")
@ -1225,7 +1225,7 @@ def login_via_token(token: str, team: str, site: str):
frappe.local.response["location"] = "/dashboard/login?showRemoteLoginError=true" frappe.local.response["location"] = "/dashboard/login?showRemoteLoginError=true"
@frappe.whitelist() @jingrow.whitelist()
def subscriptions(): def subscriptions():
team = get_current_team(True) team = get_current_team(True)
free_plans = frappe.get_all("Marketplace App Plan", {"price_usd": ("<=", 0)}, pluck="name") free_plans = frappe.get_all("Marketplace App Plan", {"price_usd": ("<=", 0)}, pluck="name")
@ -1250,7 +1250,7 @@ def subscriptions():
@protected("App Source") @protected("App Source")
@frappe.whitelist() @jingrow.whitelist()
def branches(name): def branches(name):
from press.api.github import branches as git_branches from press.api.github import branches as git_branches
@ -1268,14 +1268,14 @@ def branches(name):
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def change_branch(name, source, version, to_branch): def change_branch(name, source, version, to_branch):
app = frappe.get_pg("Marketplace App", name) app = frappe.get_pg("Marketplace App", name)
app.change_branch(source, version, to_branch) app.change_branch(source, version, to_branch)
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def options_for_version(name): def options_for_version(name):
frappe_version = frappe.get_all("Frappe Version", {"public": True}, pluck="name") frappe_version = frappe.get_all("Frappe Version", {"public": True}, pluck="name")
added_versions = frappe.get_all("Marketplace App Version", {"parent": name}, pluck="version") added_versions = frappe.get_all("Marketplace App Version", {"parent": name}, pluck="version")
@ -1289,21 +1289,21 @@ def options_for_version(name):
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def add_version(name, branch, version): def add_version(name, branch, version):
app = frappe.get_pg("Marketplace App", name) app = frappe.get_pg("Marketplace App", name)
app.add_version(version, branch) app.add_version(version, branch)
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def remove_version(name, version): def remove_version(name, version):
app = frappe.get_pg("Marketplace App", name) app = frappe.get_pg("Marketplace App", name)
app.remove_version(version) app.remove_version(version)
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def review_steps(name): def review_steps(name):
app = frappe.get_pg("Marketplace App", name) app = frappe.get_pg("Marketplace App", name)
return [ return [
@ -1337,14 +1337,14 @@ def review_steps(name):
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def mark_app_ready_for_review(name): def mark_app_ready_for_review(name):
app = frappe.get_pg("Marketplace App", name) app = frappe.get_pg("Marketplace App", name)
app.mark_app_ready_for_review() app.mark_app_ready_for_review()
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def communication(name): def communication(name):
comm = frappe.qb.DocType("Communication") comm = frappe.qb.DocType("Communication")
user = frappe.qb.DocType("User") user = frappe.qb.DocType("User")
@ -1361,7 +1361,7 @@ def communication(name):
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def add_reply(name, message): def add_reply(name, message):
doctype = "Marketplace App" doctype = "Marketplace App"
app = frappe.get_pg(doctype, name) app = frappe.get_pg(doctype, name)
@ -1385,14 +1385,14 @@ def add_reply(name, message):
@protected("Marketplace App") @protected("Marketplace App")
@frappe.whitelist() @jingrow.whitelist()
def fetch_readme(name): def fetch_readme(name):
app: MarketplaceApp = frappe.get_pg("Marketplace App", name) app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
app.long_description = app.fetch_readme() app.long_description = app.fetch_readme()
app.save() app.save()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_marketplace_apps(): def get_marketplace_apps():
apps = frappe.cache().get_value("marketplace_apps") apps = frappe.cache().get_value("marketplace_apps")
if not apps: if not apps:
@ -1402,7 +1402,7 @@ def get_marketplace_apps():
@protected("App Source") @protected("App Source")
@frappe.whitelist() @jingrow.whitelist()
def add_code_review_comment(name, filename, line_number, comment): def add_code_review_comment(name, filename, line_number, comment):
try: try:
pg = frappe.get_pg("App Release Approval Request", name) pg = frappe.get_pg("App Release Approval Request", name)

2
press/api/message.py
View File

@ -3,7 +3,7 @@ from frappe.rate_limiter import rate_limit
from werkzeug.wrappers import Response from werkzeug.wrappers import Response
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=1200, seconds=60) @rate_limit(limit=1200, seconds=60)
def confirmed_incident(server_title: str): def confirmed_incident(server_title: str):
response = Response() response = Response()

4
press/api/monitoring.py
View File

@ -124,7 +124,7 @@ def get_targets_method_rate_limit() -> int:
MONITORING_ENDPOINT_RATE_LIMIT_WINDOW_SECONDS = 60 MONITORING_ENDPOINT_RATE_LIMIT_WINDOW_SECONDS = 60
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=get_targets_method_rate_limit, seconds=MONITORING_ENDPOINT_RATE_LIMIT_WINDOW_SECONDS) @rate_limit(limit=get_targets_method_rate_limit, seconds=MONITORING_ENDPOINT_RATE_LIMIT_WINDOW_SECONDS)
def targets(token=None): def targets(token=None):
if not token: if not token:
@ -136,7 +136,7 @@ def targets(token=None):
return {"benches": get_benches(), "clusters": get_clusters(), "domains": get_domains(), "tls": get_tls()} return {"benches": get_benches(), "clusters": get_clusters(), "domains": get_domains(), "tls": get_tls()}
@frappe.whitelist(allow_guest=True, xss_safe=True) @jingrow.whitelist(allow_guest=True, xss_safe=True)
def alert(*args, **kwargs): def alert(*args, **kwargs):
user = frappe.session.user user = frappe.session.user
try: try:

6
press/api/notifications.py
View File

@ -4,7 +4,7 @@ from press.guards import role_guard
from press.utils import get_current_team from press.utils import get_current_team
@frappe.whitelist() @jingrow.whitelist()
@role_guard.document( @role_guard.document(
document_type=lambda _: "Site", document_type=lambda _: "Site",
inject_values=True, inject_values=True,
@ -78,11 +78,11 @@ def get_notifications(
return notifications return notifications
@frappe.whitelist() @jingrow.whitelist()
def mark_all_notifications_as_read(): def mark_all_notifications_as_read():
frappe.db.set_value("Press Notification", {"team": get_current_team()}, "read", 1, update_modified=False) frappe.db.set_value("Press Notification", {"team": get_current_team()}, "read", 1, update_modified=False)
@frappe.whitelist() @jingrow.whitelist()
def get_unread_count(): def get_unread_count():
return frappe.db.count("Press Notification", {"read": False, "team": get_current_team()}) return frappe.db.count("Press Notification", {"read": False, "team": get_current_team()})

8
press/api/oauth.py
View File

@ -39,7 +39,7 @@ def google_oauth_flow():
return flow return flow
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def google_login(saas_app=None): def google_login(saas_app=None):
flow = google_oauth_flow() flow = google_oauth_flow()
authorization_url, state = flow.authorization_url() authorization_url, state = flow.authorization_url()
@ -50,7 +50,7 @@ def google_login(saas_app=None):
return authorization_url return authorization_url
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def callback(code=None, state=None): def callback(code=None, state=None):
cached_key = f"fc_oauth_state:{state}" cached_key = f"fc_oauth_state:{state}"
cached_state = frappe.cache().get_value(cached_key) cached_state = frappe.cache().get_value(cached_key)
@ -149,7 +149,7 @@ def create_account_request(email, first_name, last_name, phone_number=""):
return account_request return account_request
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def saas_setup(key, app, country, subdomain): def saas_setup(key, app, country, subdomain):
if not check_subdomain_availability(subdomain, app): if not check_subdomain_availability(subdomain, app):
frappe.throw(f"Subdomain {subdomain} is already taken") frappe.throw(f"Subdomain {subdomain} is already taken")
@ -201,6 +201,6 @@ def saas_setup(key, app, country, subdomain):
return get_url("/prepare-site?key=" + signup_ar.request_key + "&app=" + app) return get_url("/prepare-site?key=" + signup_ar.request_key + "&app=" + app)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def oauth_authorize_url(provider): def oauth_authorize_url(provider):
return get_oauth2_authorize_url(provider, None) return get_oauth2_authorize_url(provider, None)

82
press/api/partner.py
View File

@ -10,7 +10,7 @@ from press.guards import role_guard
from press.utils import get_current_team from press.utils import get_current_team
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def approve_partner_request(key): def approve_partner_request(key):
partner_request_pg = frappe.get_pg("Partner Approval Request", {"key": key}) partner_request_pg = frappe.get_pg("Partner Approval Request", {"key": key})
@ -37,13 +37,13 @@ def approve_partner_request(key):
frappe.response.location = f"/app/partner-approval-request/{partner_request_pg.name}" frappe.response.location = f"/app/partner-approval-request/{partner_request_pg.name}"
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_request_status(team): def get_partner_request_status(team):
return frappe.db.get_value("Partner Approval Request", {"requested_by": team}, "status") return frappe.db.get_value("Partner Approval Request", {"requested_by": team}, "status")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def update_partnership_date(team, partnership_date): def update_partnership_date(team, partnership_date):
if team: if team:
@ -52,7 +52,7 @@ def update_partnership_date(team, partnership_date):
team_pg.save() team_pg.save()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def update_website_info(website_info): def update_website_info(website_info):
from press.utils.billing import get_frappe_io_connection, is_frappe_auth_disabled from press.utils.billing import get_frappe_io_connection, is_frappe_auth_disabled
@ -68,7 +68,7 @@ def update_website_info(website_info):
frappe.log_error("Error updating website info") frappe.log_error("Error updating website info")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_details(partner_email): def get_partner_details(partner_email):
from press.utils.billing import get_frappe_io_connection, is_frappe_auth_disabled from press.utils.billing import get_frappe_io_connection, is_frappe_auth_disabled
@ -106,7 +106,7 @@ def get_partner_details(partner_email):
return None return None
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def send_link_certificate_request(user_email, certificate_type): def send_link_certificate_request(user_email, certificate_type):
if not frappe.db.exists( if not frappe.db.exists(
@ -126,7 +126,7 @@ def send_link_certificate_request(user_email, certificate_type):
).insert() ).insert()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def approve_certificate_link_request(key): def approve_certificate_link_request(key):
cert_req_pg = frappe.get_pg("Certificate Link Request", {"key": key}) cert_req_pg = frappe.get_pg("Certificate Link Request", {"key": key})
@ -138,13 +138,13 @@ def approve_certificate_link_request(key):
frappe.response.location = "/dashboard/partners/certificates" frappe.response.location = "/dashboard/partners/certificates"
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_resource_url(): def get_resource_url():
return frappe.db.get_value("Press Settings", "Press Settings", "drive_resource_link") return frappe.db.get_value("Press Settings", "Press Settings", "drive_resource_link")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_name(partner_email): def get_partner_name(partner_email):
return frappe.db.get_value( return frappe.db.get_value(
@ -154,7 +154,7 @@ def get_partner_name(partner_email):
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def transfer_credits(amount, customer, partner): def transfer_credits(amount, customer, partner):
# partner discount map # partner discount map
@ -194,7 +194,7 @@ def transfer_credits(amount, customer, partner):
frappe.db.rollback() frappe.db.rollback()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_contribution_list(partner_email): def get_partner_contribution_list(partner_email):
partner_currency = frappe.db.get_value( partner_currency = frappe.db.get_value(
@ -223,7 +223,7 @@ def get_partner_contribution_list(partner_email):
return invoices return invoices
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_mrr(partner_email): def get_partner_mrr(partner_email):
partner_currency = frappe.db.get_value( partner_currency = frappe.db.get_value(
@ -256,7 +256,7 @@ def get_partner_mrr(partner_email):
return [d for d in query] return [d for d in query]
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_dashboard_stats(): def get_dashboard_stats():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -278,7 +278,7 @@ def get_dashboard_stats():
return [d for d in data] return [d for d in data]
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_lead_stats(): def get_lead_stats():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -303,7 +303,7 @@ def get_user_by_name(email):
return frappe.get_cached_value("User", email, "full_name") return frappe.get_cached_value("User", email, "full_name")
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_lead_activities(name): def get_lead_activities(name):
get_docinfo("", "Partner Lead", name) get_docinfo("", "Partner Lead", name)
@ -419,7 +419,7 @@ def parse_grouped_versions(versions):
return version return version
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_invoices(due_date=None, status=None): def get_partner_invoices(due_date=None, status=None):
partner_email = get_current_team(get_pg=True).partner_email partner_email = get_current_team(get_pg=True).partner_email
@ -443,7 +443,7 @@ def get_partner_invoices(due_date=None, status=None):
return invoices # noqa: RET504 return invoices # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_invoice_items(invoice): def get_invoice_items(invoice):
data = frappe.get_all( data = frappe.get_all(
@ -460,7 +460,7 @@ def get_invoice_items(invoice):
return data return data
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_current_month_partner_contribution(partner_email): def get_current_month_partner_contribution(partner_email):
partner_currency = frappe.db.get_value( partner_currency = frappe.db.get_value(
@ -493,7 +493,7 @@ def get_current_month_partner_contribution(partner_email):
return total return total
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_prev_month_partner_contribution(partner_email): def get_prev_month_partner_contribution(partner_email):
partner_currency = frappe.db.get_value( partner_currency = frappe.db.get_value(
@ -534,7 +534,7 @@ def get_prev_month_partner_contribution(partner_email):
return total return total
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def calculate_partner_tier(contribution, currency): def calculate_partner_tier(contribution, currency):
partner_tier = frappe.qb.DocType("Partner Tier") partner_tier = frappe.qb.DocType("Partner Tier")
@ -552,7 +552,7 @@ def calculate_partner_tier(contribution, currency):
return tier[0] return tier[0]
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def add_partner(referral_code: str): def add_partner(referral_code: str):
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -576,7 +576,7 @@ def add_partner(referral_code: str):
return None return None
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def validate_partner_code(code): def validate_partner_code(code):
partner = frappe.db.get_value( partner = frappe.db.get_value(
@ -589,7 +589,7 @@ def validate_partner_code(code):
return False, None return False, None
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_customers(): def get_partner_customers():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -601,7 +601,7 @@ def get_partner_customers():
return customers # noqa: RET504 return customers # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_members(partner): def get_partner_members(partner):
from press.utils.billing import get_frappe_io_connection from press.utils.billing import get_frappe_io_connection
@ -614,7 +614,7 @@ def get_partner_members(partner):
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_leads(lead_name=None, status=None, engagement_stage=None, source=None): def get_partner_leads(lead_name=None, status=None, engagement_stage=None, source=None):
team = get_current_team() team = get_current_team()
@ -634,7 +634,7 @@ def get_partner_leads(lead_name=None, status=None, engagement_stage=None, source
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def change_partner(lead_name, partner): def change_partner(lead_name, partner):
team = get_current_team() team = get_current_team()
@ -647,7 +647,7 @@ def change_partner(lead_name, partner):
pg.save() pg.save()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def remove_partner(): def remove_partner():
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -666,7 +666,7 @@ def remove_partner():
team.save(ignore_permissions=True) team.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def apply_for_certificate(member_name, certificate_type): def apply_for_certificate(member_name, certificate_type):
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -681,7 +681,7 @@ def apply_for_certificate(member_name, certificate_type):
pg.insert(ignore_permissions=True) pg.insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_partner_teams(company=None, email=None, country=None, tier=None, active_only=False): def get_partner_teams(company=None, email=None, country=None, tier=None, active_only=False):
filters = {"enabled": 1, "erpnext_partner": 1} filters = {"enabled": 1, "erpnext_partner": 1}
@ -704,7 +704,7 @@ def get_partner_teams(company=None, email=None, country=None, tier=None, active_
return teams # noqa: RET504 return teams # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_local_payment_setup(): def get_local_payment_setup():
team = get_current_team() team = get_current_team()
@ -714,20 +714,20 @@ def get_local_payment_setup():
return data return data
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_certificate_users(): def get_certificate_users():
users = frappe.get_all("Partner Certificate", ["partner_member_email", "partner_member_name"]) users = frappe.get_all("Partner Certificate", ["partner_member_email", "partner_member_name"])
return users # noqa: RET504 return users # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def get_lead_details(lead_id): def get_lead_details(lead_id):
return frappe.get_pg("Partner Lead", lead_id).as_dict() return frappe.get_pg("Partner Lead", lead_id).as_dict()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def update_lead_details(lead_name, lead_details): def update_lead_details(lead_name, lead_details):
lead_details = frappe._dict(lead_details) lead_details = frappe._dict(lead_details)
@ -751,7 +751,7 @@ def update_lead_details(lead_name, lead_details):
pg.reload() pg.reload()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def update_lead_status(lead_name, status, **kwargs): def update_lead_status(lead_name, status, **kwargs):
status_dict = {"status": status} status_dict = {"status": status}
@ -787,7 +787,7 @@ def update_lead_status(lead_name, status, **kwargs):
frappe.db.set_value("Partner Lead", lead_name, status_dict) frappe.db.set_value("Partner Lead", lead_name, status_dict)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def fetch_followup_details(id, lead): def fetch_followup_details(id, lead):
return frappe.get_all( return frappe.get_all(
@ -806,13 +806,13 @@ def fetch_followup_details(id, lead):
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def check_certificate_exists(email, type): def check_certificate_exists(email, type):
return frappe.db.count("Partner Certificate", {"partner_member_email": email, "course": type}) return frappe.db.count("Partner Certificate", {"partner_member_email": email, "course": type})
@frappe.whitelist() @jingrow.whitelist()
def get_fc_plans(): def get_fc_plans():
site_plans = frappe.get_all( site_plans = frappe.get_all(
"Site Plan", {"enabled": 1, "document_type": "Site", "price_inr": (">", 0)}, pluck="name" "Site Plan", {"enabled": 1, "document_type": "Site", "price_inr": (">", 0)}, pluck="name"
@ -820,7 +820,7 @@ def get_fc_plans():
return [*site_plans, "Dedicated Server", "Managed Press"] return [*site_plans, "Dedicated Server", "Managed Press"]
@frappe.whitelist() @jingrow.whitelist()
def update_followup_details(id, lead, followup_details): def update_followup_details(id, lead, followup_details):
followup_details = frappe._dict(followup_details) followup_details = frappe._dict(followup_details)
if id: if id:
@ -857,7 +857,7 @@ def update_followup_details(id, lead, followup_details):
pg.reload() pg.reload()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def add_new_lead(lead_details): def add_new_lead(lead_details):
lead_details = frappe._dict(lead_details) lead_details = frappe._dict(lead_details)
@ -883,7 +883,7 @@ def add_new_lead(lead_details):
pg.reload() pg.reload()
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def can_apply_for_certificate(): def can_apply_for_certificate():
from press.utils.billing import get_frappe_io_connection from press.utils.billing import get_frappe_io_connection
@ -895,7 +895,7 @@ def can_apply_for_certificate():
return response # noqa: RET504 return response # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
@role_guard.api("partner") @role_guard.api("partner")
def delete_followup(id, lead_name): def delete_followup(id, lead_name):
frappe.delete_pg("Lead Followup", id) frappe.delete_pg("Lead Followup", id)

2
press/api/payment.py
View File

@ -6,7 +6,7 @@
import jingrow import jingrow
@frappe.whitelist() @jingrow.whitelist()
def all(): def all():
payments = frappe.get_all( payments = frappe.get_all(
"Payment", fields=["name"], filters={"user": frappe.session.user} "Payment", fields=["name"], filters={"user": frappe.session.user}

10
press/api/product_trial.py
View File

@ -39,7 +39,7 @@ def _get_active_site(product: str, team: str | None) -> str | None:
return None return None
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def send_verification_code_for_login(email: str, product: str): def send_verification_code_for_login(email: str, product: str):
is_user_exists = frappe.db.exists("Team", {"user": email}) and _get_active_site( is_user_exists = frappe.db.exists("Team", {"user": email}) and _get_active_site(
product, frappe.db.get_value("Team", {"user": email}, "name") product, frappe.db.get_value("Team", {"user": email}, "name")
@ -57,7 +57,7 @@ def send_verification_code_for_login(email: str, product: str):
send_verification_mail_for_login(email, product, otp) send_verification_mail_for_login(email, product, otp)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=300) @rate_limit(limit=10, seconds=300)
def login_using_code(email: str, product: str, code: str): def login_using_code(email: str, product: str, code: str):
team_exists = frappe.db.exists("Team", {"user": email}) team_exists = frappe.db.exists("Team", {"user": email})
@ -94,13 +94,13 @@ def login_using_code(email: str, product: str, code: str):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
def get_account_request_for_product_signup(): def get_account_request_for_product_signup():
return frappe.db.get_value("Account Request", {"email": frappe.session.user}, "name") return frappe.db.get_value("Account Request", {"email": frappe.session.user}, "name")
@frappe.whitelist(allow_guest=True, methods=["POST"]) @jingrow.whitelist(allow_guest=True, methods=["POST"])
def setup_account(key: str, country: str | None = None): def setup_account(key: str, country: str | None = None):
ar = get_account_request_from_key(key) ar = get_account_request_from_key(key)
if not ar: if not ar:
@ -161,7 +161,7 @@ def _get_existing_trial_request(product: str, team: str):
) )
@frappe.whitelist(methods=["POST"]) @jingrow.whitelist(methods=["POST"])
def get_request(product: str, account_request: str | None = None) -> dict: def get_request(product: str, account_request: str | None = None) -> dict:
from frappe.core.utils import find from frappe.core.utils import find

34
press/api/regional_payments/mpesa/utils.py
View File

@ -12,7 +12,7 @@ from press.utils import get_current_team
supported_mpesa_currencies = ["KES"] supported_mpesa_currencies = ["KES"]
@frappe.whitelist() @jingrow.whitelist()
def update_mpesa_setup(mpesa_details): def update_mpesa_setup(mpesa_details):
"""Create Mpesa Settings for the team.""" """Create Mpesa Settings for the team."""
mpesa_info = frappe._dict(mpesa_details) mpesa_info = frappe._dict(mpesa_details)
@ -59,7 +59,7 @@ def update_mpesa_setup(mpesa_details):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def fetch_mpesa_setup(): def fetch_mpesa_setup():
team = get_current_team() team = get_current_team()
if frappe.db.exists("Mpesa Setup", {"team": team}): if frappe.db.exists("Mpesa Setup", {"team": team}):
@ -78,7 +78,7 @@ def fetch_mpesa_setup():
return None return None
@frappe.whitelist() @jingrow.whitelist()
def display_invoices_by_partner(): def display_invoices_by_partner():
"""Display the list of invoices by partner.""" """Display the list of invoices by partner."""
team = get_current_team() team = get_current_team()
@ -98,7 +98,7 @@ def display_invoices_by_partner():
return invoices # noqa: RET504 return invoices # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def get_exchange_rate(from_currency, to_currency): def get_exchange_rate(from_currency, to_currency):
"""Get the latest exchange rate for the given currencies.""" """Get the latest exchange rate for the given currencies."""
exchange_rate = frappe.db.get_value( exchange_rate = frappe.db.get_value(
@ -110,7 +110,7 @@ def get_exchange_rate(from_currency, to_currency):
return exchange_rate # noqa: RET504 return exchange_rate # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def update_payment_gateway_settings(gateway_details): def update_payment_gateway_settings(gateway_details):
"""Create Payment Gateway Settings for the team.""" """Create Payment Gateway Settings for the team."""
team = get_current_team() team = get_current_team()
@ -159,7 +159,7 @@ def update_payment_gateway_settings(gateway_details):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def get_payment_gateway_details(): def get_payment_gateway_details():
team = get_current_team() team = get_current_team()
if frappe.db.exists("Payment Gateway", {"team": team}): if frappe.db.exists("Payment Gateway", {"team": team}):
@ -178,7 +178,7 @@ def get_payment_gateway_details():
return None return None
@frappe.whitelist() @jingrow.whitelist()
def get_gateway_controller(): def get_gateway_controller():
# """Get the list of controllers for the given doctype.""" # """Get the list of controllers for the given doctype."""
team = get_current_team(get_pg=True) team = get_current_team(get_pg=True)
@ -188,7 +188,7 @@ def get_gateway_controller():
return None return None
@frappe.whitelist() @jingrow.whitelist()
def get_tax_percentage(payment_partner): def get_tax_percentage(payment_partner):
team = frappe.db.get_value("Team", {"user": payment_partner}, "name") team = frappe.db.get_value("Team", {"user": payment_partner}, "name")
mpesa_setups = frappe.get_all("Mpesa Setup", {"api_type": "Mpesa Express", "team": team}, pluck="name") mpesa_setups = frappe.get_all("Mpesa Setup", {"api_type": "Mpesa Express", "team": team}, pluck="name")
@ -222,7 +222,7 @@ def update_tax_id_or_phone_no(team, tax_id, phone_number):
team_pg.save() team_pg.save()
@frappe.whitelist() @jingrow.whitelist()
def display_mpesa_payment_partners(): def display_mpesa_payment_partners():
"""Display the list of partners in the system with Mpesa integration enabled.""" """Display the list of partners in the system with Mpesa integration enabled."""
@ -242,7 +242,7 @@ def display_mpesa_payment_partners():
return [partner["user"] for partner in mpesa_partners] return [partner["user"] for partner in mpesa_partners]
@frappe.whitelist() @jingrow.whitelist()
def display_payment_partners(): def display_payment_partners():
"""Display the list of partners in the system.""" """Display the list of partners in the system."""
Team = DocType("Team") Team = DocType("Team")
@ -253,7 +253,7 @@ def display_payment_partners():
return [partner["user"] for partner in partners] return [partner["user"] for partner in partners]
@frappe.whitelist() @jingrow.whitelist()
def display_payment_gateway(): def display_payment_gateway():
"""Display the payment gateway for the partner.""" """Display the payment gateway for the partner."""
gateways = frappe.get_all("Payment Gateway", filters={}, fields=["gateway"]) gateways = frappe.get_all("Payment Gateway", filters={}, fields=["gateway"])
@ -331,7 +331,7 @@ def fetch_param_value(response, key, key_field):
return None return None
@frappe.whitelist() @jingrow.whitelist()
def create_exchange_rate(**kwargs): def create_exchange_rate(**kwargs):
"""Create a new exchange rate record.""" """Create a new exchange rate record."""
try: try:
@ -385,7 +385,7 @@ def create_payment_partner_transaction(
return transaction_pg.name return transaction_pg.name
@frappe.whitelist() @jingrow.whitelist()
def fetch_payments(payment_gateway, partner, from_date, to_date): def fetch_payments(payment_gateway, partner, from_date, to_date):
partner = ( partner = (
partner if frappe.db.exists("Team", partner) else frappe.get_value("Team", {"user": partner}, "name") partner if frappe.db.exists("Team", partner) else frappe.get_value("Team", {"user": partner}, "name")
@ -408,13 +408,13 @@ def fetch_payments(payment_gateway, partner, from_date, to_date):
return partner_payments # noqa: RET504 return partner_payments # noqa: RET504
@frappe.whitelist() @jingrow.whitelist()
def fetch_percentage_commission(partner): def fetch_percentage_commission(partner):
"""Fetch the percentage commission for the partner.""" """Fetch the percentage commission for the partner."""
return frappe.get_value("Team", {"user": partner}, "partner_commission") return frappe.get_value("Team", {"user": partner}, "partner_commission")
@frappe.whitelist() @jingrow.whitelist()
def create_invoice_partner_site(data, gateway_controller): def create_invoice_partner_site(data, gateway_controller):
gateway = frappe.get_pg("Payment Gateway", gateway_controller) gateway = frappe.get_pg("Payment Gateway", gateway_controller)
api_url_ = gateway.url api_url_ = gateway.url
@ -463,7 +463,7 @@ def create_invoice_partner_site(data, gateway_controller):
frappe.throw(_("There was an issue connecting to the API.")) frappe.throw(_("There was an issue connecting to the API."))
@frappe.whitelist() @jingrow.whitelist()
def display_payment_gateways(payment_partner): def display_payment_gateways(payment_partner):
"""Display the list of payment gateways for the partner.""" """Display the list of payment gateways for the partner."""
Team = DocType("Team") Team = DocType("Team")
@ -482,7 +482,7 @@ def display_payment_gateways(payment_partner):
return [gateway["name"] for gateway in payment_gateways] return [gateway["name"] for gateway in payment_gateways]
@frappe.whitelist() @jingrow.whitelist()
def fetch_payouts(): def fetch_payouts():
team = get_current_team() team = get_current_team()
payouts = frappe.get_all( payouts = frappe.get_all(

16
press/api/saas.py
View File

@ -24,7 +24,7 @@ if TYPE_CHECKING:
# ----------------------------- SIGNUP APIs --------------------------------- # ----------------------------- SIGNUP APIs ---------------------------------
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def account_request( def account_request(
subdomain, subdomain,
email, email,
@ -120,7 +120,7 @@ def create_or_rename_saas_site(app, account_request):
frappe.session.data = current_session_data frappe.session.data = current_session_data
@frappe.whitelist() @jingrow.whitelist()
def new_saas_site(subdomain, app): def new_saas_site(subdomain, app):
frappe.only_for("System Manager") frappe.only_for("System Manager")
@ -140,7 +140,7 @@ def new_saas_site(subdomain, app):
return site return site
@frappe.whitelist() @jingrow.whitelist()
def get_saas_site_status(site): def get_saas_site_status(site):
if frappe.db.exists("Site", site): if frappe.db.exists("Site", site):
return {"site": site, "status": frappe.db.get_value("Site", site, "status")} return {"site": site, "status": frappe.db.get_value("Site", site, "status")}
@ -179,7 +179,7 @@ def get_hybrid_saas_pool(account_request):
return hybrid_pool return hybrid_pool
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def check_subdomain_availability(subdomain, app): def check_subdomain_availability(subdomain, app):
""" """
Checks if subdomain is available to create a new site Checks if subdomain is available to create a new site
@ -210,7 +210,7 @@ def check_subdomain_availability(subdomain, app):
return True return True
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def setup_account(key, business_data=None): def setup_account(key, business_data=None):
""" """
Includes the data collection step in setup-account.html Includes the data collection step in setup-account.html
@ -255,7 +255,7 @@ def setup_account(key, business_data=None):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def headless_setup_account(key): def headless_setup_account(key):
""" """
Ignores the data collection step in setup-account.html Ignores the data collection step in setup-account.html
@ -339,7 +339,7 @@ def create_team(account_request, get_stripe_id=False):
return team_pg return team_pg
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_site_status(key, app=None): def get_site_status(key, app=None):
""" """
return: Site status return: Site status
@ -362,7 +362,7 @@ def get_site_status(key, app=None):
return {"status": "Pending"} return {"status": "Pending"}
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def get_site_url_and_sid(key, app=None): def get_site_url_and_sid(key, app=None):
""" """
return: Site url and session id for login-redirect return: Site url and session id for login-redirect

12
press/api/security.py
View File

@ -5,7 +5,7 @@ from press.agent import Agent
from press.api.server import all as get_all_servers from press.api.server import all as get_all_servers
@frappe.whitelist() @jingrow.whitelist()
def get_servers(server_filter): def get_servers(server_filter):
servers = get_all_servers(server_filter=server_filter) servers = get_all_servers(server_filter=server_filter)
@ -21,7 +21,7 @@ def get_servers(server_filter):
return servers return servers
@frappe.whitelist() @jingrow.whitelist()
def fetch_security_updates( def fetch_security_updates(
filters=None, order_by=None, limit_start=None, limit_page_length=None filters=None, order_by=None, limit_start=None, limit_page_length=None
): ):
@ -35,12 +35,12 @@ def fetch_security_updates(
) )
@frappe.whitelist() @jingrow.whitelist()
def get_security_update_details(update_id): def get_security_update_details(update_id):
return frappe.get_pg("Security Update", update_id).as_dict() return frappe.get_pg("Security Update", update_id).as_dict()
@frappe.whitelist() @jingrow.whitelist()
def fetch_ssh_sessions(server, start=0, limit=10): def fetch_ssh_sessions(server, start=0, limit=10):
return frappe.get_all( return frappe.get_all(
"SSH Session", "SSH Session",
@ -52,7 +52,7 @@ def fetch_ssh_sessions(server, start=0, limit=10):
) )
@frappe.whitelist() @jingrow.whitelist()
def fetch_ssh_session_logs(server): def fetch_ssh_session_logs(server):
logs_to_display = [] logs_to_display = []
ssh_logs = Agent(server=server).get("security/ssh_session_logs") ssh_logs = Agent(server=server).get("security/ssh_session_logs")
@ -70,7 +70,7 @@ def fetch_ssh_session_logs(server):
return logs_to_display return logs_to_display
@frappe.whitelist() @jingrow.whitelist()
def fetch_ssh_session_activity(server, filename): def fetch_ssh_session_activity(server, filename):
content = Agent(server=server).get(f"security/retrieve_ssh_session_log/{filename}") content = Agent(server=server).get(f"security/retrieve_ssh_session_log/{filename}")
splited_filename = filename.split(".") splited_filename = filename.split(".")

16
press/api/selfhosted.py
View File

@ -10,7 +10,7 @@ from press.utils import get_current_team
from press.utils.dns import NAMESERVERS from press.utils.dns import NAMESERVERS
@frappe.whitelist() @jingrow.whitelist()
def new(server): def new(server):
server_details = frappe._dict(server) server_details = frappe._dict(server)
@ -71,12 +71,12 @@ def get_hybrid_cluster():
return frappe.db.get_value("Cluster", {"hybrid": 1}, "name") return frappe.db.get_value("Cluster", {"hybrid": 1}, "name")
@frappe.whitelist() @jingrow.whitelist()
def sshkey(): def sshkey():
return frappe.db.get_value("SSH Key", {"enabled": 1, "default": 1}, "public_key") return frappe.db.get_value("SSH Key", {"enabled": 1, "default": 1}, "public_key")
@frappe.whitelist() @jingrow.whitelist()
def verify(server): def verify(server):
server_pg = frappe.get_pg("Self Hosted Server", server) server_pg = frappe.get_pg("Self Hosted Server", server)
@ -125,7 +125,7 @@ def verify_server(server_type, server_pg):
return False return False
@frappe.whitelist() @jingrow.whitelist()
def setup(server): def setup(server):
server_pg = frappe.get_pg("Self Hosted Server", server) server_pg = frappe.get_pg("Self Hosted Server", server)
server_pg.start_setup = True server_pg.start_setup = True
@ -134,12 +134,12 @@ def setup(server):
time.sleep(1) time.sleep(1)
@frappe.whitelist() @jingrow.whitelist()
def get_plans(): def get_plans():
return plans("Self Hosted Server") return plans("Self Hosted Server")
@frappe.whitelist() @jingrow.whitelist()
def check_dns(domain, ip): def check_dns(domain, ip):
try: try:
resolver = Resolver(configure=False) resolver = Resolver(configure=False)
@ -152,12 +152,12 @@ def check_dns(domain, ip):
return False return False
@frappe.whitelist() @jingrow.whitelist()
def options_for_new(): def options_for_new():
return {"plans": get_plans(), "ssh_key": sshkey()} return {"plans": get_plans(), "ssh_key": sshkey()}
@frappe.whitelist() @jingrow.whitelist()
def create_and_verify_selfhosted(server): def create_and_verify_selfhosted(server):
self_hosted_server_name = new(server) self_hosted_server_name = new(server)

56
press/api/server.py
View File

@ -55,7 +55,7 @@ def get_mount_point(server: str, server_type=None) -> str:
return server_pg.guess_data_disk_mountpoint() return server_pg.guess_data_disk_mountpoint()
@frappe.whitelist() @jingrow.whitelist()
def all(server_filter=None): # noqa: C901 def all(server_filter=None): # noqa: C901
if server_filter is None: if server_filter is None:
server_filter = {"server_type": "", "tag": ""} server_filter = {"server_type": "", "tag": ""}
@ -125,13 +125,13 @@ def all(server_filter=None): # noqa: C901
return servers return servers
@frappe.whitelist() @jingrow.whitelist()
def server_tags(): def server_tags():
team = get_current_team() team = get_current_team()
return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Server"}, pluck="tag") return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Server"}, pluck="tag")
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def get(name): def get(name):
server = poly_get_pg(["Server", "Database Server"], name) server = poly_get_pg(["Server", "Database Server"], name)
@ -152,7 +152,7 @@ def get(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def overview(name): def overview(name):
server = poly_get_pg(["Server", "Database Server"], name) server = poly_get_pg(["Server", "Database Server"], name)
@ -176,21 +176,21 @@ def overview(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def archive(name): def archive(name):
server = poly_get_pg(["Server", "Database Server"], name) server = poly_get_pg(["Server", "Database Server"], name)
server.drop_server() server.drop_server()
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server"]) @protected(["Server"])
def get_reclaimable_size(name): def get_reclaimable_size(name):
server: Server = frappe.get_pg("Server", name) server: Server = frappe.get_pg("Server", name)
return server.agent.get("server/reclaimable-size") return server.agent.get("server/reclaimable-size")
@frappe.whitelist() @jingrow.whitelist()
def new(server): def new(server):
server_plan_platform = frappe.get_value("Server Plan", server["app_plan"], "platform") server_plan_platform = frappe.get_value("Server Plan", server["app_plan"], "platform")
cluster_has_arm_support = frappe.get_value("Cluster", server["cluster"], "has_arm_support") cluster_has_arm_support = frappe.get_value("Cluster", server["cluster"], "has_arm_support")
@ -283,7 +283,7 @@ def get_cpu_and_memory_usage(name: str, time_range: str = "4m") -> dict[str, flo
return {"vcpu": 0.0, "memory": 0.0} return {"vcpu": 0.0, "memory": 0.0}
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def usage(name): def usage(name):
mount_point = get_mount_point(name) mount_point = get_mount_point(name)
@ -385,7 +385,7 @@ def calculate_swap(name):
return result return result
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def analytics(name, query, timezone, duration, server_type=None): def analytics(name, query, timezone, duration, server_type=None):
@ -458,7 +458,7 @@ avg by (instance) (
return prometheus_query(query_map[query][0], query_map[query][1], timezone, timespan, timegrain) return prometheus_query(query_map[query][0], query_map[query][1], timezone, timespan, timegrain)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def get_request_by_site(name, query, timezone, duration): def get_request_by_site(name, query, timezone, duration):
@ -469,7 +469,7 @@ def get_request_by_site(name, query, timezone, duration):
return get_request_by_(name, query, timezone, timespan, timegrain, ResourceType.SERVER) return get_request_by_(name, query, timezone, timespan, timegrain, ResourceType.SERVER)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def get_background_job_by_site(name, query, timezone, duration): def get_background_job_by_site(name, query, timezone, duration):
@ -480,7 +480,7 @@ def get_background_job_by_site(name, query, timezone, duration):
return get_background_job_by_(name, query, timezone, timespan, timegrain, ResourceType.SERVER) return get_background_job_by_(name, query, timezone, timespan, timegrain, ResourceType.SERVER)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60) @redis_cache(ttl=10 * 60)
def get_slow_logs_by_site(name, query, timezone, duration, normalize=False): def get_slow_logs_by_site(name, query, timezone, duration, normalize=False):
@ -542,7 +542,7 @@ def prometheus_query(query, function, timezone, timespan, timegrain):
return {"datasets": datasets, "labels": labels} return {"datasets": datasets, "labels": labels}
@frappe.whitelist() @jingrow.whitelist()
def options(): def options():
if not get_current_team(get_pg=True).servers_enabled: if not get_current_team(get_pg=True).servers_enabled:
frappe.throw("Servers feature is not yet enabled on your account") frappe.throw("Servers feature is not yet enabled on your account")
@ -572,12 +572,12 @@ def options():
} }
@frappe.whitelist() @jingrow.whitelist()
def get_autoscale_discount(): def get_autoscale_discount():
return frappe.db.get_single_value("Press Settings", "autoscale_discount", cache=True) return frappe.db.get_single_value("Press Settings", "autoscale_discount", cache=True)
@frappe.whitelist() @jingrow.whitelist()
def secondary_server_plans( def secondary_server_plans(
name, name,
cluster=None, cluster=None,
@ -621,7 +621,7 @@ def secondary_server_plans(
return filter_by_roles(plans) return filter_by_roles(plans)
@frappe.whitelist() @jingrow.whitelist()
def plans(name, cluster=None, platform=None): def plans(name, cluster=None, platform=None):
# Removed default platform of x86_64; # Removed default platform of x86_64;
# Still use x86_64 for new database servers # Still use x86_64 for new database servers
@ -652,7 +652,7 @@ def plans(name, cluster=None, platform=None):
) )
@frappe.whitelist() @jingrow.whitelist()
def play(play): def play(play):
play = frappe.get_pg("Ansible Play", play) play = frappe.get_pg("Ansible Play", play)
play = play.as_dict() play = play.as_dict()
@ -678,13 +678,13 @@ def play(play):
return play return play
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def change_plan(name, plan): def change_plan(name, plan):
poly_get_pg(["Server", "Database Server"], name).change_plan(plan) poly_get_pg(["Server", "Database Server"], name).change_plan(plan)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def press_jobs(name): def press_jobs(name):
jobs = [] jobs = []
@ -693,7 +693,7 @@ def press_jobs(name):
return jobs return jobs
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None): def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
jobs = frappe.get_all( jobs = frappe.get_all(
@ -711,7 +711,7 @@ def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return jobs return jobs
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def plays(filters=None, order_by=None, limit_start=None, limit_page_length=None): def plays(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return frappe.get_all( return frappe.get_all(
@ -724,13 +724,13 @@ def plays(filters=None, order_by=None, limit_start=None, limit_page_length=None)
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Server") @protected("Server")
def get_title_and_cluster(name): def get_title_and_cluster(name):
return frappe.db.get_value("Server", name, ["title", "cluster"], as_dict=True) return frappe.db.get_value("Server", name, ["title", "cluster"], as_dict=True)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def groups(name): def groups(name):
server = poly_get_pg(["Server", "Database Server"], name) server = poly_get_pg(["Server", "Database Server"], name)
@ -741,13 +741,13 @@ def groups(name):
return all_benches(server=server.name) return all_benches(server=server.name)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def reboot(name): def reboot(name):
return poly_get_pg(["Server", "Database Server"], name).reboot() return poly_get_pg(["Server", "Database Server"], name).reboot()
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server", "Database Server"]) @protected(["Server", "Database Server"])
def rename(name, title): def rename(name, title):
pg = poly_get_pg(["Server", "Database Server"], name) pg = poly_get_pg(["Server", "Database Server"], name)
@ -767,7 +767,7 @@ def get_timespan_timegrain(duration: str) -> tuple[int, int]:
return timespan, timegrain return timespan, timegrain
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def benches_are_idle(server: str, access_token: str) -> None: def benches_are_idle(server: str, access_token: str) -> None:
"""Shut down the secondary server if all benches are idle. """Shut down the secondary server if all benches are idle.
@ -815,7 +815,7 @@ def benches_are_idle(server: str, access_token: str) -> None:
frappe.set_user(current_user) frappe.set_user(current_user)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server"]) @protected(["Server"])
def schedule_auto_scale( def schedule_auto_scale(
name, scheduled_scale_up_time: str | datetime, scheduled_scale_down_time: str | datetime name, scheduled_scale_up_time: str | datetime, scheduled_scale_down_time: str | datetime
@ -859,7 +859,7 @@ def schedule_auto_scale(
create_record("Scale Down", formatted_scheduled_scale_down_time) create_record("Scale Down", formatted_scheduled_scale_down_time)
@frappe.whitelist() @jingrow.whitelist()
@protected(["Server"]) @protected(["Server"])
def get_configured_autoscale_triggers(name) -> list[dict[str, float]] | None: def get_configured_autoscale_triggers(name) -> list[dict[str, float]] | None:
return frappe.db.get_all( return frappe.db.get_all(

2
press/api/service_health.py
View File

@ -1,7 +1,7 @@
import jingrow import jingrow
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def service_health(): def service_health():
""" """
Check if more than 50% of records for each service in the past 5 minutes are failing. Check if more than 50% of records for each service in the past 5 minutes are failing.

154
press/api/site.py
View File

@ -284,7 +284,7 @@ def validate_plan(server: str, plan: str) -> None:
frappe.throw("You are not allowed to use this plan") frappe.throw("You are not allowed to use this plan")
@frappe.whitelist() @jingrow.whitelist()
def new(site): def new(site):
if not hasattr(site, "domain") and not site.get("domain"): if not hasattr(site, "domain") and not site.get("domain"):
site["domain"] = frappe.db.get_single_value("Press Settings", "domain") site["domain"] = frappe.db.get_single_value("Press Settings", "domain")
@ -323,7 +323,7 @@ def get_app_subscriptions(app_plans, team_name: str):
return subscriptions return subscriptions
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None): def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
jobs = frappe.get_all( jobs = frappe.get_all(
@ -341,7 +341,7 @@ def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return jobs return jobs
@frappe.whitelist() @jingrow.whitelist()
def job(job): def job(job):
job = frappe.get_pg("Agent Job", job) job = frappe.get_pg("Agent Job", job)
job = job.as_dict() job = job.as_dict()
@ -370,14 +370,14 @@ def job(job):
return job return job
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def running_jobs(name): def running_jobs(name):
jobs = frappe.get_all("Agent Job", filters={"status": ("in", ("Pending", "Running")), "site": name}) jobs = frappe.get_all("Agent Job", filters={"status": ("in", ("Pending", "Running")), "site": name})
return [job_detail(job.name) for job in jobs] return [job_detail(job.name) for job in jobs]
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def backups(name): def backups(name):
available_offsite_backups = frappe.db.get_single_value("Press Settings", "offsite_backups_count") or 30 available_offsite_backups = frappe.db.get_single_value("Press Settings", "offsite_backups_count") or 30
@ -421,7 +421,7 @@ def backups(name):
return sorted(latest_backups + offsite_backups, key=lambda x: x["creation"], reverse=True) return sorted(latest_backups + offsite_backups, key=lambda x: x["creation"], reverse=True)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def get_backup_link(name, backup, file): def get_backup_link(name, backup, file):
try: try:
@ -431,7 +431,7 @@ def get_backup_link(name, backup, file):
log_error(title="Offsite Backup Response Exception") log_error(title="Offsite Backup Response Exception")
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def domains(name): def domains(name):
domains = frappe.get_all( domains = frappe.get_all(
@ -447,7 +447,7 @@ def domains(name):
return domains return domains
@frappe.whitelist() @jingrow.whitelist()
def activities(filters=None, order_by=None, limit_start=None, limit_page_length=None): def activities(filters=None, order_by=None, limit_start=None, limit_page_length=None):
# get all site activity except Backup by Administrator # get all site activity except Backup by Administrator
SiteActivity = frappe.qb.DocType("Site Activity") SiteActivity = frappe.qb.DocType("Site Activity")
@ -469,7 +469,7 @@ def activities(filters=None, order_by=None, limit_start=None, limit_page_length=
return activities return activities
@frappe.whitelist() @jingrow.whitelist()
def app_details_for_new_public_site(): def app_details_for_new_public_site():
fields = [ fields = [
"name", "name",
@ -527,7 +527,7 @@ def app_details_for_new_public_site():
return marketplace_apps return marketplace_apps
@frappe.whitelist() @jingrow.whitelist()
def options_for_new(for_bench: str | None = None): # noqa: C901 def options_for_new(for_bench: str | None = None): # noqa: C901
from press.utils import get_nearest_cluster from press.utils import get_nearest_cluster
@ -720,12 +720,12 @@ def set_bench_and_clusters(version, for_bench):
version.group.clusters = clusters version.group.clusters = clusters
@frappe.whitelist() @jingrow.whitelist()
def get_domain(): def get_domain():
return frappe.db.get_value("Press Settings", "Press Settings", ["domain"]) return frappe.db.get_value("Press Settings", "Press Settings", ["domain"])
@frappe.whitelist() @jingrow.whitelist()
def get_new_site_options(group: str | None = None): def get_new_site_options(group: str | None = None):
team = get_current_team() team = get_current_team()
apps = set() apps = set()
@ -814,7 +814,7 @@ def get_new_site_options(group: str | None = None):
} }
@frappe.whitelist() @jingrow.whitelist()
def get_site_plans(): def get_site_plans():
plans = Plan.get_plans( plans = Plan.get_plans(
doctype="Site Plan", doctype="Site Plan",
@ -921,7 +921,7 @@ def get_plan_details_dict(plan_details):
return plan_details_dict return plan_details_dict
@frappe.whitelist() @jingrow.whitelist()
def get_plans(name=None, rg=None): def get_plans(name=None, rg=None):
site_name = name site_name = name
plans = Plan.get_plans( plans = Plan.get_plans(
@ -997,7 +997,7 @@ def sites_with_recent_activity(sites, limit=3):
return query.run(pluck="site") return query.run(pluck="site")
@frappe.whitelist() @jingrow.whitelist()
def all(site_filter=None): def all(site_filter=None):
if site_filter is None: if site_filter is None:
site_filter = {"status": "", "tag": ""} site_filter = {"status": "", "tag": ""}
@ -1078,13 +1078,13 @@ def get_sites_query(site_filter, benches_with_updates):
return sites_query return sites_query
@frappe.whitelist() @jingrow.whitelist()
def site_tags(): def site_tags():
team = get_current_team() team = get_current_team()
return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Site"}, pluck="tag") return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Site"}, pluck="tag")
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def get(name): def get(name):
from frappe.utils.data import time_diff from frappe.utils.data import time_diff
@ -1197,7 +1197,7 @@ def get(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def check_for_updates(name): def check_for_updates(name):
site = frappe.get_pg("Site", name) site = frappe.get_pg("Site", name)
@ -1234,7 +1234,7 @@ def check_for_updates(name):
return out return out
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def installed_apps(name): def installed_apps(name):
site = frappe.get_cached_pg("Site", name) site = frappe.get_cached_pg("Site", name)
@ -1347,7 +1347,7 @@ def get_server_region_info(site) -> dict:
return frappe.db.get_value("Cluster", site.cluster, ["title", "image"], as_dict=True) return frappe.db.get_value("Cluster", site.cluster, ["title", "image"], as_dict=True)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def available_apps(name): def available_apps(name):
site = frappe.get_pg("Site", name) site = frappe.get_pg("Site", name)
@ -1412,7 +1412,7 @@ def is_prepaid_marketplace_app(app):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def current_plan(name): def current_plan(name):
from press.api.analytics import get_current_cpu_usage from press.api.analytics import get_current_cpu_usage
@ -1461,13 +1461,13 @@ def current_plan(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_plan(name, plan): def change_plan(name, plan):
frappe.get_pg("Site", name).set_plan(plan) frappe.get_pg("Site", name).set_plan(plan)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_auto_update(name, auto_update_enabled): def change_auto_update(name, auto_update_enabled):
# Not so good, it should have been "enable_auto_updates" # Not so good, it should have been "enable_auto_updates"
@ -1475,25 +1475,25 @@ def change_auto_update(name, auto_update_enabled):
return frappe.db.set_value("Site", name, "skip_auto_updates", not auto_update_enabled) return frappe.db.set_value("Site", name, "skip_auto_updates", not auto_update_enabled)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def deactivate(name): def deactivate(name):
frappe.get_pg("Site", name).deactivate() frappe.get_pg("Site", name).deactivate()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def activate(name): def activate(name):
frappe.get_pg("Site", name).activate() frappe.get_pg("Site", name).activate()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def login(name, reason=None): def login(name, reason=None):
return {"sid": frappe.get_pg("Site", name).login(reason), "site": name} return {"sid": frappe.get_pg("Site", name).login(reason), "site": name}
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def update(name, skip_failing_patches=False, skip_backups=False): def update(name, skip_failing_patches=False, skip_backups=False):
return frappe.get_pg("Site", name).schedule_update( return frappe.get_pg("Site", name).schedule_update(
@ -1501,43 +1501,43 @@ def update(name, skip_failing_patches=False, skip_backups=False):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def last_migrate_failed(name): def last_migrate_failed(name):
return frappe.get_pg("Site", name).last_migrate_failed() return frappe.get_pg("Site", name).last_migrate_failed()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def backup(name, with_files=False): def backup(name, with_files=False):
frappe.get_pg("Site", name).backup(with_files) frappe.get_pg("Site", name).backup(with_files)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def archive(name, force): def archive(name, force):
frappe.get_pg("Site", name).archive(force=force) frappe.get_pg("Site", name).archive(force=force)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def reinstall(name): def reinstall(name):
return frappe.get_pg("Site", name).reinstall() return frappe.get_pg("Site", name).reinstall()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def migrate(name, skip_failing_patches=False): def migrate(name, skip_failing_patches=False):
frappe.get_pg("Site", name).migrate(skip_failing_patches=skip_failing_patches) frappe.get_pg("Site", name).migrate(skip_failing_patches=skip_failing_patches)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def clear_cache(name): def clear_cache(name):
frappe.get_pg("Site", name).clear_site_cache() frappe.get_pg("Site", name).clear_site_cache()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def restore(name, files, skip_failing_patches=False): def restore(name, files, skip_failing_patches=False):
if not files.get("database") and not files.get("public") and not files.get("private"): if not files.get("database") and not files.get("public") and not files.get("private"):
@ -1557,7 +1557,7 @@ def restore(name, files, skip_failing_patches=False):
return site.restore_site(skip_failing_patches=skip_failing_patches) return site.restore_site(skip_failing_patches=skip_failing_patches)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def validate_restoration_space_requirements( def validate_restoration_space_requirements(
name: str, db_file_size: int, public_file_size: int, private_file_size: int name: str, db_file_size: int, public_file_size: int, private_file_size: int
@ -1602,7 +1602,7 @@ def validate_restoration_space_requirements(
} }
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=60) @rate_limit(limit=10, seconds=60)
def exists(subdomain, domain): def exists(subdomain, domain):
from press.press.doctype.site.site import Site from press.press.doctype.site.site import Site
@ -1610,84 +1610,84 @@ def exists(subdomain, domain):
return Site.exists(subdomain, domain) return Site.exists(subdomain, domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def setup_wizard_complete(name): def setup_wizard_complete(name):
return frappe.get_pg("Site", name).is_setup_wizard_complete() return frappe.get_pg("Site", name).is_setup_wizard_complete()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def check_dns(name, domain): def check_dns(name, domain):
return check_dns_cname_a(name, domain) return check_dns_cname_a(name, domain)
@frappe.whitelist() @jingrow.whitelist()
def domain_exists(domain): def domain_exists(domain):
return frappe.db.get_value("Site Domain", domain.lower(), "site") return frappe.db.get_value("Site Domain", domain.lower(), "site")
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def add_domain(name, domain): def add_domain(name, domain):
frappe.get_pg("Site", name).add_domain(domain) frappe.get_pg("Site", name).add_domain(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def remove_domain(name, domain): def remove_domain(name, domain):
frappe.get_pg("Site", name).remove_domain(domain) frappe.get_pg("Site", name).remove_domain(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def retry_add_domain(name, domain): def retry_add_domain(name, domain):
frappe.get_pg("Site", name).retry_add_domain(domain) frappe.get_pg("Site", name).retry_add_domain(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def set_host_name(name, domain): def set_host_name(name, domain):
frappe.get_pg("Site", name).set_host_name(domain) frappe.get_pg("Site", name).set_host_name(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def set_redirect(name, domain): def set_redirect(name, domain):
frappe.get_pg("Site", name).set_redirect(domain) frappe.get_pg("Site", name).set_redirect(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def unset_redirect(name, domain): def unset_redirect(name, domain):
frappe.get_pg("Site", name).unset_redirect(domain) frappe.get_pg("Site", name).unset_redirect(domain)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def install_app(name, app, plan=None): def install_app(name, app, plan=None):
frappe.get_pg("Site", name).install_app(app, plan) frappe.get_pg("Site", name).install_app(app, plan)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def uninstall_app(name, app): def uninstall_app(name, app):
frappe.get_pg("Site", name).uninstall_app(app) frappe.get_pg("Site", name).uninstall_app(app)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def logs(name): def logs(name):
return frappe.get_pg("Site", name).server_logs return frappe.get_pg("Site", name).server_logs
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def log(name, log): def log(name, log):
return frappe.get_pg("Site", name).get_server_log(log) return frappe.get_pg("Site", name).get_server_log(log)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def site_config(name): def site_config(name):
site = frappe.get_pg("Site", name) site = frappe.get_pg("Site", name)
@ -1702,7 +1702,7 @@ def site_config(name):
return config return config
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def update_config(name, config): def update_config(name, config):
config = frappe.parse_json(config) config = frappe.parse_json(config)
@ -1729,12 +1729,12 @@ def update_config(name, config):
return list(filter(lambda x: not x.internal, site.configuration)) return list(filter(lambda x: not x.internal, site.configuration))
@frappe.whitelist() @jingrow.whitelist()
def get_trial_plan(): def get_trial_plan():
return frappe.db.get_value("Press Settings", None, "press_trial_plan") return frappe.db.get_value("Press Settings", None, "press_trial_plan")
@frappe.whitelist() @jingrow.whitelist()
def get_upload_link(file, parts=1): def get_upload_link(file, parts=1):
bucket_name = frappe.db.get_single_value("Press Settings", "remote_uploads_bucket") bucket_name = frappe.db.get_single_value("Press Settings", "remote_uploads_bucket")
expiration = frappe.db.get_single_value("Press Settings", "remote_link_expiry") or 3600 expiration = frappe.db.get_single_value("Press Settings", "remote_link_expiry") or 3600
@ -1777,7 +1777,7 @@ def get_upload_link(file, parts=1):
log_error("Failed to Generate Presigned URL", content=e) log_error("Failed to Generate Presigned URL", content=e)
@frappe.whitelist() @jingrow.whitelist()
def multipart_exit(file, id, action, parts=None): def multipart_exit(file, id, action, parts=None):
bucket_name = frappe.db.get_single_value("Press Settings", "remote_uploads_bucket") bucket_name = frappe.db.get_single_value("Press Settings", "remote_uploads_bucket")
s3_client = client( s3_client = client(
@ -1805,7 +1805,7 @@ def multipart_exit(file, id, action, parts=None):
return response return response
@frappe.whitelist() @jingrow.whitelist()
def uploaded_backup_info(file=None, path=None, type=None, size=None, url=None): def uploaded_backup_info(file=None, path=None, type=None, size=None, url=None):
pg = frappe.get_pg( pg = frappe.get_pg(
{ {
@ -1822,7 +1822,7 @@ def uploaded_backup_info(file=None, path=None, type=None, size=None, url=None):
return pg.name return pg.name
@frappe.whitelist() @jingrow.whitelist()
def get_backup_links(url, email, password): def get_backup_links(url, email, password):
try: try:
files = get_frappe_backups(url, email, password) files = get_frappe_backups(url, email, password)
@ -1843,7 +1843,7 @@ def get_backup_links(url, email, password):
return remote_files return remote_files
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def enable_auto_update(name): def enable_auto_update(name):
site_pg = frappe.get_pg("Site", name) site_pg = frappe.get_pg("Site", name)
@ -1852,7 +1852,7 @@ def enable_auto_update(name):
site_pg.save() site_pg.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def disable_auto_update(name): def disable_auto_update(name):
site_pg = frappe.get_pg("Site", name) site_pg = frappe.get_pg("Site", name)
@ -1861,13 +1861,13 @@ def disable_auto_update(name):
site_pg.save() site_pg.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def get_auto_update_info(name): def get_auto_update_info(name):
return frappe.get_pg("Site", name).get_auto_update_info() return frappe.get_pg("Site", name).get_auto_update_info()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def update_auto_update_info(name, info=None): def update_auto_update_info(name, info=None):
site_pg = frappe.get_pg("Site", name, for_update=True) site_pg = frappe.get_pg("Site", name, for_update=True)
@ -1875,18 +1875,18 @@ def update_auto_update_info(name, info=None):
site_pg.save() site_pg.save()
@frappe.whitelist() @jingrow.whitelist()
def get_job_status(job_name): def get_job_status(job_name):
return {"status": frappe.db.get_value("Agent Job", job_name, "status")} return {"status": frappe.db.get_value("Agent Job", job_name, "status")}
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def send_change_team_request(name, team_mail_id, reason): def send_change_team_request(name, team_mail_id, reason):
frappe.get_pg("Site", name).send_change_team_request(team_mail_id, reason) frappe.get_pg("Site", name).send_change_team_request(team_mail_id, reason)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def confirm_site_transfer(key: str): def confirm_site_transfer(key: str):
from frappe import _ from frappe import _
@ -1937,7 +1937,7 @@ def confirm_site_transfer(key: str):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def add_server_to_release_group(name, group_name, server=None): def add_server_to_release_group(name, group_name, server=None):
if not server: if not server:
@ -1966,7 +1966,7 @@ def add_server_to_release_group(name, group_name, server=None):
return frappe.get_value("Agent Job", {"bench": bench, "job_type": "New Bench"}, "name") return frappe.get_value("Agent Job", {"bench": bench, "job_type": "New Bench"}, "name")
@frappe.whitelist() @jingrow.whitelist()
def validate_group_for_upgrade(name, group_name): def validate_group_for_upgrade(name, group_name):
server = frappe.db.get_value("Site", name, "server") server = frappe.db.get_value("Site", name, "server")
rg = frappe.get_pg("Release Group", group_name) rg = frappe.get_pg("Release Group", group_name)
@ -1975,7 +1975,7 @@ def validate_group_for_upgrade(name, group_name):
return True return True
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@role_guard.document( @role_guard.document(
document_type=lambda _: "Release Group", document_type=lambda _: "Release Group",
@ -2014,7 +2014,7 @@ def change_group_options(name, release_groups=None):
return query.run(as_dict=True) return query.run(as_dict=True)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def clone_group(name: str, new_group_title: str, server: str | None = None): def clone_group(name: str, new_group_title: str, server: str | None = None):
site = frappe.get_pg("Site", name) site = frappe.get_pg("Site", name)
@ -2049,7 +2049,7 @@ def clone_group(name: str, new_group_title: str, server: str | None = None):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_group(name, group, skip_failing_patches=False): def change_group(name, group, skip_failing_patches=False):
team = frappe.db.get_value("Release Group", group, "team") team = frappe.db.get_value("Release Group", group, "team")
@ -2060,7 +2060,7 @@ def change_group(name, group, skip_failing_patches=False):
site.move_to_group(group, skip_failing_patches=skip_failing_patches) site.move_to_group(group, skip_failing_patches=skip_failing_patches)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_region_options(name): def change_region_options(name):
group, cluster = frappe.db.get_value("Site", name, ["group", "cluster"]) group, cluster = frappe.db.get_value("Site", name, ["group", "cluster"])
@ -2077,7 +2077,7 @@ def change_region_options(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_region(name, cluster, scheduled_datetime=None, skip_failing_patches=False): def change_region(name, cluster, scheduled_datetime=None, skip_failing_patches=False):
group = frappe.db.get_value("Site", name, "group") group = frappe.db.get_value("Site", name, "group")
@ -2107,7 +2107,7 @@ def change_region(name, cluster, scheduled_datetime=None, skip_failing_patches=F
site_migration.start() site_migration.start()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
@role_guard.document( @role_guard.document(
document_type=lambda _: "Release Group", document_type=lambda _: "Release Group",
@ -2148,7 +2148,7 @@ def get_private_groups_for_upgrade(name, version, release_groups=None):
return query.run(as_dict=True) return query.run(as_dict=True)
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def version_upgrade( def version_upgrade(
name, destination_group, scheduled_datetime=None, skip_failing_patches=False, skip_backups=False name, destination_group, scheduled_datetime=None, skip_failing_patches=False, skip_backups=False
@ -2196,7 +2196,7 @@ def version_upgrade(
version_upgrade.start() version_upgrade.start()
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_server_options(name): def change_server_options(name):
site = Site("Site", name) site = Site("Site", name)
@ -2210,7 +2210,7 @@ def change_server_options(name):
} }
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def is_server_added_in_group(name, server): def is_server_added_in_group(name, server):
site_group = frappe.get_value("Site", name, "group") site_group = frappe.get_value("Site", name, "group")
@ -2220,7 +2220,7 @@ def is_server_added_in_group(name, server):
return True return True
@frappe.whitelist() @jingrow.whitelist()
@protected("Site") @protected("Site")
def change_server(name, server, scheduled_datetime=None, skip_failing_patches=False): def change_server(name, server, scheduled_datetime=None, skip_failing_patches=False):
group = frappe.db.get_value("Site", name, "group") group = frappe.db.get_value("Site", name, "group")
@ -2257,7 +2257,7 @@ def change_server(name, server, scheduled_datetime=None, skip_failing_patches=Fa
site_migration.start() site_migration.start()
@frappe.whitelist() @jingrow.whitelist()
def get_site_config_standard_keys(): def get_site_config_standard_keys():
return frappe.get_all( return frappe.get_all(
"Site Config Key", "Site Config Key",
@ -2267,7 +2267,7 @@ def get_site_config_standard_keys():
) )
@frappe.whitelist() @jingrow.whitelist()
def fetch_sites_data_for_export(): def fetch_sites_data_for_export():
from press.api.client import get_list from press.api.client import get_list

2
press/api/site_backup.py
View File

@ -10,7 +10,7 @@ if TYPE_CHECKING:
from botocore.exceptions import ClientError from botocore.exceptions import ClientError
@frappe.whitelist(allow_guest=True, methods="POST") @jingrow.whitelist(allow_guest=True, methods="POST")
def create_snapshot(name: str, key: str): def create_snapshot(name: str, key: str):
""" """
This API will be called by agent during physical backup of database server. This API will be called by agent during physical backup of database server.

12
press/api/site_login.py
View File

@ -10,7 +10,7 @@ from frappe.rate_limiter import rate_limit
from press.utils.extra import disabled from press.utils.extra import disabled
@frappe.whitelist(allow_guest=True, methods=["POST"]) @jingrow.whitelist(allow_guest=True, methods=["POST"])
def sync_product_site_user(**data): def sync_product_site_user(**data):
""" """
Sync user info from product site Sync user info from product site
@ -61,7 +61,7 @@ def sync_product_site_user(**data):
).insert(ignore_permissions=True) ).insert(ignore_permissions=True)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=60) @rate_limit(limit=10, seconds=60)
@disabled @disabled
def get_product_sites_of_user(user: str): def get_product_sites_of_user(user: str):
@ -97,7 +97,7 @@ def get_product_sites_of_user(user: str):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 5) @rate_limit(limit=5, seconds=60 * 5)
def send_otp(email: str): def send_otp(email: str):
""" """
@ -112,7 +112,7 @@ def send_otp(email: str):
return session.send_otp() return session.send_otp()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def verify_otp(email: str, otp: str): def verify_otp(email: str, otp: str):
""" """
@ -147,7 +147,7 @@ def verify_otp(email: str, otp: str):
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
@disabled @disabled
def login_to_site(email: str, site: str): def login_to_site(email: str, site: str):
@ -170,7 +170,7 @@ def login_to_site(email: str, site: str):
return site_user.login_to_site() return site_user.login_to_site()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60) @rate_limit(limit=5, seconds=60)
def check_session_id(): def check_session_id():
""" """

24
press/api/spaces.py
View File

@ -6,7 +6,7 @@ from press.api.site import protected
from press.utils import get_current_team from press.utils import get_current_team
@frappe.whitelist() @jingrow.whitelist()
def spaces(space_filter: Dict | None) -> Dict: def spaces(space_filter: Dict | None) -> Dict:
""" """
Returns all spaces and code servers for the current team Returns all spaces and code servers for the current team
@ -45,7 +45,7 @@ def spaces(space_filter: Dict | None) -> Dict:
} }
@frappe.whitelist() @jingrow.whitelist()
def code_server_domain(): def code_server_domain():
""" """
Returns the domain for code servers Returns the domain for code servers
@ -53,7 +53,7 @@ def code_server_domain():
return frappe.db.get_single_value("Press Settings", "spaces_domain") return frappe.db.get_single_value("Press Settings", "spaces_domain")
@frappe.whitelist() @jingrow.whitelist()
def code_server_group_options(): def code_server_group_options():
return frappe.get_all( return frappe.get_all(
"Release Group", "Release Group",
@ -67,7 +67,7 @@ def code_server_group_options():
) )
@frappe.whitelist() @jingrow.whitelist()
def code_server_bench_options(group): def code_server_bench_options(group):
valid_candidates = frappe.get_all( valid_candidates = frappe.get_all(
"Deploy Candidate", "Deploy Candidate",
@ -91,38 +91,38 @@ def code_server_bench_options(group):
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Code Server") @protected("Code Server")
def code_server(name): def code_server(name):
return frappe.get_pg("Code Server", name) return frappe.get_pg("Code Server", name)
@frappe.whitelist() @jingrow.whitelist()
@protected("Code Server") @protected("Code Server")
def stop_code_server(name) -> None: def stop_code_server(name) -> None:
frappe.get_pg("Code Server", name).stop() frappe.get_pg("Code Server", name).stop()
@frappe.whitelist() @jingrow.whitelist()
@protected("Code Server") @protected("Code Server")
def start_code_server(name) -> None: def start_code_server(name) -> None:
frappe.get_pg("Code Server", name).start() frappe.get_pg("Code Server", name).start()
@frappe.whitelist() @jingrow.whitelist()
def code_server_password(name) -> str: def code_server_password(name) -> str:
if get_current_team() != frappe.db.get_value("Code Server", name, "team"): if get_current_team() != frappe.db.get_value("Code Server", name, "team"):
frappe.throw("Not allowed", frappe.PermissionError) frappe.throw("Not allowed", frappe.PermissionError)
return frappe.utils.password.get_decrypted_password("Code Server", name, "password") return frappe.utils.password.get_decrypted_password("Code Server", name, "password")
@frappe.whitelist() @jingrow.whitelist()
@protected("Code Server") @protected("Code Server")
def drop_code_server(name) -> None: def drop_code_server(name) -> None:
frappe.get_pg("Code Server", name).archive() frappe.get_pg("Code Server", name).archive()
@frappe.whitelist() @jingrow.whitelist()
def create_code_server(subdomain, domain, bench) -> str: def create_code_server(subdomain, domain, bench) -> str:
""" """
Create a new code server pg Create a new code server pg
@ -143,7 +143,7 @@ def create_code_server(subdomain, domain, bench) -> str:
return code_server.name return code_server.name
@frappe.whitelist() @jingrow.whitelist()
def exists(subdomain, domain) -> bool: def exists(subdomain, domain) -> bool:
""" """
Checks if a subdomain is already taken Checks if a subdomain is already taken
@ -161,7 +161,7 @@ def exists(subdomain, domain) -> bool:
) )
@frappe.whitelist() @jingrow.whitelist()
@protected("Code Server") @protected("Code Server")
def code_server_jobs( def code_server_jobs(
filters=None, order_by=None, limit_start=None, limit_page_length=None filters=None, order_by=None, limit_start=None, limit_page_length=None

2
press/api/telegram.py
View File

@ -8,7 +8,7 @@ from press.telegram_utils import Telegram
from press.utils import log_error from press.utils import log_error
@frappe.whitelist(allow_guest=True, xss_safe=True) @jingrow.whitelist(allow_guest=True, xss_safe=True)
def hook(*args, **kwargs): def hook(*args, **kwargs):
try: try:
# set user to Administrator, to not have to do ignore_permissions everywhere # set user to Administrator, to not have to do ignore_permissions everywhere

10
press/api/webhook.py
View File

@ -11,7 +11,7 @@ from press.api.site import protected
from press.guards import role_guard from press.guards import role_guard
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def available_events(): def available_events():
return frappe.get_all( return frappe.get_all(
"Press Webhook Event", "Press Webhook Event",
@ -21,7 +21,7 @@ def available_events():
) )
@frappe.whitelist() @jingrow.whitelist()
@role_guard.document(document_type=lambda _: "Press Webhook") @role_guard.document(document_type=lambda _: "Press Webhook")
def add(endpoint: str, secret: str, events: list[str]): def add(endpoint: str, secret: str, events: list[str]):
pg = frappe.new_pg("Press Webhook") pg = frappe.new_pg("Press Webhook")
@ -33,7 +33,7 @@ def add(endpoint: str, secret: str, events: list[str]):
pg.save() pg.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Press Webhook") @protected("Press Webhook")
@role_guard.document(document_type=lambda _: "Press Webhook") @role_guard.document(document_type=lambda _: "Press Webhook")
def update(name: str, endpoint: str, secret: str, events: list[str]): def update(name: str, endpoint: str, secret: str, events: list[str]):
@ -46,7 +46,7 @@ def update(name: str, endpoint: str, secret: str, events: list[str]):
pg.save() pg.save()
@frappe.whitelist() @jingrow.whitelist()
@protected("Press Webhook") @protected("Press Webhook")
@role_guard.document(document_type=lambda _: "Press Webhook Log") @role_guard.document(document_type=lambda _: "Press Webhook Log")
def attempts(webhook: str): def attempts(webhook: str):
@ -73,7 +73,7 @@ def attempts(webhook: str):
return query.run(as_dict=1) return query.run(as_dict=1)
@frappe.whitelist() @jingrow.whitelist()
@role_guard.document(document_type=lambda _: "Press Webhook Attempt") @role_guard.document(document_type=lambda _: "Press Webhook Attempt")
def attempt(name: str): def attempt(name: str):
pg = frappe.get_pg("Press Webhook Attempt", name) pg = frappe.get_pg("Press Webhook Attempt", name)

2
press/experimental/doctype/referral_bonus/referral_bonus.py
View File

@ -6,7 +6,7 @@ from frappe.model.document import Document
class ReferralBonus(Document): class ReferralBonus(Document):
@frappe.whitelist() @jingrow.whitelist()
def allocate_credits(self): def allocate_credits(self):
# Credits have already been allocated # Credits have already been allocated
if self.credits_allocated: if self.credits_allocated:

2
press/incident_management/doctype/incident_investigator/incident_investigator.py
View File

@ -332,7 +332,7 @@ class IncidentInvestigator(Document):
enqueue_after_commit=True, enqueue_after_commit=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def start_investigation(self): def start_investigation(self):
if self.status == "Pending": if self.status == "Pending":
frappe.enqueue_pg(self.doctype, self.name, "investigate", queue="long") frappe.enqueue_pg(self.doctype, self.name, "investigate", queue="long")

12
press/infrastructure/doctype/arm_build_record/arm_build_record.py
View File

@ -78,7 +78,7 @@ class ARMBuildRecord(Document):
return False return False
return agent_job.status == "Success" return agent_job.status == "Success"
@frappe.whitelist() @jingrow.whitelist()
def remove_build_from_deploy_candidate(self, build: str): def remove_build_from_deploy_candidate(self, build: str):
""" """
Remove arm build field from deploy candidate. Remove arm build field from deploy candidate.
@ -88,13 +88,13 @@ class ARMBuildRecord(Document):
frappe.db.set_value("Deploy Candidate", deploy_candidate, "arm_build", None) frappe.db.set_value("Deploy Candidate", deploy_candidate, "arm_build", None)
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def retry(self): def retry(self):
server: Server = frappe.get_pg("Server", self.server) server: Server = frappe.get_pg("Server", self.server)
server.collect_arm_images() server.collect_arm_images()
self.delete(ignore_permissions=True) self.delete(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def cancel_all_jobs(self): def cancel_all_jobs(self):
"""Cancel all current running jobs""" """Cancel all current running jobs"""
self.sync_status() self.sync_status()
@ -109,7 +109,7 @@ class ARMBuildRecord(Document):
self.sync_status() self.sync_status()
@frappe.whitelist() @jingrow.whitelist()
def pull_images(self): def pull_images(self):
"""Pull images on app server using image tags""" """Pull images on app server using image tags"""
builds = [] builds = []
@ -125,7 +125,7 @@ class ARMBuildRecord(Document):
) )
self._pull_images(image_tags) self._pull_images(image_tags)
@frappe.whitelist() @jingrow.whitelist()
def update_image_tags_on_benches(self): def update_image_tags_on_benches(self):
""" """
This step replaces the image tags on the app server itself. This step replaces the image tags on the app server itself.
@ -139,7 +139,7 @@ class ARMBuildRecord(Document):
) )
self._update_image_tags_on_benches() self._update_image_tags_on_benches()
@frappe.whitelist() @jingrow.whitelist()
def sync_status(self): def sync_status(self):
for arm_image in self.arm_images: for arm_image in self.arm_images:
if arm_image.status in Status.terminal(): if arm_image.status in Status.terminal():

2
press/infrastructure/doctype/ssh_access_audit/ssh_access_audit.py
View File

@ -64,7 +64,7 @@ class SSHAccessAudit(Document):
def before_insert(self): def before_insert(self):
self.set_inventory() self.set_inventory()
@frappe.whitelist() @jingrow.whitelist()
def run(self): def run(self):
frappe.only_for("System Manager") frappe.only_for("System Manager")
self.status = "Running" self.status = "Running"

12
press/infrastructure/doctype/virtual_disk_resize/virtual_disk_resize.py
View File

@ -114,7 +114,7 @@ class VirtualDiskResize(Document):
frappe.db.commit() frappe.db.commit()
return False return False
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
if not self.get_lock(): if not self.get_lock():
return return
@ -527,7 +527,7 @@ class VirtualDiskResize(Document):
self.old_volume_status = "Deleted" self.old_volume_status = "Deleted"
return StepStatus.Success return StepStatus.Success
@frappe.whitelist() @jingrow.whitelist()
def propagate_volume_id(self) -> StepStatus: def propagate_volume_id(self) -> StepStatus:
"Propagate volume id" "Propagate volume id"
machine = self.machine machine = self.machine
@ -605,7 +605,7 @@ class VirtualDiskResize(Document):
self.duration = (self.end - self.start).total_seconds() self.duration = (self.end - self.start).total_seconds()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self, ignore_version=False) -> None: def next(self, ignore_version=False) -> None:
self.status = Status.Running self.status = Status.Running
self.save(ignore_version=ignore_version) self.save(ignore_version=ignore_version)
@ -625,7 +625,7 @@ class VirtualDiskResize(Document):
at_front=True, at_front=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self) -> None: def force_continue(self) -> None:
# Mark all failed and skipped steps as pending # Mark all failed and skipped steps as pending
for step in self.steps: for step in self.steps:
@ -633,7 +633,7 @@ class VirtualDiskResize(Document):
step.status = StepStatus.Pending step.status = StepStatus.Pending
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self) -> None: def force_fail(self) -> None:
# Mark all pending steps as failure # Mark all pending steps as failure
for step in self.steps: for step in self.steps:
@ -649,7 +649,7 @@ class VirtualDiskResize(Document):
return step return step
return None return None
@frappe.whitelist() @jingrow.whitelist()
def execute_step(self, step_name): def execute_step(self, step_name):
step = self.get_step(step_name) step = self.get_step(step_name)

10
press/infrastructure/doctype/virtual_machine_migration/virtual_machine_migration.py
View File

@ -576,7 +576,7 @@ class VirtualMachineMigration(Document):
return StepStatus.Success return StepStatus.Success
return StepStatus.Failure return StepStatus.Failure
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
self.status = "Running" self.status = "Running"
self.start = frappe.utils.now_datetime() self.start = frappe.utils.now_datetime()
@ -598,7 +598,7 @@ class VirtualMachineMigration(Document):
self.duration = (self.end - self.start).total_seconds() self.duration = (self.end - self.start).total_seconds()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self, ignore_version=False) -> None: def next(self, ignore_version=False) -> None:
self.status = "Running" self.status = "Running"
self.save(ignore_version=ignore_version) self.save(ignore_version=ignore_version)
@ -618,7 +618,7 @@ class VirtualMachineMigration(Document):
at_front=True, at_front=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self) -> None: def force_continue(self) -> None:
# Mark all failed and skipped steps as pending # Mark all failed and skipped steps as pending
for step in self.steps: for step in self.steps:
@ -626,7 +626,7 @@ class VirtualMachineMigration(Document):
step.status = "Pending" step.status = "Pending"
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self) -> None: def force_fail(self) -> None:
# Mark all pending steps as failure # Mark all pending steps as failure
for step in self.steps: for step in self.steps:
@ -641,7 +641,7 @@ class VirtualMachineMigration(Document):
return step return step
return None return None
@frappe.whitelist() @jingrow.whitelist()
def execute_step(self, step_name): def execute_step(self, step_name):
step = self.get_step(step_name) step = self.get_step(step_name)

10
press/infrastructure/doctype/virtual_machine_replacement/virtual_machine_replacement.py
View File

@ -235,7 +235,7 @@ class VirtualMachineReplacement(Document):
subprocess.check_call(shlex.split(command)) subprocess.check_call(shlex.split(command))
return StepStatus.Success return StepStatus.Success
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
self.status = "Running" self.status = "Running"
self.start = frappe.utils.now_datetime() self.start = frappe.utils.now_datetime()
@ -257,7 +257,7 @@ class VirtualMachineReplacement(Document):
self.duration = (self.end - self.start).total_seconds() self.duration = (self.end - self.start).total_seconds()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self, ignore_version=False) -> None: def next(self, ignore_version=False) -> None:
self.status = "Running" self.status = "Running"
self.save(ignore_version=ignore_version) self.save(ignore_version=ignore_version)
@ -277,7 +277,7 @@ class VirtualMachineReplacement(Document):
at_front=True, at_front=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self) -> None: def force_continue(self) -> None:
# Mark all failed and skipped steps as pending # Mark all failed and skipped steps as pending
for step in self.steps: for step in self.steps:
@ -285,7 +285,7 @@ class VirtualMachineReplacement(Document):
step.status = "Pending" step.status = "Pending"
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self) -> None: def force_fail(self) -> None:
# Mark all pending steps as failure # Mark all pending steps as failure
for step in self.steps: for step in self.steps:
@ -300,7 +300,7 @@ class VirtualMachineReplacement(Document):
return step return step
return None return None
@frappe.whitelist() @jingrow.whitelist()
def execute_step(self, step_name): def execute_step(self, step_name):
step = self.get_step(step_name) step = self.get_step(step_name)

2
press/marketplace/doctype/marketplace_app_subscription/marketplace_app_subscription.py
View File

@ -128,7 +128,7 @@ class MarketplaceAppSubscription(Document):
site_pg.update_site_config(config) site_pg.update_site_config(config)
@frappe.whitelist() @jingrow.whitelist()
def activate(self): def activate(self):
if self.status == "Active": if self.status == "Active":
frappe.throw("Subscription is already active.") frappe.throw("Subscription is already active.")

2
press/overrides.py
View File

@ -15,7 +15,7 @@ from press.runner import constants
from press.utils import _get_current_team, _system_user from press.utils import _get_current_team, _system_user
@frappe.whitelist() @jingrow.whitelist()
def upload_file(): def upload_file():
files = frappe.request.files files = frappe.request.files
is_private = frappe.form_dict.is_private is_private = frappe.form_dict.is_private

2
press/press/doctype/account_request/account_request.py
View File

@ -180,7 +180,7 @@ class AccountRequest(Document):
self.otp = 111111 self.otp = 111111
self.save(ignore_permissions=True) self.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def send_verification_email(self): # noqa: C901 def send_verification_email(self): # noqa: C901
url = self.get_verification_url() url = self.get_verification_url()

2
press/press/doctype/add_on_settings/add_on_settings.py
View File

@ -18,7 +18,7 @@ class AddOnSettings(Document):
aws_secret_key: DF.Password | None aws_secret_key: DF.Password | None
# end: auto-generated types # end: auto-generated types
@frappe.whitelist() @jingrow.whitelist()
def init_etcd_data(self, proxy_server): def init_etcd_data(self, proxy_server):
# TODO: Add a separate agent job for this, instead of doing it recursively here do it on server # TODO: Add a separate agent job for this, instead of doing it recursively here do it on server
subs = frappe.get_all( subs = frappe.get_all(

16
press/press/doctype/agent_job/agent_job.py
View File

@ -249,7 +249,7 @@ class AgentJob(Document):
) )
pg.insert() pg.insert()
@frappe.whitelist() @jingrow.whitelist()
def retry(self): def retry(self):
return frappe.get_pg( return frappe.get_pg(
{ {
@ -269,12 +269,12 @@ class AgentJob(Document):
} }
).insert() ).insert()
@frappe.whitelist() @jingrow.whitelist()
def retry_in_place(self): def retry_in_place(self):
self.enqueue_http_request() self.enqueue_http_request()
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def get_status(self): def get_status(self):
agent = Agent(self.server, server_type=self.server_type) agent = Agent(self.server, server_type=self.server_type)
@ -287,7 +287,7 @@ class AgentJob(Document):
update_job(self.name, polled_job) update_job(self.name, polled_job)
update_steps(self.name, polled_job) update_steps(self.name, polled_job)
@frappe.whitelist() @jingrow.whitelist()
def retry_skip_failing_patches(self): def retry_skip_failing_patches(self):
# Add the skip flag and update request data # Add the skip flag and update request data
updated_request_data = json.loads(self.request_data) if self.request_data else {} updated_request_data = json.loads(self.request_data) if self.request_data else {}
@ -296,23 +296,23 @@ class AgentJob(Document):
return self.retry() return self.retry()
@frappe.whitelist() @jingrow.whitelist()
def succeed_and_process_job_updates(self): def succeed_and_process_job_updates(self):
self.status = "Success" self.status = "Success"
self.save() self.save()
self.process_job_updates() self.process_job_updates()
@frappe.whitelist() @jingrow.whitelist()
def fail_and_process_job_updates(self): def fail_and_process_job_updates(self):
self.status = "Failure" self.status = "Failure"
self.save() self.save()
self.process_job_updates() self.process_job_updates()
@frappe.whitelist() @jingrow.whitelist()
def process_job_updates(self): def process_job_updates(self):
process_job_updates(self.name) process_job_updates(self.name)
@frappe.whitelist() @jingrow.whitelist()
def cancel_job(self): def cancel_job(self):
agent = Agent(self.server, server_type=self.server_type) agent = Agent(self.server, server_type=self.server_type)
agent.cancel_job(self.job_id) agent.cancel_job(self.job_id)

8
press/press/doctype/agent_update/agent_update.py
View File

@ -200,7 +200,7 @@ class AgentUpdate(Document):
for server in servers: for server in servers:
self.append("servers", {"server": server, "server_type": "Proxy Server", "status": "Draft"}) self.append("servers", {"server": server, "server_type": "Proxy Server", "status": "Draft"})
@frappe.whitelist() @jingrow.whitelist()
def split_updates(self, no_of_batches: int): def split_updates(self, no_of_batches: int):
if self.status != "Pending": if self.status != "Pending":
frappe.throw("You can only split updates when the status is Pending") frappe.throw("You can only split updates when the status is Pending")
@ -282,7 +282,7 @@ class AgentUpdate(Document):
frappe.msgprint(f"Agent Update has been split into {no_of_batches} batches") frappe.msgprint(f"Agent Update has been split into {no_of_batches} batches")
@frappe.whitelist() @jingrow.whitelist()
def create_execution_plan(self): def create_execution_plan(self):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.doctype,
@ -360,12 +360,12 @@ class AgentUpdate(Document):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def pause(self): def pause(self):
self.status = "Paused" self.status = "Paused"
self.save(ignore_version=True) self.save(ignore_version=True)
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
if self._process_next_step(): if self._process_next_step():
frappe.enqueue_pg( frappe.enqueue_pg(

2
press/press/doctype/analytics_server/analytics_server.py
View File

@ -110,6 +110,6 @@ class AnalyticsServer(BaseServer):
log_error("Analytics Server Setup Exception", server=self.as_dict()) log_error("Analytics Server Setup Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def show_plausible_password(self): def show_plausible_password(self):
return self.get_password("plausible_password") return self.get_password("plausible_password")

2
press/press/doctype/ansible_console/ansible_console.py
View File

@ -57,7 +57,7 @@ class AnsibleConsole(Document):
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def execute_command(pg): def execute_command(pg):
frappe.enqueue( frappe.enqueue(
"press.press.doctype.ansible_console.ansible_console._execute_command", "press.press.doctype.ansible_console.ansible_console._execute_command",

4
press/press/doctype/app_patch/app_patch.py
View File

@ -106,7 +106,7 @@ class AppPatch(Document):
def revert_patch(self): def revert_patch(self):
self.patch_app(revert=True) self.patch_app(revert=True)
@frappe.whitelist() @jingrow.whitelist()
def delete_patch(self): def delete_patch(self):
if self.status != "Not Applied": if self.status != "Not Applied":
frappe.throw( frappe.throw(
@ -146,7 +146,7 @@ class AppPatch(Document):
app_patch.save() app_patch.save()
@frappe.whitelist() @jingrow.whitelist()
def revert_all_patches(self): def revert_all_patches(self):
# TODO: Agent job: git reset RELEASE_COMMIT --hard # TODO: Agent job: git reset RELEASE_COMMIT --hard
pass pass

4
press/press/doctype/app_release/app_release.py
View File

@ -202,7 +202,7 @@ class AppRelease(Document):
"""Return the commit URL for this app release""" """Return the commit URL for this app release"""
return f"{self.get_source().repository_url}/commit/{self.hash}" return f"{self.get_source().repository_url}/commit/{self.hash}"
@frappe.whitelist() @jingrow.whitelist()
def clone(self): def clone(self):
frappe.enqueue_pg(self.doctype, self.name, "_clone") frappe.enqueue_pg(self.doctype, self.name, "_clone")
@ -318,7 +318,7 @@ class AppRelease(Document):
if self.clone_directory and os.path.exists(self.clone_directory): if self.clone_directory and os.path.exists(self.clone_directory):
shutil.rmtree(self.clone_directory) shutil.rmtree(self.clone_directory)
@frappe.whitelist() @jingrow.whitelist()
def cleanup(self): def cleanup(self):
self.on_trash() self.on_trash()
self.cloned = False self.cloned = False

2
press/press/doctype/app_release_approval_request/app_release_approval_request.py
View File

@ -153,7 +153,7 @@ class AppReleaseApprovalRequest(Document):
template="app_approval_request_update", template="app_approval_request_update",
) )
@frappe.whitelist() @jingrow.whitelist()
def start_screening(self): def start_screening(self):
self.release = frappe.get_pg("App Release", self.app_release, for_update=True) self.release = frappe.get_pg("App Release", self.app_release, for_update=True)
self._set_baseline() self._set_baseline()

2
press/press/doctype/app_source/app_source.py
View File

@ -143,7 +143,7 @@ class AppSource(Document):
self.validate_dependent_apps() self.validate_dependent_apps()
# self.create_release() # self.create_release()
@frappe.whitelist() @jingrow.whitelist()
def create_release( def create_release(
self, self,
force: bool = False, force: bool = False,

2
press/press/doctype/auto_scale_record/auto_scale_record.py
View File

@ -629,7 +629,7 @@ class AutoScaleRecord(Document, AutoScaleStepFailureHandler, StepHandler):
if self.status != "Scheduled": if self.status != "Scheduled":
self.execute_scale_steps() self.execute_scale_steps()
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self): def force_continue(self):
self.execute_scale_steps() self.execute_scale_steps()

18
press/press/doctype/bench/bench.py
View File

@ -393,7 +393,7 @@ class Bench(Document):
"vcpu": self.vcpu, "vcpu": self.vcpu,
} }
@frappe.whitelist() @jingrow.whitelist()
def correct_bench_permissions(self): def correct_bench_permissions(self):
"""Give all permissions to frappe:frappe in (container:/home/frappe)""" """Give all permissions to frappe:frappe in (container:/home/frappe)"""
frappe.enqueue_pg( frappe.enqueue_pg(
@ -419,7 +419,7 @@ class Bench(Document):
except Exception: except Exception:
log_error("Bench Permissions Correction Exception", server=self.as_dict()) log_error("Bench Permissions Correction Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def force_update_limits(self): def force_update_limits(self):
agent = Agent(self.server) agent = Agent(self.server)
agent.force_update_bench_limits(self.name, self.get_limits()) agent.force_update_bench_limits(self.name, self.get_limits())
@ -501,7 +501,7 @@ class Bench(Document):
process_snapshot.insert() process_snapshot.insert()
return process_snapshot.name return process_snapshot.name
@frappe.whitelist() @jingrow.whitelist()
def sync_info(self): def sync_info(self):
"""Initiates a Job to update Site Usage, site.config.encryption_key and timezone details for all sites on Bench.""" """Initiates a Job to update Site Usage, site.config.encryption_key and timezone details for all sites on Bench."""
try: try:
@ -547,7 +547,7 @@ class Bench(Document):
) )
frappe.db.rollback() frappe.db.rollback()
@frappe.whitelist() @jingrow.whitelist()
def sync_analytics(self): def sync_analytics(self):
agent = Agent(self.server) agent = Agent(self.server)
if agent.should_skip_requests(): if agent.should_skip_requests():
@ -633,19 +633,19 @@ class Bench(Document):
traceback.print_exc() traceback.print_exc()
frappe.db.rollback() frappe.db.rollback()
@frappe.whitelist() @jingrow.whitelist()
def add_ssh_user(self): def add_ssh_user(self):
proxy_server = frappe.db.get_value("Server", self.server, "proxy_server") proxy_server = frappe.db.get_value("Server", self.server, "proxy_server")
agent = Agent(proxy_server, server_type="Proxy Server") agent = Agent(proxy_server, server_type="Proxy Server")
agent.add_ssh_user(self) agent.add_ssh_user(self)
@frappe.whitelist() @jingrow.whitelist()
def remove_ssh_user(self): def remove_ssh_user(self):
proxy_server = frappe.db.get_value("Server", self.server, "proxy_server") proxy_server = frappe.db.get_value("Server", self.server, "proxy_server")
agent = Agent(proxy_server, server_type="Proxy Server") agent = Agent(proxy_server, server_type="Proxy Server")
agent.remove_ssh_user(self) agent.remove_ssh_user(self)
@frappe.whitelist() @jingrow.whitelist()
def generate_nginx_config(self): def generate_nginx_config(self):
agent = Agent(self.server) agent = Agent(self.server)
agent.update_bench_config(self) agent.update_bench_config(self)
@ -687,7 +687,7 @@ class Bench(Document):
def get_server_log_for_log_browser(self, log): def get_server_log_for_log_browser(self, log):
return Agent(self.server).get(f"benches/{self.name}/logs_v2/{log}") return Agent(self.server).get(f"benches/{self.name}/logs_v2/{log}")
@frappe.whitelist() @jingrow.whitelist()
def move_sites(self, server: str): def move_sites(self, server: str):
try: try:
destination_bench = frappe.get_last_pg( destination_bench = frappe.get_last_pg(
@ -712,7 +712,7 @@ class Bench(Document):
} }
).insert() ).insert()
@frappe.whitelist() @jingrow.whitelist()
def retry_bench(self): def retry_bench(self):
if frappe.get_value("Deploy Candidate Build", self.build, "status") != "Success": if frappe.get_value("Deploy Candidate Build", self.build, "status") != "Success":
frappe.throw(f"Deploy Candidate Build {self.build} is not Active") frappe.throw(f"Deploy Candidate Build {self.build} is not Active")

2
press/press/doctype/bench_shell/bench_shell.py
View File

@ -52,7 +52,7 @@ class BenchShell(Document):
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def run_command(pg): def run_command(pg):
bench_shell: "BenchShell" = frappe.get_pg(json.loads(pg)) bench_shell: "BenchShell" = frappe.get_pg(json.loads(pg))
bench_shell.run_command() bench_shell.run_command()

2
press/press/doctype/build_cache_shell/build_cache_shell.py
View File

@ -46,7 +46,7 @@ class BuildCacheShell(Document):
) )
@frappe.whitelist() @jingrow.whitelist()
def run_command(pg): def run_command(pg):
bench_shell: "BuildCacheShell" = frappe.get_pg(json.loads(pg)) bench_shell: "BuildCacheShell" = frappe.get_pg(json.loads(pg))
bench_shell.run_command() bench_shell.run_command()

2
press/press/doctype/build_metric/build_metric.py
View File

@ -56,7 +56,7 @@ class BuildMetric(Document):
) )
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def get_metrics(self): def get_metrics(self):
"""Retrigger metrics""" """Retrigger metrics"""
frappe.enqueue(self._get_metrics) frappe.enqueue(self._get_metrics)

8
press/press/doctype/cluster/cluster.py
View File

@ -223,7 +223,7 @@ class Cluster(Document):
for machine in machines: for machine in machines:
frappe.delete_pg("Virtual Machine", machine) frappe.delete_pg("Virtual Machine", machine)
@frappe.whitelist() @jingrow.whitelist()
def add_images(self): def add_images(self):
if self.images_available == 1: if self.images_available == 1:
frappe.throw("Images are already available", frappe.ValidationError) frappe.throw("Images are already available", frappe.ValidationError)
@ -737,7 +737,7 @@ class Cluster(Document):
frappe.db.commit() frappe.db.commit()
yield from copies yield from copies
@frappe.whitelist() @jingrow.whitelist()
def create_proxy(self): def create_proxy(self):
"""Creates a proxy server for the cluster""" """Creates a proxy server for the cluster"""
if self.get_same_region_vmis(get_series=True).count("n") < 1: if self.get_same_region_vmis(get_series=True).count("n") < 1:
@ -750,7 +750,7 @@ class Cluster(Document):
self.create_server("Proxy Server", DEFAULT_SERVER_TITLE) self.create_server("Proxy Server", DEFAULT_SERVER_TITLE)
@frappe.whitelist() @jingrow.whitelist()
def create_servers(self): def create_servers(self):
"""Creates servers for the cluster""" """Creates servers for the cluster"""
if self.images_available < 1: if self.images_available < 1:
@ -805,7 +805,7 @@ class Cluster(Document):
""" """
return True return True
@frappe.whitelist() @jingrow.whitelist()
def check_machine_availability(self, machine_type: str) -> bool: def check_machine_availability(self, machine_type: str) -> bool:
"Check availability of machine in the region before allowing provision" "Check availability of machine in the region before allowing provision"
if self.cloud_provider == "AWS EC2": if self.cloud_provider == "AWS EC2":

8
press/press/doctype/code_server/code_server.py
View File

@ -55,7 +55,7 @@ class CodeServer(Document):
def after_insert(self): def after_insert(self):
self.setup() self.setup()
@frappe.whitelist() @jingrow.whitelist()
def setup(self): def setup(self):
try: try:
create_dns_record(pg=self, record_name=self.name) create_dns_record(pg=self, record_name=self.name)
@ -69,7 +69,7 @@ class CodeServer(Document):
except Exception as e: except Exception as e:
log_error(title="Setup Code Server Failed", data=e) log_error(title="Setup Code Server Failed", data=e)
@frappe.whitelist() @jingrow.whitelist()
def stop(self): def stop(self):
try: try:
self.status = "Pending" self.status = "Pending"
@ -78,7 +78,7 @@ class CodeServer(Document):
except Exception as e: except Exception as e:
log_error(title="Stop Code Server Failed", data=e) log_error(title="Stop Code Server Failed", data=e)
@frappe.whitelist() @jingrow.whitelist()
def start(self): def start(self):
try: try:
self.status = "Pending" self.status = "Pending"
@ -89,7 +89,7 @@ class CodeServer(Document):
except Exception as e: except Exception as e:
log_error(title="Start Code Server Failed", data=e) log_error(title="Start Code Server Failed", data=e)
@frappe.whitelist() @jingrow.whitelist()
def archive(self): def archive(self):
try: try:
self.status = "Pending" self.status = "Pending"

54
press/press/doctype/database_server/database_server.py
View File

@ -470,7 +470,7 @@ class DatabaseServer(BaseServer):
if restart: if restart:
self._restart_mariadb() self._restart_mariadb()
@frappe.whitelist() @jingrow.whitelist()
def restart_mariadb(self): def restart_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_restart_mariadb") frappe.enqueue_pg(self.doctype, self.name, "_restart_mariadb")
@ -488,7 +488,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure": if play.status == "Failure":
log_error("MariaDB Restart Error", server=self.name) log_error("MariaDB Restart Error", server=self.name)
@frappe.whitelist() @jingrow.whitelist()
def stop_mariadb(self): def stop_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_stop_mariadb", timeout=1800) frappe.enqueue_pg(self.doctype, self.name, "_stop_mariadb", timeout=1800)
@ -506,11 +506,11 @@ class DatabaseServer(BaseServer):
if play.status == "Failure": if play.status == "Failure":
log_error("MariaDB Stop Error", server=self.name) log_error("MariaDB Stop Error", server=self.name)
@frappe.whitelist() @jingrow.whitelist()
def run_upgrade_mariadb_job(self): def run_upgrade_mariadb_job(self):
self.run_press_job("Upgrade MariaDB") self.run_press_job("Upgrade MariaDB")
@frappe.whitelist() @jingrow.whitelist()
def upgrade_mariadb(self): def upgrade_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb", timeout=1800) frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb", timeout=1800)
@ -528,7 +528,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure": if play.status == "Failure":
log_error("MariaDB Upgrade Error", server=self.name) log_error("MariaDB Upgrade Error", server=self.name)
@frappe.whitelist() @jingrow.whitelist()
def update_mariadb(self): def update_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_update_mariadb", timeout=1800) frappe.enqueue_pg(self.doctype, self.name, "_update_mariadb", timeout=1800)
@ -546,7 +546,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure": if play.status == "Failure":
log_error("MariaDB Update Error", server=self.name) log_error("MariaDB Update Error", server=self.name)
@frappe.whitelist() @jingrow.whitelist()
def upgrade_mariadb_patched(self): def upgrade_mariadb_patched(self):
frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb_patched", timeout=1800) frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb_patched", timeout=1800)
@ -789,7 +789,7 @@ class DatabaseServer(BaseServer):
inventory = f"{self.ip}," inventory = f"{self.ip},"
return AnsibleAdHoc(sources=inventory).run(command, self.name)[0] return AnsibleAdHoc(sources=inventory).run(command, self.name)[0]
@frappe.whitelist() @jingrow.whitelist()
def setup_essentials(self): def setup_essentials(self):
"""Setup missing essentials after server setup""" """Setup missing essentials after server setup"""
config = self._get_config() config = self._get_config()
@ -942,7 +942,7 @@ class DatabaseServer(BaseServer):
if primary.status == "Active": if primary.status == "Active":
self._setup_secondary() self._setup_secondary()
@frappe.whitelist() @jingrow.whitelist()
def setup_replication(self): def setup_replication(self):
if self.is_primary: if self.is_primary:
return return
@ -950,7 +950,7 @@ class DatabaseServer(BaseServer):
self.save() self.save()
frappe.enqueue_pg(self.doctype, self.name, "_setup_replication", queue="long", timeout=18000) frappe.enqueue_pg(self.doctype, self.name, "_setup_replication", queue="long", timeout=18000)
@frappe.whitelist() @jingrow.whitelist()
def perform_physical_backup(self, path): def perform_physical_backup(self, path):
if not path: if not path:
frappe.throw("Provide a path to store the physical backup") frappe.throw("Provide a path to store the physical backup")
@ -1013,7 +1013,7 @@ class DatabaseServer(BaseServer):
server.database_server = self.name server.database_server = self.name
server.save() server.save()
@frappe.whitelist() @jingrow.whitelist()
def trigger_failover(self): def trigger_failover(self):
if self.is_primary: if self.is_primary:
return return
@ -1049,7 +1049,7 @@ class DatabaseServer(BaseServer):
log_error("Database Server Conversion Exception", server=self.as_dict()) log_error("Database Server Conversion Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def convert_from_frappe_server(self): def convert_from_frappe_server(self):
self.status = "Installing" self.status = "Installing"
self.save() self.save()
@ -1074,7 +1074,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("Exporters Install Exception", server=self.as_dict()) log_error("Exporters Install Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def reset_root_password(self): def reset_root_password(self):
if self.is_primary: if self.is_primary:
self.reset_root_password_primary() self.reset_root_password_primary()
@ -1106,7 +1106,7 @@ class DatabaseServer(BaseServer):
def get_replication_status(self): def get_replication_status(self):
return self.agent.get_replication_status(self) return self.agent.get_replication_status(self)
@frappe.whitelist() @jingrow.whitelist()
def sync_replication_config(self): def sync_replication_config(self):
data = self.get_replication_status() data = self.get_replication_status()
if not data.get("success"): if not data.get("success"):
@ -1239,7 +1239,7 @@ class DatabaseServer(BaseServer):
if not data.get("success"): if not data.get("success"):
frappe.throw(data.get("message", "Failed to stop replication")) frappe.throw(data.get("message", "Failed to stop replication"))
@frappe.whitelist() @jingrow.whitelist()
def setup_deadlock_logger(self): def setup_deadlock_logger(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_deadlock_logger", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_setup_deadlock_logger", queue="long", timeout=1200)
@ -1276,7 +1276,7 @@ class DatabaseServer(BaseServer):
log_error("Process List Capture Exception", server=self.as_dict()) log_error("Process List Capture Exception", server=self.as_dict())
return None return None
@frappe.whitelist() @jingrow.whitelist()
def setup_pt_stalk(self): def setup_pt_stalk(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_pt_stalk", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_setup_pt_stalk", queue="long", timeout=1200)
@ -1313,7 +1313,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("Percona Stalk Setup Exception", server=self.as_dict()) log_error("Percona Stalk Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_logrotate(self): def setup_logrotate(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_logrotate", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_setup_logrotate", queue="long", timeout=1200)
@ -1326,7 +1326,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("Logrotate Setup Exception", server=self.as_dict()) log_error("Logrotate Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def provide_frappe_user_du_and_find_permission(self): def provide_frappe_user_du_and_find_permission(self):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.name, "_provide_frappe_user_du_and_find_permission", queue="long", timeout=1200 self.doctype, self.name, "_provide_frappe_user_du_and_find_permission", queue="long", timeout=1200
@ -1344,7 +1344,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("MariaDB Provide Frappe User DU Permission Exception", server=self.as_dict()) log_error("MariaDB Provide Frappe User DU Permission Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_mariadb_debug_symbols(self): def setup_mariadb_debug_symbols(self):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.name, "_setup_mariadb_debug_symbols", queue="long", timeout=1200 self.doctype, self.name, "_setup_mariadb_debug_symbols", queue="long", timeout=1200
@ -1362,7 +1362,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("MariaDB Debug Symbols Setup Exception", server=self.as_dict()) log_error("MariaDB Debug Symbols Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def fetch_stalks(self): def fetch_stalks(self):
frappe.enqueue( frappe.enqueue(
"press.press.doctype.mariadb_stalk.mariadb_stalk.fetch_server_stalks", "press.press.doctype.mariadb_stalk.mariadb_stalk.fetch_server_stalks",
@ -1508,7 +1508,7 @@ class DatabaseServer(BaseServer):
int(self.ram_for_mariadb * 0.65), int(self.ram_for_mariadb * 0.65),
) )
@frappe.whitelist() @jingrow.whitelist()
def adjust_memory_config(self): # noqa: C901 def adjust_memory_config(self): # noqa: C901
if not self.ram: if not self.ram:
return return
@ -1570,7 +1570,7 @@ class DatabaseServer(BaseServer):
"innodb_force_recovery", "value_str", str(value), skip=False, persist=True, save=True "innodb_force_recovery", "value_str", str(value), skip=False, persist=True, save=True
) )
@frappe.whitelist() @jingrow.whitelist()
def toggle_read_only_mode(self): def toggle_read_only_mode(self):
read_only_mode_value = self.get_mariadb_variable_value("read_only", return_default_if_not_found=True) read_only_mode_value = self.get_mariadb_variable_value("read_only", return_default_if_not_found=True)
read_only_mode_enabled = read_only_mode_value in (1, "1", "ON") read_only_mode_enabled = read_only_mode_value in (1, "1", "ON")
@ -1580,7 +1580,7 @@ class DatabaseServer(BaseServer):
else: else:
self.enable_read_only_mode() self.enable_read_only_mode()
@frappe.whitelist() @jingrow.whitelist()
def enable_read_only_mode(self, update_variables_synchronously: bool = False): def enable_read_only_mode(self, update_variables_synchronously: bool = False):
"""Enable read-only mode for the database server""" """Enable read-only mode for the database server"""
self.add_or_update_mariadb_variable( self.add_or_update_mariadb_variable(
@ -1593,7 +1593,7 @@ class DatabaseServer(BaseServer):
update_variables_synchronously=update_variables_synchronously, update_variables_synchronously=update_variables_synchronously,
) )
@frappe.whitelist() @jingrow.whitelist()
def disable_read_only_mode(self, update_variables_synchronously: bool = False): def disable_read_only_mode(self, update_variables_synchronously: bool = False):
"""Disable read-only mode for the database server""" """Disable read-only mode for the database server"""
self.add_or_update_mariadb_variable( self.add_or_update_mariadb_variable(
@ -1606,7 +1606,7 @@ class DatabaseServer(BaseServer):
update_variables_synchronously=update_variables_synchronously, update_variables_synchronously=update_variables_synchronously,
) )
@frappe.whitelist() @jingrow.whitelist()
def reconfigure_mariadb_exporter(self): def reconfigure_mariadb_exporter(self):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.name, "_reconfigure_mariadb_exporter", queue="long", timeout=1200 self.doctype, self.name, "_reconfigure_mariadb_exporter", queue="long", timeout=1200
@ -1629,7 +1629,7 @@ class DatabaseServer(BaseServer):
except Exception: except Exception:
log_error("Database Server MariaDB Exporter Reconfigure Exception", server=self.as_dict()) log_error("Database Server MariaDB Exporter Reconfigure Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def update_memory_allocator(self, memory_allocator): def update_memory_allocator(self, memory_allocator):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.doctype,
@ -1703,7 +1703,7 @@ class DatabaseServer(BaseServer):
binlogs = sorted(binlogs, key=lambda x: x["modified_at"], reverse=True) binlogs = sorted(binlogs, key=lambda x: x["modified_at"], reverse=True)
return [binlog for binlog in binlogs if binlog.get("name") != current_binlog] return [binlog for binlog in binlogs if binlog.get("name") != current_binlog]
@frappe.whitelist() @jingrow.whitelist()
def get_binlog_summary(self): def get_binlog_summary(self):
binlogs_in_disk = self.get_binlogs_raw_data().get("binlogs_in_disk", []) binlogs_in_disk = self.get_binlogs_raw_data().get("binlogs_in_disk", [])
no_of_binlogs = len(binlogs_in_disk) no_of_binlogs = len(binlogs_in_disk)
@ -2237,7 +2237,7 @@ Latest binlog : {latest_binlog.get("name", "")} - {last_binlog_size_mb} MB {last
except Exception: except Exception:
log_error("Set MariaDB Mount Dependency Exception", server=self.as_dict()) log_error("Set MariaDB Mount Dependency Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def update_database_schema_sizes(self): def update_database_schema_sizes(self):
self.agent.update_database_schema_sizes() self.agent.update_database_schema_sizes()

8
press/press/doctype/deploy_candidate/deploy_candidate.py
View File

@ -216,7 +216,7 @@ class DeployCandidate(Document):
) )
return frappe.get_pg(kwargs) return frappe.get_pg(kwargs)
@frappe.whitelist() @jingrow.whitelist()
def build( def build(
self, self,
no_push: bool = False, no_push: bool = False,
@ -234,7 +234,7 @@ class DeployCandidate(Document):
deploy_candidate_build.insert() deploy_candidate_build.insert()
return dict(error=False, message=deploy_candidate_build.name) return dict(error=False, message=deploy_candidate_build.name)
@frappe.whitelist() @jingrow.whitelist()
def schedule_build_and_deploy( def schedule_build_and_deploy(
self, self,
run_now: bool = True, run_now: bool = True,
@ -659,7 +659,7 @@ def ansi_escape(text):
return ansi_escape.sub("", text) return ansi_escape.sub("", text)
@frappe.whitelist() @jingrow.whitelist()
def desk_app(doctype, txt, searchfield, start, page_len, filters): def desk_app(doctype, txt, searchfield, start, page_len, filters):
return frappe.get_all( return frappe.get_all(
"Release Group App", "Release Group App",
@ -672,7 +672,7 @@ def desk_app(doctype, txt, searchfield, start, page_len, filters):
get_permission_query_conditions = get_permission_query_conditions_for_doctype("Deploy Candidate") get_permission_query_conditions = get_permission_query_conditions_for_doctype("Deploy Candidate")
@frappe.whitelist() @jingrow.whitelist()
def toggle_builds(suspend): def toggle_builds(suspend):
frappe.only_for("System Manager") frappe.only_for("System Manager")
frappe.db.set_single_value("Press Settings", "suspend_builds", suspend) frappe.db.set_single_value("Press Settings", "suspend_builds", suspend)

14
press/press/doctype/deploy_candidate_build/deploy_candidate_build.py
View File

@ -1238,7 +1238,7 @@ class DeployCandidateBuild(Document):
} }
).insert() ).insert()
@frappe.whitelist() @jingrow.whitelist()
def deploy(self): def deploy(self):
try: try:
return dict( return dict(
@ -1247,7 +1247,7 @@ class DeployCandidateBuild(Document):
except Exception: except Exception:
log_error("Deploy Creation Error", pg=self) log_error("Deploy Creation Error", pg=self)
@frappe.whitelist() @jingrow.whitelist()
def redeploy(self, no_cache: bool = False): def redeploy(self, no_cache: bool = False):
deploy_candidate: DeployCandidate | None = self.candidate.get_duplicate_dc() deploy_candidate: DeployCandidate | None = self.candidate.get_duplicate_dc()
if not deploy_candidate: if not deploy_candidate:
@ -1256,7 +1256,7 @@ class DeployCandidateBuild(Document):
deploy_candidate_build_name = deploy_candidate.build_and_deploy(no_cache=no_cache) deploy_candidate_build_name = deploy_candidate.build_and_deploy(no_cache=no_cache)
return dict(error=False, message=deploy_candidate_build_name) return dict(error=False, message=deploy_candidate_build_name)
@frappe.whitelist() @jingrow.whitelist()
def cleanup_build_directory(self): def cleanup_build_directory(self):
if not self.build_directory: if not self.build_directory:
return return
@ -1268,7 +1268,7 @@ class DeployCandidateBuild(Document):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def stop_and_fail(dn: str): def stop_and_fail(dn: str):
# We can avoid lock here in testing it did not raise a timestamp mismatch error. # We can avoid lock here in testing it did not raise a timestamp mismatch error.
build: DeployCandidateBuild = frappe.get_pg("Deploy Candidate Build", dn) build: DeployCandidateBuild = frappe.get_pg("Deploy Candidate Build", dn)
@ -1276,7 +1276,7 @@ def stop_and_fail(dn: str):
build._stop_and_fail() build._stop_and_fail()
@frappe.whitelist() @jingrow.whitelist()
def fail_and_redeploy(dn: str): def fail_and_redeploy(dn: str):
stop_and_fail(dn) stop_and_fail(dn)
@ -1285,7 +1285,7 @@ def fail_and_redeploy(dn: str):
return build.redeploy() return build.redeploy()
@frappe.whitelist() @jingrow.whitelist()
def redeploy(dn: str) -> dict[str, str | bool]: def redeploy(dn: str) -> dict[str, str | bool]:
"""Allow redeploy preserving app sources if the deploy is in terminal stage""" """Allow redeploy preserving app sources if the deploy is in terminal stage"""
deploy_candidate_build: DeployCandidateBuild = frappe.get_pg("Deploy Candidate Build", dn) deploy_candidate_build: DeployCandidateBuild = frappe.get_pg("Deploy Candidate Build", dn)
@ -1299,7 +1299,7 @@ def redeploy(dn: str) -> dict[str, str | bool]:
return deploy_candidate_build.redeploy() return deploy_candidate_build.redeploy()
@frappe.whitelist() @jingrow.whitelist()
def fail_remote_job(dn: str) -> bool: def fail_remote_job(dn: str) -> bool:
agent_job: "AgentJob" = frappe.get_pg( agent_job: "AgentJob" = frappe.get_pg(
"Agent Job", {"reference_doctype": "Deploy Candidate Build", "reference_name": dn} "Agent Job", {"reference_doctype": "Deploy Candidate Build", "reference_name": dn}

2
press/press/doctype/downtime_analysis/downtime_analysis.py
View File

@ -35,7 +35,7 @@ class DowntimeAnalysis(Document):
def load_from_db(self): def load_from_db(self):
frappe.only_for("Desk User") frappe.only_for("Desk User")
@frappe.whitelist() @jingrow.whitelist()
def fetch_report(self): def fetch_report(self):
frappe.only_for("Desk User") frappe.only_for("Desk User")
if not (self.start_date and self.end_date): if not (self.start_date and self.end_date):

4
press/press/doctype/drip_email/drip_email.py
View File

@ -218,7 +218,7 @@ class DripEmail(Document):
frappe.db.rollback() frappe.db.rollback()
log_error("Drip Email Error", drip_email=self.name, site=site) log_error("Drip Email Error", drip_email=self.name, site=site)
@frappe.whitelist() @jingrow.whitelist()
def send_test_email(self, site: str, email: str): def send_test_email(self, site: str, email: str):
"""Send test email to the given email address.""" """Send test email to the given email address."""
self.send_drip_email(site, email) self.send_drip_email(site, email)
@ -267,7 +267,7 @@ def send_welcome_email():
welcome_email.send(site) welcome_email.send(site)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60) @rate_limit(limit=5, seconds=60 * 60)
def unsubscribe(email: str, account_request: str) -> None: def unsubscribe(email: str, account_request: str) -> None:
""" """

10
press/press/doctype/incident/incident.py
View File

@ -216,7 +216,7 @@ class Incident(WebsiteGenerator):
self.take_grafana_screenshots() self.take_grafana_screenshots()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def regather_info_and_screenshots(self): def regather_info_and_screenshots(self):
self.identify_affected_resource() self.identify_affected_resource()
self.identify_problem() self.identify_problem()
@ -392,7 +392,7 @@ class Incident(WebsiteGenerator):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def reboot_database_server(self): def reboot_database_server(self):
db_server_name = frappe.db.get_value("Server", self.server, "database_server") db_server_name = frappe.db.get_value("Server", self.server, "database_server")
if not db_server_name: if not db_server_name:
@ -405,7 +405,7 @@ class Incident(WebsiteGenerator):
self.add_likely_cause("Rebooted database server.") self.add_likely_cause("Rebooted database server.")
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def cancel_stuck_jobs(self): def cancel_stuck_jobs(self):
""" """
During db reboot/upgrade some jobs tend to get stuck. This is a hack to cancel those jobs During db reboot/upgrade some jobs tend to get stuck. This is a hack to cancel those jobs
@ -432,7 +432,7 @@ class Incident(WebsiteGenerator):
def add_likely_cause(self, cause: str): def add_likely_cause(self, cause: str):
self.likely_cause = self.likely_cause + cause + "\n" if self.likely_cause else cause + "\n" self.likely_cause = self.likely_cause + cause + "\n" if self.likely_cause else cause + "\n"
@frappe.whitelist() @jingrow.whitelist()
def restart_down_benches(self): def restart_down_benches(self):
""" """
Restart all benches on the server that are down Restart all benches on the server that are down
@ -791,7 +791,7 @@ Likely due to insufficient balance or incorrect credentials""",
def sites_down(self) -> list[str]: def sites_down(self) -> list[str]:
return self.monitor_server.get_sites_down_for_server(str(self.server)) return self.monitor_server.get_sites_down_for_server(str(self.server))
@frappe.whitelist() @jingrow.whitelist()
def get_down_site(self): def get_down_site(self):
return self.sites_down[0] if self.sites_down else None return self.sites_down[0] if self.sites_down else None

2
press/press/doctype/inspect_trace_id/inspect_trace_id.py
View File

@ -27,7 +27,7 @@ class InspectTraceID(Document):
def load_from_db(self): def load_from_db(self):
frappe.only_for("Desk User") frappe.only_for("Desk User")
@frappe.whitelist() @jingrow.whitelist()
def fetch(self): def fetch(self):
frappe.only_for("Desk User") frappe.only_for("Desk User")

16
press/press/doctype/invoice/invoice.py
View File

@ -249,7 +249,7 @@ class Invoice(Document):
self.calculate_amount_due() self.calculate_amount_due()
self.apply_taxes_if_applicable() self.apply_taxes_if_applicable()
@frappe.whitelist() @jingrow.whitelist()
def finalize_invoice(self): # noqa: C901 def finalize_invoice(self): # noqa: C901
if self.type == "Prepaid Credits": if self.type == "Prepaid Credits":
return return
@ -501,7 +501,7 @@ class Invoice(Document):
period_string = f"{start.strftime('%b %d')} - {end.strftime('%b %d')} {end.year}" period_string = f"{start.strftime('%b %d')} - {end.strftime('%b %d')} {end.year}"
return f"Frappe Cloud Subscription ({period_string})" return f"Frappe Cloud Subscription ({period_string})"
@frappe.whitelist() @jingrow.whitelist()
def finalize_stripe_invoice(self): def finalize_stripe_invoice(self):
stripe = get_stripe() stripe = get_stripe()
stripe.Invoice.finalize_invoice(self.stripe_invoice_id) stripe.Invoice.finalize_invoice(self.stripe_invoice_id)
@ -831,7 +831,7 @@ class Invoice(Document):
f"/api/method/frappe.utils.print_format.download_pdf?doctype=Invoice&name={self.name}&format={print_format}&no_letterhead=0" f"/api/method/frappe.utils.print_format.download_pdf?doctype=Invoice&name={self.name}&format={print_format}&no_letterhead=0"
) )
@frappe.whitelist() @jingrow.whitelist()
def create_invoice_on_frappeio(self): # noqa: C901 def create_invoice_on_frappeio(self): # noqa: C901
if self.flags.skip_frappe_invoice: if self.flags.skip_frappe_invoice:
return None return None
@ -894,7 +894,7 @@ class Invoice(Document):
data={"invoice": self.name, "traceback": traceback}, data={"invoice": self.name, "traceback": traceback},
) )
@frappe.whitelist() @jingrow.whitelist()
def fetch_invoice_pdf(self): def fetch_invoice_pdf(self):
if self.frappe_invoice: if self.frappe_invoice:
from urllib.parse import urlencode from urllib.parse import urlencode
@ -993,7 +993,7 @@ class Invoice(Document):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def fetch_mpesa_invoice_pdf(self): def fetch_mpesa_invoice_pdf(self):
if not (self.mpesa_payment_record and self.mpesa_invoice): if not (self.mpesa_payment_record and self.mpesa_invoice):
return return
@ -1034,7 +1034,7 @@ class Invoice(Document):
except Exception as e: except Exception as e:
frappe.log_error(str(e), "Error fetching Sales Invoice PDF on external site") frappe.log_error(str(e), "Error fetching Sales Invoice PDF on external site")
@frappe.whitelist() @jingrow.whitelist()
def refund(self, reason): def refund(self, reason):
stripe = get_stripe() stripe = get_stripe()
charge = None charge = None
@ -1054,7 +1054,7 @@ class Invoice(Document):
self.save() self.save()
self.add_comment(text=f"Refund reason: {reason}") self.add_comment(text=f"Refund reason: {reason}")
@frappe.whitelist() @jingrow.whitelist()
def change_stripe_invoice_status(self, status): def change_stripe_invoice_status(self, status):
stripe = get_stripe() stripe = get_stripe()
if status == "Paid": if status == "Paid":
@ -1064,7 +1064,7 @@ class Invoice(Document):
elif status == "Void": elif status == "Void":
stripe.Invoice.void_invoice(self.stripe_invoice_id) stripe.Invoice.void_invoice(self.stripe_invoice_id)
@frappe.whitelist() @jingrow.whitelist()
def refresh_stripe_payment_link(self): def refresh_stripe_payment_link(self):
stripe = get_stripe() stripe = get_stripe()
stripe_invoice = stripe.Invoice.retrieve(self.stripe_invoice_id) stripe_invoice = stripe.Invoice.retrieve(self.stripe_invoice_id)

4
press/press/doctype/log_server/log_server.py
View File

@ -96,11 +96,11 @@ class LogServer(BaseServer):
log_error("Log Server Setup Exception", server=self.as_dict()) log_error("Log Server Setup Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def show_kibana_password(self): def show_kibana_password(self):
return self.get_password("kibana_password") return self.get_password("kibana_password")
@frappe.whitelist() @jingrow.whitelist()
def install_elasticsearch_exporter(self): def install_elasticsearch_exporter(self):
frappe.enqueue_pg( frappe.enqueue_pg(
self.doctype, self.doctype,

12
press/press/doctype/logical_replication_backup/logical_replication_backup.py
View File

@ -980,7 +980,7 @@ class LogicalReplicationBackup(Document):
process_callback_from_logical_replication_backup(self) process_callback_from_logical_replication_backup(self)
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
if self.stage_status == "Running": if self.stage_status == "Running":
frappe.msgprint("Replication is already in Running state. It will be executed soon.") frappe.msgprint("Replication is already in Running state. It will be executed soon.")
@ -1011,7 +1011,7 @@ class LogicalReplicationBackup(Document):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self) -> None: def next(self) -> None:
if self.stage_status != "Running" and self.stage_status not in ("Success", "Failure"): if self.stage_status != "Running" and self.stage_status not in ("Success", "Failure"):
self.stage_status = "Running" self.stage_status = "Running"
@ -1043,7 +1043,7 @@ class LogicalReplicationBackup(Document):
timeout=600, timeout=600,
) )
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def retry(self): def retry(self):
# Reset the states # Reset the states
self.stage_status = "Pending" self.stage_status = "Pending"
@ -1055,7 +1055,7 @@ class LogicalReplicationBackup(Document):
step.status = "Pending" step.status = "Pending"
self.save(ignore_version=True) self.save(ignore_version=True)
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self) -> None: def force_continue(self) -> None:
# Mark all failed and skipped steps as pending # Mark all failed and skipped steps as pending
for step in self.current_execution_steps: for step in self.current_execution_steps:
@ -1067,7 +1067,7 @@ class LogicalReplicationBackup(Document):
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self) -> None: def force_fail(self) -> None:
# Mark all pending steps as failure # Mark all pending steps as failure
for step in self.current_execution_steps: for step in self.current_execution_steps:
@ -1105,7 +1105,7 @@ class LogicalReplicationBackup(Document):
def is_restoration_steps_successful(self) -> bool: def is_restoration_steps_successful(self) -> bool:
return all(step.status == "Success" for step in self.current_execution_steps) return all(step.status == "Success" for step in self.current_execution_steps)
@frappe.whitelist() @jingrow.whitelist()
def execute_step(self, step_name): def execute_step(self, step_name):
step = self.get_step(step_name) step = self.get_step(step_name)

2
press/press/doctype/malware_scan/malware_scan.py
View File

@ -57,7 +57,7 @@ class MalwareScan(Document):
self.status = "Failure" self.status = "Failure"
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def start(self): def start(self):
self.status = "Pending" self.status = "Pending"
self.save() self.save()

2
press/press/doctype/managed_database_service/managed_database_service.py
View File

@ -25,7 +25,7 @@ class ManagedDatabaseService(Document):
pass pass
@frappe.whitelist() @jingrow.whitelist()
def show_root_password(self): def show_root_password(self):
frappe.only_for("System Manager") frappe.only_for("System Manager")
return self.get_password("root_user_password") return self.get_password("root_user_password")

2
press/press/doctype/mariadb_binlog/mariadb_binlog.py
View File

@ -48,7 +48,7 @@ class MariaDBBinlog(Document):
self.save() self.save()
frappe.delete_pg("Remote File", remote_file) frappe.delete_pg("Remote File", remote_file)
@frappe.whitelist() @jingrow.whitelist()
def download_binlog(self): def download_binlog(self):
frappe.enqueue_pg( frappe.enqueue_pg(
"MariaDB Binlog", "MariaDB Binlog",

2
press/press/doctype/mariadb_variable/mariadb_variable.py
View File

@ -40,7 +40,7 @@ class MariaDBVariable(Document):
return float(value) return float(value)
return value return value
@frappe.whitelist() @jingrow.whitelist()
def set_on_all_servers(self): def set_on_all_servers(self):
value = self.get_default_value() value = self.get_default_value()
servers = frappe.get_all( servers = frappe.get_all(

4
press/press/doctype/monitor_server/monitor_server.py
View File

@ -173,7 +173,7 @@ class MonitorServer(BaseServer):
log_error("Monitor Server Setup Exception", server=self.as_dict()) log_error("Monitor Server Setup Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def reconfigure_monitor_server(self): def reconfigure_monitor_server(self):
frappe.enqueue_pg(self.doctype, self.name, "_reconfigure_monitor_server", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_reconfigure_monitor_server", queue="long", timeout=1200)
@ -235,7 +235,7 @@ class MonitorServer(BaseServer):
except Exception: except Exception:
log_error("Monitoring Server Setup Exception", server=self.as_dict()) log_error("Monitoring Server Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def show_grafana_password(self): def show_grafana_password(self):
return self.get_password("grafana_password") return self.get_password("grafana_password")

4
press/press/doctype/nfs_server/nfs_server.py
View File

@ -89,7 +89,7 @@ class NFSServer(BaseServer):
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def add_mount_enabled_server( def add_mount_enabled_server(
self, self,
server: str, server: str,
@ -106,7 +106,7 @@ class NFSServer(BaseServer):
) )
return nfs_volume_attachment.insert() return nfs_volume_attachment.insert()
@frappe.whitelist() @jingrow.whitelist()
def remove_mount_enabled_server(self, server: str) -> NFSVolumeDetachment: def remove_mount_enabled_server(self, server: str) -> NFSVolumeDetachment:
secondary_server = frappe.get_value("Server", server, "secondary_server") secondary_server = frappe.get_value("Server", server, "secondary_server")
nfs_volume_detachment: NFSVolumeDetachment = frappe.get_pg( nfs_volume_detachment: NFSVolumeDetachment = frappe.get_pg(

2
press/press/doctype/nfs_volume_attachment/nfs_volume_attachment.py
View File

@ -439,7 +439,7 @@ class NFSVolumeAttachment(Document, AutoScaleStepFailureHandler, StepHandler):
self.secondary_server = frappe.db.get_value("Server", self.primary_server, "secondary_server") self.secondary_server = frappe.db.get_value("Server", self.primary_server, "secondary_server")
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self): def force_continue(self):
self.execute_mount_steps() self.execute_mount_steps()

2
press/press/doctype/nfs_volume_detachment/nfs_volume_detachment.py
View File

@ -332,7 +332,7 @@ class NFSVolumeDetachment(Document, AutoScaleStepFailureHandler, StepHandler):
if is_server_auto_scaled: if is_server_auto_scaled:
frappe.throw("Benches are currently running on the secondary server!") frappe.throw("Benches are currently running on the secondary server!")
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self): def force_continue(self):
self.execute_mount_steps() self.execute_mount_steps()

2
press/press/doctype/partner_payment_payout/partner_payment_payout.py
View File

@ -73,7 +73,7 @@ class PartnerPaymentPayout(Document):
frappe.db.commit() frappe.db.commit()
@frappe.whitelist() @jingrow.whitelist()
def submit_payment_payout(partner, payment_gateway, from_date, to_date, partner_commission, transactions): def submit_payment_payout(partner, payment_gateway, from_date, to_date, partner_commission, transactions):
partner = ( partner = (
partner if frappe.db.exists("Team", partner) else frappe.get_value("Team", {"user": partner}, "name") partner if frappe.db.exists("Team", partner) else frappe.get_value("Team", {"user": partner}, "name")

2
press/press/doctype/payout_order/payout_order.py
View File

@ -276,7 +276,7 @@ def get_unaccounted_marketplace_invoice_items():
return items return items
@frappe.whitelist() @jingrow.whitelist()
def create_payout_order_from_invoice_items( def create_payout_order_from_invoice_items(
invoice_items: List[InvoiceItem], invoice_items: List[InvoiceItem],
team: str, team: str,

14
press/press/doctype/physical_backup_group/physical_backup_group.py
View File

@ -45,7 +45,7 @@ class PhysicalBackupGroup(Document):
return site return site
return None return None
@frappe.whitelist() @jingrow.whitelist()
def sync(self): def sync(self):
self.no_of_sites = len(self.site_backups) self.no_of_sites = len(self.site_backups)
# Check site backup's status # Check site backup's status
@ -58,12 +58,12 @@ class PhysicalBackupGroup(Document):
) )
self.save(ignore_permissions=True) self.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def set_db_sizes(self): def set_db_sizes(self):
for site in self.site_backups: for site in self.site_backups:
site.set_db_size() site.set_db_size()
@frappe.whitelist() @jingrow.whitelist()
def trigger_next_backup(self): def trigger_next_backup(self):
frappe.enqueue_pg(self.doctype, self.name, "_trigger_next_backup", queue="default", at_front=True) frappe.enqueue_pg(self.doctype, self.name, "_trigger_next_backup", queue="default", at_front=True)
frappe.msgprint("Triggered next backup") frappe.msgprint("Triggered next backup")
@ -87,7 +87,7 @@ class PhysicalBackupGroup(Document):
enqueue_after_commit=True, enqueue_after_commit=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def retry_failed_backups(self): def retry_failed_backups(self):
for site in self.site_backups: for site in self.site_backups:
if site.status == "Failure": if site.status == "Failure":
@ -96,19 +96,19 @@ class PhysicalBackupGroup(Document):
site.status = "Pending" site.status = "Pending"
site.save(ignore_permissions=True) site.save(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def delete_backups(self): def delete_backups(self):
for site in self.site_backups: for site in self.site_backups:
site.delete_backup() site.delete_backup()
@frappe.whitelist() @jingrow.whitelist()
def activate_all_sites(self): def activate_all_sites(self):
for site_backup in self.site_backups: for site_backup in self.site_backups:
site = frappe.get_pg("Site", site_backup.site) site = frappe.get_pg("Site", site_backup.site)
agent = Agent(site.server) agent = Agent(site.server)
agent.activate_site(site) agent.activate_site(site)
@frappe.whitelist() @jingrow.whitelist()
def create_duplicate_group(self): def create_duplicate_group(self):
suffix = 2 suffix = 2
name = self.name + "-" + str(suffix) name = self.name + "-" + str(suffix)

14
press/press/doctype/physical_backup_restoration/physical_backup_restoration.py
View File

@ -607,7 +607,7 @@ class PhysicalBackupRestoration(Document):
step.update({"status": "Pending"}) step.update({"status": "Pending"})
self.append("steps", step) self.append("steps", step)
@frappe.whitelist() @jingrow.whitelist()
def execute(self): def execute(self):
if self.status == "Scheduled": if self.status == "Scheduled":
frappe.msgprint("Restoration is already in Scheduled state. It will be executed soon.") frappe.msgprint("Restoration is already in Scheduled state. It will be executed soon.")
@ -651,7 +651,7 @@ class PhysicalBackupRestoration(Document):
self.cleanup_completed = self.is_cleanup_steps_successful() self.cleanup_completed = self.is_cleanup_steps_successful()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self) -> None: def next(self) -> None:
if self.status != "Running" and self.status not in ("Success", "Failure"): if self.status != "Running" and self.status not in ("Success", "Failure"):
self.status = "Running" self.status = "Running"
@ -686,7 +686,7 @@ class PhysicalBackupRestoration(Document):
job_id=f"physical_restoration||{self.name}||{next_step_to_run.name}", job_id=f"physical_restoration||{self.name}||{next_step_to_run.name}",
) )
@frappe.whitelist() @jingrow.whitelist()
def cleanup(self): def cleanup(self):
is_cleanup_required = False is_cleanup_required = False
for step in self.steps: for step in self.steps:
@ -702,7 +702,7 @@ class PhysicalBackupRestoration(Document):
if is_cleanup_required: if is_cleanup_required:
self.next() self.next()
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def retry(self): def retry(self):
# Check if all the cleanup steps are completed # Check if all the cleanup steps are completed
for step in self.steps: for step in self.steps:
@ -722,7 +722,7 @@ class PhysicalBackupRestoration(Document):
step.status = "Pending" step.status = "Pending"
self.save(ignore_version=True) self.save(ignore_version=True)
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self) -> None: def force_continue(self) -> None:
first_failed_step: PhysicalBackupRestorationStep = None first_failed_step: PhysicalBackupRestorationStep = None
# Mark all failed and skipped steps as pending # Mark all failed and skipped steps as pending
@ -737,7 +737,7 @@ class PhysicalBackupRestoration(Document):
self.job = None self.job = None
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self) -> None: def force_fail(self) -> None:
# Mark all pending steps as failure # Mark all pending steps as failure
for step in self.steps: for step in self.steps:
@ -771,7 +771,7 @@ class PhysicalBackupRestoration(Document):
# Anything else means the cleanup steps are not completed # Anything else means the cleanup steps are not completed
return all(step.status in ("Skipped", "Success") for step in self.steps if step.is_cleanup_step) return all(step.status in ("Skipped", "Success") for step in self.steps if step.is_cleanup_step)
@frappe.whitelist() @jingrow.whitelist()
def execute_step(self, step_name): def execute_step(self, step_name):
step = self.get_step(step_name) step = self.get_step(step_name)

6
press/press/doctype/physical_restoration_test/physical_restoration_test.py
View File

@ -80,7 +80,7 @@ class PhysicalRestorationTest(Document):
} }
).insert(ignore_permissions=True) ).insert(ignore_permissions=True)
@frappe.whitelist() @jingrow.whitelist()
def start(self): def start(self):
self.sync() self.sync()
record = None record = None
@ -105,12 +105,12 @@ class PhysicalRestorationTest(Document):
self.save() self.save()
frappe.throw("No pending restoration found") frappe.throw("No pending restoration found")
@frappe.whitelist() @jingrow.whitelist()
def sync(self): def sync(self):
for result in self.results: for result in self.results:
result.save() result.save()
@frappe.whitelist() @jingrow.whitelist()
def reset_failed_restorations(self): def reset_failed_restorations(self):
for result in self.results: for result in self.results:
if result.status == "Failure": if result.status == "Failure":

8
press/press/doctype/press_job/press_job.py
View File

@ -99,7 +99,7 @@ class PressJob(Document):
self.duration = (self.end - self.start).total_seconds() self.duration = (self.end - self.start).total_seconds()
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def next(self, arguments=None): def next(self, arguments=None):
if arguments: if arguments:
old_arguments = json.loads(self.arguments) old_arguments = json.loads(self.arguments)
@ -115,7 +115,7 @@ class PressJob(Document):
frappe.enqueue_pg("Press Job Step", next_step, "execute", enqueue_after_commit=True) frappe.enqueue_pg("Press Job Step", next_step, "execute", enqueue_after_commit=True)
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self): def force_continue(self):
for step in frappe.get_all( for step in frappe.get_all(
"Press Job Step", "Press Job Step",
@ -125,7 +125,7 @@ class PressJob(Document):
frappe.db.set_value("Press Job Step", step, "status", "Pending") frappe.db.set_value("Press Job Step", step, "status", "Pending")
self.next() self.next()
@frappe.whitelist() @jingrow.whitelist()
def force_fail(self): def force_fail(self):
for step in frappe.get_all( for step in frappe.get_all(
"Press Job Step", "Press Job Step",
@ -172,7 +172,7 @@ class PressJob(Document):
"press_job_update", doctype=self.doctype, docname=self.name, message=self.detail() "press_job_update", doctype=self.doctype, docname=self.name, message=self.detail()
) )
@frappe.whitelist() @jingrow.whitelist()
def mark_callback_failure_issue_resolved(self): def mark_callback_failure_issue_resolved(self):
self.callback_failure_issue_resolved = True self.callback_failure_issue_resolved = True
self.save() self.save()

2
press/press/doctype/press_job_step/press_job_step.py
View File

@ -35,7 +35,7 @@ class PressJobStep(Document):
wait_until_true: DF.Check wait_until_true: DF.Check
# end: auto-generated types # end: auto-generated types
@frappe.whitelist() @jingrow.whitelist()
def execute(self): # noqa: C901 def execute(self): # noqa: C901
if not self.start: if not self.start:
self.start = frappe.utils.now_datetime() self.start = frappe.utils.now_datetime()

4
press/press/doctype/press_settings/press_settings.py
View File

@ -211,7 +211,7 @@ class PressSettings(Document):
if self.minimum_rebuild_memory < 2: if self.minimum_rebuild_memory < 2:
frappe.throw("Minimum rebuild memory needs to be 2 GB or more.") frappe.throw("Minimum rebuild memory needs to be 2 GB or more.")
@frappe.whitelist() @jingrow.whitelist()
def create_stripe_webhook(self): def create_stripe_webhook(self):
stripe = get_stripe() stripe = get_stripe()
url = frappe.utils.get_url( url = frappe.utils.get_url(
@ -237,7 +237,7 @@ class PressSettings(Document):
self.flags.ignore_mandatory = True self.flags.ignore_mandatory = True
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def get_github_app_manifest(self): def get_github_app_manifest(self):
if frappe.conf.developer_mode: if frappe.conf.developer_mode:
app_name = f"Frappe Cloud {frappe.generate_hash(length=6).upper()}" app_name = f"Frappe Cloud {frappe.generate_hash(length=6).upper()}"

4
press/press/doctype/proxy_failover/proxy_failover.py
View File

@ -85,7 +85,7 @@ class ProxyFailover(Document, StepHandler):
deduplicate=True, deduplicate=True,
) )
@frappe.whitelist() @jingrow.whitelist()
def route_requests_from_primary_to_secondary(self, step=None): def route_requests_from_primary_to_secondary(self, step=None):
"""Route all traffic from primary to secondary proxy server""" """Route all traffic from primary to secondary proxy server"""
@ -317,7 +317,7 @@ class ProxyFailover(Document, StepHandler):
self.error = frappe.get_traceback(with_context=True) self.error = frappe.get_traceback(with_context=True)
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def force_continue(self): def force_continue(self):
self.error = None self.error = None
self.save() self.save()

16
press/press/doctype/proxy_server/proxy_server.py
View File

@ -154,7 +154,7 @@ class ProxyServer(BaseServer):
except Exception: except Exception:
log_error("Exporters Install Exception", server=self.as_dict()) log_error("Exporters Install Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_ssh_proxy(self): def setup_ssh_proxy(self):
if not self.ssh_certificate_authority: if not self.ssh_certificate_authority:
frappe.throw("SSH Certificate Authority is required to setup SSH Proxy") frappe.throw("SSH Certificate Authority is required to setup SSH Proxy")
@ -190,7 +190,7 @@ class ProxyServer(BaseServer):
except Exception: except Exception:
log_error("SSH Proxy Setup Exception", server=self.as_dict()) log_error("SSH Proxy Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_fail2ban(self): def setup_fail2ban(self):
self.status = "Installing" self.status = "Installing"
self.save() self.save()
@ -212,7 +212,7 @@ class ProxyServer(BaseServer):
log_error("Fail2ban Setup Exception", server=self.as_dict()) log_error("Fail2ban Setup Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def setup_proxysql(self): def setup_proxysql(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql", queue="long", timeout=1200)
@ -246,7 +246,7 @@ class ProxyServer(BaseServer):
except Exception: except Exception:
log_error("ProxySQL Setup Exception", server=self.as_dict()) log_error("ProxySQL Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_replication(self): def setup_replication(self):
self.status = "Installing" self.status = "Installing"
self.save() self.save()
@ -303,7 +303,7 @@ class ProxyServer(BaseServer):
log_error("Secondary Proxy Server Setup Exception", server=self.as_dict()) log_error("Secondary Proxy Server Setup Exception", server=self.as_dict())
self.save() self.save()
@frappe.whitelist() @jingrow.whitelist()
def trigger_failover(self): def trigger_failover(self):
# TODO: should also be automatic based on monitoring/some kind of health check mechanism # TODO: should also be automatic based on monitoring/some kind of health check mechanism
if self.is_primary: if self.is_primary:
@ -319,7 +319,7 @@ class ProxyServer(BaseServer):
return f"Failover Reference: {frappe.get_desk_link(failover.doctype, failover.name)}" return f"Failover Reference: {frappe.get_desk_link(failover.doctype, failover.name)}"
@frappe.whitelist() @jingrow.whitelist()
def setup_proxysql_monitor(self): def setup_proxysql_monitor(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql_monitor", queue="long", timeout=1200) frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql_monitor", queue="long", timeout=1200)
@ -346,7 +346,7 @@ class ProxyServer(BaseServer):
except Exception: except Exception:
log_error("ProxySQL Monitor Setup Exception", server=self.as_dict()) log_error("ProxySQL Monitor Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def setup_wireguard(self): def setup_wireguard(self):
if not self.private_ip_interface_id: if not self.private_ip_interface_id:
play = frappe.get_last_pg("Ansible Play", {"play": "Ping Server", "server": self.name}) play = frappe.get_last_pg("Ansible Play", {"play": "Ping Server", "server": self.name})
@ -395,7 +395,7 @@ class ProxyServer(BaseServer):
except Exception: except Exception:
log_error("Wireguard Setup Exception", server=self.as_dict()) log_error("Wireguard Setup Exception", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def reload_wireguard(self): def reload_wireguard(self):
frappe.enqueue_pg("Proxy Server", self.name, "_reload_wireguard", queue="default", timeout=1200) frappe.enqueue_pg("Proxy Server", self.name, "_reload_wireguard", queue="default", timeout=1200)

2
press/press/doctype/razorpay_payment_record/razorpay_payment_record.py
View File

@ -134,7 +134,7 @@ class RazorpayPaymentRecord(Document):
invoice.update_razorpay_transaction_details(payment) invoice.update_razorpay_transaction_details(payment)
invoice.submit() invoice.submit()
@frappe.whitelist() @jingrow.whitelist()
def sync(self): def sync(self):
try: try:
client = get_razorpay_client() client = get_razorpay_client()

4
press/press/doctype/razorpay_webhook_log/razorpay_webhook_log.py
View File

@ -31,7 +31,7 @@ class RazorpayWebhookLog(Document):
payment_record.save(ignore_permissions=True) payment_record.save(ignore_permissions=True)
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def razorpay_authorized_payment_handler(): def razorpay_authorized_payment_handler():
client = get_razorpay_client() client = get_razorpay_client()
form_dict = frappe.local.form_dict form_dict = frappe.local.form_dict
@ -92,7 +92,7 @@ def razorpay_authorized_payment_handler():
raise Exception from e raise Exception from e
@frappe.whitelist(allow_guest=True) @jingrow.whitelist(allow_guest=True)
def razorpay_webhook_handler(): def razorpay_webhook_handler():
client = get_razorpay_client() client = get_razorpay_client()
current_user = frappe.session.user current_user = frappe.session.user

6
press/press/doctype/registry_server/registry_server.py
View File

@ -151,12 +151,12 @@ class RegistryServer(BaseServer):
except Exception: except Exception:
log_error("Mirror Registry Prune Failed", server=self.as_dict()) log_error("Mirror Registry Prune Failed", server=self.as_dict())
@frappe.whitelist() @jingrow.whitelist()
def show_registry_password(self): def show_registry_password(self):
"""Show registry password""" """Show registry password"""
frappe.msgprint(self.get_password("registry_password")) frappe.msgprint(self.get_password("registry_password"))
@frappe.whitelist() @jingrow.whitelist()
def create_registry_mirror( def create_registry_mirror(
self, self,
hostname: str, hostname: str,
@ -204,7 +204,7 @@ class RegistryServer(BaseServer):
except Exception as e: except Exception as e:
log_error("Error during mirror config rewrite", e) log_error("Error during mirror config rewrite", e)
@frappe.whitelist() @jingrow.whitelist()
def rewrite_config(self): def rewrite_config(self):
"""Rewrite mirror's config""" """Rewrite mirror's config"""
if not self.is_mirror: if not self.is_mirror:

14
press/press/doctype/release_group/release_group.py
View File

@ -605,7 +605,7 @@ class ReleaseGroup(Document, TagHelpers):
frappe.db.commit() # Safe password regardless frappe.db.commit() # Safe password regardless
return self.get_password("redis_password") return self.get_password("redis_password")
@frappe.whitelist() @jingrow.whitelist()
def create_duplicate_deploy_candidate(self): def create_duplicate_deploy_candidate(self):
return self.create_deploy_candidate([]) return self.create_deploy_candidate([])
@ -707,7 +707,7 @@ class ReleaseGroup(Document, TagHelpers):
"Please scale down all the server before deploying." "Please scale down all the server before deploying."
) )
@frappe.whitelist() @jingrow.whitelist()
def create_deploy_candidate( def create_deploy_candidate(
self, self,
apps_to_update=None, apps_to_update=None,
@ -847,7 +847,7 @@ class ReleaseGroup(Document, TagHelpers):
return sorted_apps return sorted_apps
@frappe.whitelist() @jingrow.whitelist()
def deploy_information(self): def deploy_information(self):
out = frappe._dict(update_available=False) out = frappe._dict(update_available=False)
last_deployed_bench = get_last_pg( last_deployed_bench = get_last_pg(
@ -1459,7 +1459,7 @@ class ReleaseGroup(Document, TagHelpers):
except frappe.DoesNotExistError: except frappe.DoesNotExistError:
return None return None
@frappe.whitelist() @jingrow.whitelist()
def add_server(self, server: str, deploy=False, force_new_build: bool = False): def add_server(self, server: str, deploy=False, force_new_build: bool = False):
""" """
Add a server to the release group in case last successful deploy candidate exists Add a server to the release group in case last successful deploy candidate exists
@ -1503,7 +1503,7 @@ class ReleaseGroup(Document, TagHelpers):
except ImageNotFoundInRegistry: except ImageNotFoundInRegistry:
return self.add_server(server=server, deploy=True, force_new_build=True) return self.add_server(server=server, deploy=True, force_new_build=True)
@frappe.whitelist() @jingrow.whitelist()
def change_server(self, server: str): def change_server(self, server: str):
""" """
Create latest candidate in given server and tries to move sites there. Create latest candidate in given server and tries to move sites there.
@ -1515,7 +1515,7 @@ class ReleaseGroup(Document, TagHelpers):
self.remove(self.servers[0]) self.remove(self.servers[0])
self.add_server(server, deploy=True) self.add_server(server, deploy=True)
@frappe.whitelist() @jingrow.whitelist()
def update_benches_config(self): def update_benches_config(self):
from press.press.doctype.bench.bench import Bench from press.press.doctype.bench.bench import Bench
@ -1562,7 +1562,7 @@ class ReleaseGroup(Document, TagHelpers):
app_source = self.get_app_source(app) app_source = self.get_app_source(app)
app_source.create_release(force=True) app_source.create_release(force=True)
@frappe.whitelist() @jingrow.whitelist()
def archive(self): def archive(self):
benches = frappe.get_all("Bench", filters={"group": self.name, "status": "Active"}, pluck="name") benches = frappe.get_all("Bench", filters={"group": self.name, "status": "Active"}, pluck="name")
for bench in benches: for bench in benches:

6
press/press/doctype/remote_file/remote_file.py
View File

@ -194,7 +194,7 @@ class RemoteFile(Document):
def download_link(self): def download_link(self):
return self.get_download_link() return self.get_download_link()
@frappe.whitelist() @jingrow.whitelist()
def exists(self): def exists(self):
self.db_set("status", "Available") self.db_set("status", "Available")
@ -210,7 +210,7 @@ class RemoteFile(Document):
self.db_set("status", "Unavailable") self.db_set("status", "Unavailable")
return False return False
@frappe.whitelist() @jingrow.whitelist()
def delete_remote_object(self): def delete_remote_object(self):
self.db_set("status", "Unavailable") self.db_set("status", "Unavailable")
return self.s3_client.delete_object( return self.s3_client.delete_object(
@ -221,7 +221,7 @@ class RemoteFile(Document):
def on_trash(self): def on_trash(self):
self.delete_remote_object() self.delete_remote_object()
@frappe.whitelist() @jingrow.whitelist()
def get_download_link(self): def get_download_link(self):
return self.url or self.s3_client.generate_presigned_url( return self.url or self.s3_client.generate_presigned_url(
"get_object", "get_object",

2
press/press/doctype/root_domain/root_domain.py
View File

@ -194,7 +194,7 @@ class RootDomain(Document):
ChangeBatch={"Changes": changes}, HostedZoneId=self.hosted_zone ChangeBatch={"Changes": changes}, HostedZoneId=self.hosted_zone
) )
@frappe.whitelist() @jingrow.whitelist()
def add_to_proxies(self): def add_to_proxies(self):
proxies = frappe.get_all("Proxy Server", {"status": "Active"}, pluck="name") proxies = frappe.get_all("Proxy Server", {"status": "Active"}, pluck="name")
for proxy_name in proxies: for proxy_name in proxies:

2
press/press/doctype/security_update_check/security_update_check.py
View File

@ -33,7 +33,7 @@ class SecurityUpdateCheck(Document):
def after_insert(self): def after_insert(self):
self.start() self.start()
@frappe.whitelist() @jingrow.whitelist()
def start(self): def start(self):
self.status = "Pending" self.status = "Pending"
self.save() self.save()

Some files were not shown because too many files have changed in this diff Show More