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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def script():
return get_minified_script()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def script_2():
return get_minified_script_2()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def handle_suspended_site_redirection():
from press.saas.doctype.product_trial_request.product_trial_request import (
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
@frappe.whitelist()
@jingrow.whitelist()
@caching.redis_cache(ttl=60, user=True)
@typing_validations.validate_argument_types
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
def signup(email: str, product: str | None = None, referrer: str | None = None) -> str:
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
def verify_otp(account_request: str, otp: str) -> str:
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
def verify_otp_and_login(email: str, otp: str):
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60)
def resend_otp(account_request: str, for_2fa_keys: bool = False):
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60)
def send_otp(email: str, for_2fa_keys: bool = False):
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def setup_account( # noqa: C901
key,
first_name=None,
@ -238,7 +238,7 @@ def setup_account( # noqa: C901
return account_request.name
@frappe.whitelist()
@jingrow.whitelist()
@rate_limit(limit=5, seconds=60 * 60)
def accept_team_invite(key: str):
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
def send_login_link(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)
def login_using_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():
team = get_current_team()
return frappe.get_all("Server", {"team": team, "status": "Active"}, ["title", "name"])
@frappe.whitelist()
@jingrow.whitelist()
def disable_account(totp_code: str | None):
user = frappe.session.user
team = get_current_team(get_pg=True)
@ -331,12 +331,12 @@ def disable_account(totp_code: str | None):
team.disable_account()
@frappe.whitelist()
@jingrow.whitelist()
def has_active_servers(team):
return frappe.db.exists("Server", {"status": "Active", "team": team})
@frappe.whitelist()
@jingrow.whitelist()
def enable_account():
team = get_current_team(get_pg=True)
if frappe.session.user != team.user:
@ -344,14 +344,14 @@ def enable_account():
team.enable_account()
@frappe.whitelist()
@jingrow.whitelist()
def request_team_deletion():
team = get_current_team(get_pg=True)
pg = frappe.get_pg({"doctype": "Team Deletion Request", "team": team.name}).insert()
return pg.name
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def delete_team(team):
from frappe.utils.verified_command import verify_request
@ -396,7 +396,7 @@ def delete_team(team):
return respond_as_web_page("confirmed")
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def validate_request_key(key, timezone=None):
from press.utils.country_timezone import get_country_from_timezone
@ -429,7 +429,7 @@ def validate_request_key(key, timezone=None):
return None
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def country_list():
def get_country_list():
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.whitelist()
@jingrow.whitelist()
def set_country(country):
team_pg = get_current_team(get_pg=True)
team_pg.country = country
@ -461,7 +461,7 @@ def get_account_request_from_key(key: str):
return None
@frappe.whitelist()
@jingrow.whitelist()
def get():
cached = frappe.cache.get_value("cached-account.get", user=frappe.session.user)
if cached:
@ -523,7 +523,7 @@ def _get():
}
@frappe.whitelist()
@jingrow.whitelist()
def current_team():
user = frappe.session.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}
@frappe.whitelist()
@jingrow.whitelist()
def has_method_permission(doctype, docname, method) -> bool:
from press.press.doctype.press_permission_group.press_permission_group import (
has_method_permission,
@ -560,7 +560,7 @@ def has_method_permission(doctype, docname, method) -> bool:
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):
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def guest_feature_flags():
return {
"enable_google_oauth": frappe.db.get_single_value("Press Settings", "enable_google_oauth"),
}
@frappe.whitelist()
@jingrow.whitelist()
def create_child_team(title):
team = title.strip()
@ -657,7 +657,7 @@ def get_ssh_key(user):
return None
@frappe.whitelist()
@jingrow.whitelist()
def update_profile(first_name=None, last_name=None, email=None):
if email:
frappe.utils.validate_email_address(email, True)
@ -673,7 +673,7 @@ def update_profile(first_name=None, last_name=None, email=None):
return pg
@frappe.whitelist()
@jingrow.whitelist()
def update_profile_picture():
user = frappe.session.user
_file = frappe.get_pg(
@ -692,7 +692,7 @@ def update_profile_picture():
frappe.db.set_value("User", user, "user_image", _file.file_url)
@frappe.whitelist()
@jingrow.whitelist()
def update_feature_flags(values=None):
frappe.only_for("Press Admin")
team = get_current_team(get_pg=True)
@ -709,7 +709,7 @@ def update_feature_flags(values=None):
team.save()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
@mfa.verify(user_key="email", raise_error=True)
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):
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)
def get_user_for_reset_password_key(key):
if not key or not isinstance(key, str):
@ -769,13 +769,13 @@ def get_user_for_reset_password_key(key):
return user_pg.name
@frappe.whitelist()
@jingrow.whitelist()
def remove_team_member(user_email):
team = get_current_team(True)
team.remove_team_member(user_email)
@frappe.whitelist()
@jingrow.whitelist()
def remove_child_team(child_team):
team = frappe.get_pg("Team", child_team)
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)
@frappe.whitelist()
@jingrow.whitelist()
def can_switch_to_team(team):
if not frappe.db.exists("Team", team):
return False
@ -798,7 +798,7 @@ def can_switch_to_team(team):
return False
@frappe.whitelist()
@jingrow.whitelist()
def switch_team(team):
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"
@ -812,7 +812,7 @@ def switch_team(team):
return None
@frappe.whitelist()
@jingrow.whitelist()
def leave_team(team):
team_to_leave = frappe.get_pg("Team", team)
cur_team = frappe.session.user
@ -823,7 +823,7 @@ def leave_team(team):
team_to_leave.remove_team_member(cur_team)
@frappe.whitelist()
@jingrow.whitelist()
def get_billing_information(timezone=None):
from press.utils.country_timezone import get_country_from_timezone
@ -840,7 +840,7 @@ def get_billing_information(timezone=None):
return billing_details
@frappe.whitelist()
@jingrow.whitelist()
def update_billing_information(billing_details):
try:
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.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def feedback(team, message, note, rating, route=None):
feedback = frappe.new_pg("Press Feedback")
team_pg = frappe.get_pg("Team", team)
@ -905,12 +905,12 @@ def feedback(team, message, note, rating, route=None):
feedback.insert(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def get_site_count(team):
return frappe.db.count("Site", {"team": team, "status": ("=", "Active")})
@frappe.whitelist()
@jingrow.whitelist()
def user_prompts():
if frappe.local.dev_server:
return None
@ -966,7 +966,7 @@ def get_frappe_io_auth_url() -> str | None:
return None
@frappe.whitelist()
@jingrow.whitelist()
def get_emails():
team = get_current_team(get_pg=False)
return frappe.get_all(
@ -980,7 +980,7 @@ def get_emails():
)
@frappe.whitelist()
@jingrow.whitelist()
def update_emails(data):
from frappe.utils import validate_email_address
@ -993,19 +993,19 @@ def update_emails(data):
team_pg.save()
@frappe.whitelist()
@jingrow.whitelist()
def add_key(key):
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):
key = frappe.get_pg("User SSH Key", key_name)
key.is_default = True
key.save()
@frappe.whitelist()
@jingrow.whitelist()
def create_api_secret():
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}
@frappe.whitelist()
@jingrow.whitelist()
def me():
return {"user": frappe.session.user, "team": get_current_team()}
@frappe.whitelist()
@jingrow.whitelist()
def fuse_list():
team = get_current_team(get_pg=True)
query = f"""
@ -1055,7 +1055,7 @@ def fuse_list():
# Permissions
@frappe.whitelist()
@jingrow.whitelist()
def get_permission_options(name, ptype):
"""
[{'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()}
@frappe.whitelist()
@jingrow.whitelist()
def update_permissions(user, ptype, updated):
values = []
drop = []
@ -1145,12 +1145,12 @@ def update_permissions(user, ptype, updated):
frappe.db.commit()
@frappe.whitelist()
@jingrow.whitelist()
def groups():
return frappe.get_all("Press Permission Group", {"team": get_current_team()}, ["name", "title"])
@frappe.whitelist()
@jingrow.whitelist()
def permission_group_users(name):
if get_current_team() != frappe.db.get_value("Press Permission Group", name, "team"):
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")
@frappe.whitelist()
@jingrow.whitelist()
def add_permission_group(title):
pg = frappe.get_pg(
{"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}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Press Permission Group")
def remove_permission_group(name):
frappe.db.delete("Press User Permission", {"group": name})
frappe.delete_pg("Press Permission Group", name)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Press Permission Group")
def add_permission_group_user(name, user):
pg = frappe.get_pg("Press Permission Group", name)
@ -1181,7 +1181,7 @@ def add_permission_group_user(name, user):
pg.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Press Permission Group")
def remove_permission_group_user(name, user):
pg = frappe.get_pg("Press Permission Group", name)
@ -1192,7 +1192,7 @@ def remove_permission_group_user(name, user):
break
@frappe.whitelist()
@jingrow.whitelist()
def get_permission_roles():
PressRole = frappe.qb.DocType("Press Role")
PressRoleUser = frappe.qb.DocType("Press Role User")
@ -1221,7 +1221,7 @@ def get_permission_roles():
)
@frappe.whitelist()
@jingrow.whitelist()
def get_user_ssh_keys():
return frappe.db.get_list(
"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)
def is_2fa_enabled(user: str) -> bool:
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)
def verify_2fa(user, totp_code):
user_totp_secret = get_decrypted_password("User 2FA", user, "totp_secret")
@ -1251,7 +1251,7 @@ def verify_2fa(user, totp_code):
return verified
@frappe.whitelist()
@jingrow.whitelist()
def get_2fa_qr_code_url():
"""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):
"""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):
"""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.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
def recover_2fa(user: str, recovery_code: str):
"""Recover 2FA using a recovery code."""
@ -1361,7 +1361,7 @@ def recover_2fa(user: str, recovery_code: str):
two_fa.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def get_2fa_recovery_codes(verification_code: int):
"""Get the recovery codes for the user."""
@ -1393,7 +1393,7 @@ def get_2fa_recovery_codes(verification_code: int):
return recovery_codes
@frappe.whitelist()
@jingrow.whitelist()
def reset_2fa_recovery_codes():
"""Reset the recovery codes for the user."""
@ -1423,7 +1423,7 @@ def reset_2fa_recovery_codes():
return recovery_codes
@frappe.whitelist()
@jingrow.whitelist()
def get_user_banners():
team = get_current_team()
@ -1476,7 +1476,7 @@ def get_user_banners():
return visible_banners
@frappe.whitelist()
@jingrow.whitelist()
def dismiss_banner(banner_name):
user = frappe.session.user
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.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def get_fs_read_bytes(name: str, timezone: str, duration: str = "24h"):
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")
def get_fs_write_bytes(name: str, timezone: str, duration: str = "24h"):
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")
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]))'
@ -565,7 +565,7 @@ def get_outgoing_network_traffic(name: str, timezone: str, duration: str = "24h"
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def get_incoming_network_traffic(name: str, timezone: str, duration: str = "24h"):
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")
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)'
@ -593,7 +593,7 @@ def get_memory_usage(name: str, timezone: str, duration: str = "24h"):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def get_cpu_usage(name: str, timezone: str, duration: str = "24h"):
promql_query = (
@ -608,7 +608,7 @@ def get_cpu_usage(name: str, timezone: str, duration: str = "24h"):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@redis_cache(ttl=10 * 60)
def get(name, timezone, duration="7d"):
@ -659,7 +659,7 @@ def get_additional_duration_reports(
return reports
@frappe.whitelist()
@jingrow.whitelist()
def get_advanced_analytics(name, timezone, duration="7d", max_no_of_paths=MAX_NO_OF_PATHS):
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")
@redis_cache(ttl=10 * 60)
def daily_usage(name, timezone):
@ -852,7 +852,7 @@ def get_background_job_by_(
).run()
@frappe.whitelist()
@jingrow.whitelist()
def get_slow_logs_by_query(
name: str,
agg_type: str,
@ -1147,7 +1147,7 @@ def get_current_cpu_usage_for_sites_on_server(server):
return result
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@site.feature("monitor_access")
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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@site.feature("monitor_access")
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@site.feature("monitor_access")
def mariadb_processlist(site):
@ -1243,7 +1243,7 @@ def mariadb_processlist(site):
return rows
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@site.feature("monitor_access")
def mariadb_slow_queries(
@ -1270,7 +1270,7 @@ def mariadb_slow_queries(
return {"columns": columns, "data": data}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@site.feature("monitor_access")
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@protected("Marketplace App")
def plausible_analytics(name):
response = {}
@ -1341,7 +1341,7 @@ def get_doctype_name(table_name: str) -> str:
return table_name.removeprefix("tab")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def mariadb_add_suggested_index(name, table, column):
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
@frappe.whitelist()
@jingrow.whitelist()
def new(app):
if isinstance(app, str):
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
@frappe.whitelist()
@jingrow.whitelist()
def new(bench):
team = get_current_team(get_pg=True)
if not team.enabled:
@ -72,7 +72,7 @@ def new(bench):
return group.name
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def get(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"
@frappe.whitelist()
@jingrow.whitelist()
def all(server=None, bench_filter=None):
if bench_filter is None:
bench_filter = {"status": "", "tag": ""}
@ -163,7 +163,7 @@ def all(server=None, bench_filter=None):
return private_groups
@frappe.whitelist()
@jingrow.whitelist()
def bench_tags():
team = get_current_team()
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
@frappe.whitelist()
@jingrow.whitelist()
def exists(title):
team = get_current_team()
return bool(frappe.db.exists("Release Group", {"title": title, "team": team, "enabled": True}))
@frappe.whitelist()
@jingrow.whitelist()
def get_default_apps():
press_settings = frappe.get_single("Press Settings")
default_apps = press_settings.get_default_apps()
@ -249,7 +249,7 @@ def get_app_versions_list(only_frappe=False):
return version_list, rows
@frappe.whitelist()
@jingrow.whitelist()
def options():
version_list, rows = get_app_versions_list(only_frappe=True)
approved_apps = frappe.get_all("Marketplace App", filters={"frappe_approved": 1}, pluck="app")
@ -287,7 +287,7 @@ def options():
return {"versions": versions, "clusters": clusters}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def bench_config(name):
rg = frappe.get_pg("Release Group", name)
@ -321,7 +321,7 @@ def bench_config(name):
return config
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def update_config(name, 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")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def dependencies(name: str):
rg: ReleaseGroup = frappe.get_pg("Release Group", name)
@ -385,7 +385,7 @@ def dependencies(name: str):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def update_dependencies(name: str, dependencies: str):
dependencies = frappe.parse_json(dependencies)
@ -407,7 +407,7 @@ def update_dependencies(name: str, dependencies: str):
rg.save()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def apps(name):
group = frappe.get_pg("Release Group", name)
@ -472,7 +472,7 @@ def apps(name):
return apps
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def installable_apps(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]
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def all_apps(name):
"""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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def fetch_latest_app_update(name, app):
frappe.get_pg("Release Group", name).fetch_latest_app_update(app)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def add_app(name, source, app):
add_apps(name, [{"app": app, "source": source}])
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def add_apps(name, apps):
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))
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def remove_app(name, app):
return frappe.get_pg("Release Group", name).remove_app(app)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def versions(name):
Bench = frappe.qb.DocType("Bench")
@ -636,7 +636,7 @@ def versions(name):
return deployed_versions
@frappe.whitelist()
@jingrow.whitelist()
@protected("Bench")
def get_installed_apps_in_version(name):
apps = frappe.db.get_all(
@ -660,7 +660,7 @@ def get_installed_apps_in_version(name):
return apps
@frappe.whitelist()
@jingrow.whitelist()
@protected("Bench")
def get_processes(name):
bench: "Bench" = frappe.get_pg("Bench", name)
@ -670,7 +670,7 @@ def get_processes(name):
return bench.supervisorctl_status()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def candidates(filters=None, order_by=None, limit_start=None, limit_page_length=None):
# 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()
@frappe.whitelist()
@jingrow.whitelist()
def candidate(name):
if not name:
return None
@ -736,14 +736,14 @@ def candidate(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def deploy_information(name):
rg: ReleaseGroup = frappe.get_pg("Release Group", name)
return rg.deploy_information()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def deploy(name, apps):
team = get_current_team(True)
@ -761,7 +761,7 @@ def deploy(name, apps):
return deploy_candidate_build["name"]
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def deploy_and_update(
name: str,
@ -778,7 +778,7 @@ def deploy_and_update(
).deploy(run_will_fail_check)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def update_inplace(
name: str,
@ -794,7 +794,7 @@ def update_inplace(
).update_inplace()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def create_deploy_candidate(name, apps_to_ignore=None):
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def running_jobs(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]
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def recent_deploys(name):
return frappe.get_all(
@ -846,7 +846,7 @@ def recent_deploys(name):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def change_branch(name: str, app: str, to_branch: str):
"""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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def branch_list(name: str, app: str) -> list[dict]:
"""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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def regions(name):
rg = frappe.get_pg("Release Group", name)
@ -920,7 +920,7 @@ def regions(name):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def available_regions(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)})
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def add_region(name, region):
frappe.get_pg("Release Group", name).add_region(region)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def archive(name):
benches = frappe.get_all("Bench", filters={"group": name, "status": "Active"}, pluck="name")
@ -949,25 +949,25 @@ def archive(name):
group.save()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Bench")
def restart(name):
frappe.get_pg("Bench", name).restart()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Bench")
def rebuild(name):
frappe.get_pg("Bench", name).rebuild()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Bench")
def update(name):
frappe.get_pg("Bench", name).update_all_sites()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def update_all_sites(name):
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.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def logs(name, bench):
from press.agent import AgentRequestSkippedException
@ -989,7 +989,7 @@ def logs(name, bench):
return []
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def log(name, bench, log):
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def certificate(name):
return frappe.get_pg("Release Group", name).get_certificate()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def generate_certificate(name):
return frappe.get_pg("Release Group", name).generate_certificate()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def get_title_and_creation(name):
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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def rename(name, title):
return frappe.db.set_value("Release Group", name, "title", title)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def apply_patch(release_group: str, app: str, patch_config: dict) -> list[str]:
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")
def fail_build(dn: str):
failed = fail_remote_job(dn)
@ -1048,7 +1048,7 @@ def fail_build(dn: str):
frappe.throw("No running job found!")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def fail_and_redeploy(name: str, dc_name: str):
res = fail_and_redeploy_build(dc_name)
@ -1061,7 +1061,7 @@ def fail_and_redeploy(name: str, dc_name: str):
return res.get("message")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Release Group")
def show_app_versions(name: str, dc_name: str) -> dict[str, str]:
"""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")
def redeploy(name: str, dc_name: str) -> str:
response = redeploy_candidate(dc_name)
@ -1106,7 +1106,7 @@ def redeploy(name: str, dc_name: str) -> str:
return response["message"]
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def confirm_bench_transfer(key: str):
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_publishable_key_and_setup_intent():
team = get_current_team()
@ -52,7 +52,7 @@ def get_publishable_key_and_setup_intent():
}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def upcoming_invoice():
team = get_current_team(True)
@ -70,34 +70,34 @@ def upcoming_invoice():
}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_balance_credit():
team = get_current_team(True)
return team.get_balance()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def past_invoices():
return get_current_team(True).get_past_invoices()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def invoices_and_payments():
team = get_current_team(True)
return team.get_past_invoices()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def refresh_invoice_link(invoice):
pg = frappe.get_pg("Invoice", invoice)
return pg.refresh_stripe_payment_link()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def balances():
team = get_current_team()
@ -201,7 +201,7 @@ def is_added_credits_bt(bt):
return not bt.description.startswith("Reverse")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def details():
team = get_current_team(True)
@ -226,7 +226,7 @@ def details():
}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def fetch_invoice_items(invoice):
team = get_current_team()
@ -250,7 +250,7 @@ def fetch_invoice_items(invoice):
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_customer_details(team):
"""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")
def create_payment_intent_for_micro_debit():
team = get_current_team(True)
@ -284,7 +284,7 @@ def create_payment_intent_for_micro_debit():
return {"client_secret": intent["client_secret"]}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def create_payment_intent_for_partnership_fees():
team = get_current_team(True)
@ -312,7 +312,7 @@ def create_payment_intent_for_partnership_fees():
}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def create_payment_intent_for_buying_credits(amount):
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")
def create_payment_intent_for_prepaid_app(amount, metadata):
stripe = get_stripe()
@ -400,21 +400,21 @@ def create_payment_intent_for_prepaid_app(amount, metadata):
}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_payment_methods():
team = get_current_team()
return frappe.get_pg("Team", team).get_payment_methods()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def set_as_default(name):
payment_method = frappe.get_pg("Stripe Payment Method", {"name": name, "team": get_current_team()})
payment_method.set_default()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def remove_payment_method(name):
team = get_current_team()
@ -428,7 +428,7 @@ def remove_payment_method(name):
return None
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def finalize_invoices():
unsettled_invoices = frappe.get_all(
@ -442,7 +442,7 @@ def finalize_invoices():
inv_pg.finalize_invoice()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def unpaid_invoices():
team = get_current_team()
@ -458,7 +458,7 @@ def unpaid_invoices():
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_unpaid_invoices():
team = get_current_team()
@ -476,7 +476,7 @@ def get_unpaid_invoices():
return unpaid_invoices # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def change_payment_mode(mode):
team = get_current_team(get_pg=True)
@ -494,7 +494,7 @@ def change_payment_mode(mode):
return
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def prepaid_credits_via_onboarding():
"""When prepaid credits are bought, the balance is not immediately reflected.
@ -514,7 +514,7 @@ def prepaid_credits_via_onboarding():
team.save()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_invoice_usage(invoice):
team = get_current_team()
@ -527,7 +527,7 @@ def get_invoice_usage(invoice):
return out
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_summary():
team = get_current_team()
@ -581,13 +581,13 @@ def get_grouped_invoice_items(invoices: list[str]) -> dict:
return invoice_items_map
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def after_card_add():
clear_setup_intent()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def setup_intent_success(setup_intent, address=None):
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}
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def validate_gst(address, method=None):
if isinstance(address, dict):
@ -640,7 +640,7 @@ def validate_gst(address, method=None):
validate_gstin_check_digit(address.gstin)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_latest_unpaid_invoice():
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def is_paypal_enabled() -> bool:
return frappe.db.get_single_value("Press Settings", "paypal_enabled")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def create_razorpay_order(amount, transaction_type, pg_name=None) -> dict | None:
if not transaction_type:
@ -776,7 +776,7 @@ def _validate_invoice_payment(amount, pg_name, currency):
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def handle_razorpay_payment_success(response):
client = get_razorpay_client()
@ -797,7 +797,7 @@ def handle_razorpay_payment_success(response):
payment_record.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def handle_razorpay_payment_failed(response):
payment_record = frappe.get_pg(
@ -811,7 +811,7 @@ def handle_razorpay_payment_failed(response):
payment_record.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def total_unpaid_amount():
team = get_current_team(get_pg=True)
@ -829,7 +829,7 @@ def total_unpaid_amount():
) + negative_balance
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def get_current_billing_amount():
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):
"""Verify the transaction result received via callback from STK."""
transaction_response, request_id = parse_transaction_response(kwargs)
@ -960,7 +960,7 @@ def handle_transaction_result(transaction_response, integration_request):
return status
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
def request_for_payment(**kwargs):
"""request for payments"""
@ -1118,7 +1118,7 @@ def parse_datetime(date):
return datetime.strptime(str(date), "%Y%m%d%H%M%S")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("billing")
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.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def callback(job_id: str):
"""
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def account_request(
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.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def setup_account(key, business_data=None):
account_request = get_account_request_from_key(key)
if not account_request:
@ -121,7 +121,7 @@ def setup_account(key, business_data=None):
return site.name
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def check_subdomain_availability(subdomain):
exists = bool(
frappe.db.exists(
@ -139,7 +139,7 @@ def check_subdomain_availability(subdomain):
return True
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def options_for_regional_data(key):
account_request = get_account_request_from_key(key)
if not account_request:
@ -155,7 +155,7 @@ def options_for_regional_data(key):
return data
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_trial_end_date(site):
if not site or not isinstance(site, str):
frappe.throw("Invalid Site")
@ -163,7 +163,7 @@ def get_trial_end_date(site):
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):
if not site or not isinstance(site, str) or not frappe.db.exists("Site", site):
frappe.throw("Invalid site")

14
press/api/client.py
View File

@ -98,7 +98,7 @@ ALLOWED_DOCTYPES = [
whitelisted_methods = set()
@frappe.whitelist()
@jingrow.whitelist()
def get_list(
doctype: str,
fields: list | None = None,
@ -199,7 +199,7 @@ def get_list_query(
return query
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.document(
document_type=lambda args: str(args.get("doctype")),
document_name=lambda args: str(args.get("name")),
@ -237,7 +237,7 @@ def get(doctype, name):
return dashboard_access_rules(_pg)
@frappe.whitelist(methods=["POST", "PUT"])
@jingrow.whitelist(methods=["POST", "PUT"])
def insert(pg=None):
if not pg or not pg.get("doctype"):
frappe.throw(frappe._("pg.doctype is required"))
@ -272,7 +272,7 @@ def insert(pg=None):
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):
check_permissions(doctype)
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)
@frappe.whitelist(methods=["DELETE", "POST"])
@jingrow.whitelist(methods=["DELETE", "POST"])
def delete(doctype: str, name: str):
method = "delete"
@ -298,7 +298,7 @@ def delete(doctype: str, name: str):
_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):
check_permissions(dt)
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.whitelist()
@jingrow.whitelist()
def search_link(
doctype: str,
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
@frappe.whitelist()
@jingrow.whitelist()
def standard_keys():
return frappe.get_all(
"Site Config Key",
@ -12,7 +12,7 @@ def standard_keys():
)
@frappe.whitelist()
@jingrow.whitelist()
def is_valid(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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def update_preferences(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
@frappe.whitelist()
@jingrow.whitelist()
def all():
sites = frappe.get_list(
"Site",
@ -20,7 +20,7 @@ def all():
return {"sites": sites}
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"])
def create_new_tag(name, doctype, tag):
team = get_current_team()
@ -39,7 +39,7 @@ def create_new_tag(name, doctype, tag):
return tag
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"])
def add_tag(name, doctype, tag):
pg = frappe.get_pg(doctype, name)
@ -48,7 +48,7 @@ def add_tag(name, doctype, tag):
return tag
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Site", "Release Group", "Server", "Database Server"])
def remove_tag(name, doctype, tag):
pg = frappe.get_pg(doctype, name)

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

@ -179,56 +179,56 @@ class SessionManager:
# ------------------------------------------------------------
# API ENDPOINTS
# ------------------------------------------------------------
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_subscription_status(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription_status()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_subscription_info(secret_key: str) -> Dict:
api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription_info()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_subscription(secret_key: str) -> str:
api_handler = DeveloperApiHandler(secret_key)
return api_handler.get_subscription()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_plans(secret_key: str, subscription: str) -> List:
api_handler = DeveloperApiHandler(secret_key)
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:
data = frappe.parse_json(data)
api_handler = DeveloperApiHandler(secret_key)
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:
api_handler = DeveloperApiHandler(secret_key)
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:
api_handler = DeveloperApiHandler(secret_key)
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:
api_handler = DeveloperApiHandler(secret_key)
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:
api_handler = DeveloperApiHandler(secret_key)
return api_handler.send_login_link()

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

@ -82,30 +82,30 @@ class SaasApiHandler:
# ------------------------------------------------------------
# API ENDPOINTS
# ------------------------------------------------------------
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def ping():
return "pong"
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_subscription_status(secret_key):
api_handler = SaasApiHandler(secret_key)
return api_handler.get_subscription_status()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_plan_config(secret_key):
api_handler = SaasApiHandler(secret_key)
return api_handler.get_plan_config()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_subscription_info(secret_key):
api_handler = SaasApiHandler(secret_key)
return api_handler.get_subscription_info()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_trial_expiry(secret_key):
api_handler = SaasApiHandler(secret_key)
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)
def send_verification_code(domain: str, route: str = ""):
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)
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)
@ -188,7 +188,7 @@ def verify_verification_code(domain: str, verification_code: str, route: str = "
frappe.response["login_token"] = login_token
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60)
def login_to_fc(token: str):
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def email_ping():
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.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_analytics(**data):
"""
send data for a specific month
@ -206,7 +206,7 @@ def check_recipients(recipients: str | list[str]):
validate_email_address(recipient, throw=True)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def send_mime_mail(**data):
"""
send api request to mailgun
@ -261,7 +261,7 @@ def is_valid_mailgun_event(event_data):
return True
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def event_log():
"""
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
@frappe.whitelist(allow_guest=True, xss_safe=True)
@jingrow.whitelist(allow_guest=True, xss_safe=True)
def hook(*args, **kwargs):
user = frappe.session.user
# 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")
@frappe.whitelist()
@jingrow.whitelist()
def clear_token_and_get_installation_url():
clear_current_team_access_token()
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.whitelist()
@jingrow.whitelist()
def options():
team = get_current_team()
token = frappe.db.get_value("Team", team, "github_access_token")
@ -162,7 +162,7 @@ def repositories(installation, token):
return repositories
@frappe.whitelist()
@jingrow.whitelist()
def repository(owner, name, installation=None):
token = ""
if not installation:
@ -197,7 +197,7 @@ def repository(owner, name, installation=None):
return repo
@frappe.whitelist()
@jingrow.whitelist()
def app(owner, repository, branch, installation=None):
headers = get_auth_headers(installation)
response = requests.get(
@ -235,7 +235,7 @@ def app(owner, repository, branch, installation=None):
return {"name": app_name, "title": title}
@frappe.whitelist()
@jingrow.whitelist()
def branches(owner, name, installation=None):
if 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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def login(product=None):
flow = google_oauth_flow()
authorization_url, state = flow.authorization_url()
@ -26,7 +26,7 @@ def login(product=None):
return authorization_url
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def callback(code=None, state=None): # noqa: C901
cached_key = f"google_oauth_flow:{state}"
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"])
def get_log(log_type: LOG_TYPE, pg_name: str, log_name: str) -> list:
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
@frappe.whitelist()
@jingrow.whitelist()
def get(app):
record = frappe.get_pg("Marketplace App", app)
return {
@ -41,7 +41,7 @@ def get(app):
}
@frappe.whitelist()
@jingrow.whitelist()
def get_install_app_options(marketplace_app: str) -> dict:
"""Get options for installing a marketplace app"""
@ -315,7 +315,7 @@ def create_site_on_private_bench(
return site_group_deploy # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
def create_site_for_app(
subdomain: str,
apps: list[dict],
@ -338,7 +338,7 @@ def create_site_for_app(
return create_site_on_private_bench(subdomain, apps, cluster)
@frappe.whitelist()
@jingrow.whitelist()
def options_for_quick_install(marketplace_app: str):
app_name, title, frappe_approved = frappe.db.get_value(
"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")
@frappe.whitelist()
@jingrow.whitelist()
def become_publisher():
"""Turn on marketplace developer mode for current team"""
current_team = get_current_team(get_pg=True)
@ -427,13 +427,13 @@ def become_publisher():
current_team.save()
@frappe.whitelist()
@jingrow.whitelist()
def frappe_versions():
"""Return a list of Frappe Version names"""
return frappe.get_all("Frappe Version", pluck="name", order_by="name desc")
@frappe.whitelist()
@jingrow.whitelist()
def get_apps() -> list[dict]:
"""Return list of apps developed by the current team"""
team = get_current_team()
@ -447,7 +447,7 @@ def get_apps() -> list[dict]:
return apps # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
@protected("Marketplace App")
def get_app(name: str) -> dict:
"""Return the `Marketplace App` document with name"""
@ -460,7 +460,7 @@ def get_app(name: str) -> dict:
return app
@frappe.whitelist()
@jingrow.whitelist()
@protected("Marketplace App")
def deploy_information(name: str):
"""Return the deploy information for marketplace app `app`"""
@ -468,12 +468,12 @@ def deploy_information(name: str):
return marketplace_app.get_deploy_information()
@frappe.whitelist()
@jingrow.whitelist()
def profile_image_url(app: str) -> str:
return frappe.db.get_value("Marketplace App", app, "image")
@frappe.whitelist()
@jingrow.whitelist()
def update_app_image() -> str:
"""Handles App Image Upload"""
file_content = frappe.local.uploaded_file
@ -519,7 +519,7 @@ def convert_to_webp(file_content: bytes) -> bytes:
return image_bytes.getvalue()
@frappe.whitelist()
@jingrow.whitelist()
def add_app_screenshot() -> str:
"""Handles App Image Upload"""
file_content = frappe.local.uploaded_file
@ -556,7 +556,7 @@ def add_app_screenshot() -> str:
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def remove_app_screenshot(name, file):
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.whitelist()
@jingrow.whitelist()
def update_app_title(name: str, title: str) -> MarketplaceApp:
"""Update `title` and `category`"""
app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
@ -589,7 +589,7 @@ def update_app_title(name: str, title: str) -> MarketplaceApp:
return app
@frappe.whitelist()
@jingrow.whitelist()
def update_app_links(name: str, links: dict) -> None:
"""Update links related to app"""
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)
@frappe.whitelist()
@jingrow.whitelist()
def update_app_summary(name: str, summary: str) -> None:
"""Update the `description` of 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)
@frappe.whitelist()
@jingrow.whitelist()
def update_app_description(name: str, description: str) -> None:
"""Update the `long_description` of 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)
@frappe.whitelist()
@jingrow.whitelist()
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"""
@ -641,32 +641,32 @@ def releases(filters=None, order_by=None, limit_start=None, limit_page_length=No
return app_releases
@frappe.whitelist()
@jingrow.whitelist()
def get_app_source(name: str) -> AppSource:
"""Return `App Source` document having `name`"""
return frappe.get_pg("App Source", name)
@frappe.whitelist()
@jingrow.whitelist()
def latest_approved_release(source: None | str) -> AppRelease:
"""Return the latest app release with `approved` status"""
return get_last_pg("App Release", {"source": source, "status": "Approved"})
@frappe.whitelist()
@jingrow.whitelist()
@protected("Marketplace App")
def create_approval_request(name, app_release: str):
"""Create a new Approval Request for given `app_release`"""
frappe.get_pg("Marketplace App", name).create_approval_request(app_release)
@frappe.whitelist()
@jingrow.whitelist()
def cancel_approval_request(app_release: str):
"""Cancel Approval Request for given `app_release`"""
get_latest_approval_request(app_release).cancel()
@frappe.whitelist()
@jingrow.whitelist()
def reason_for_rejection(app_release: str) -> str:
"""Return feedback given on a `Rejected` approval request"""
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
@frappe.whitelist()
@jingrow.whitelist()
def options_for_marketplace_app() -> dict[str, dict]: # noqa: C901
# Get versions (along with apps and associated sources)
# which belong to the current team
@ -744,7 +744,7 @@ def options_for_marketplace_app() -> dict[str, dict]: # noqa: C901
return marketplace_options
@frappe.whitelist()
@jingrow.whitelist()
def get_marketplace_apps_for_onboarding() -> list[dict]:
apps = frappe.get_all(
"Marketplace App",
@ -763,7 +763,7 @@ def is_on_marketplace(app: str) -> bool:
return frappe.db.exists("Marketplace App", app)
@frappe.whitelist()
@jingrow.whitelist()
def new_app(app: dict):
name = app["name"]
team = get_current_team()
@ -784,7 +784,7 @@ def new_app(app: dict):
return add_app(source.name, app_pg.name)
@frappe.whitelist()
@jingrow.whitelist()
def add_app(source: str, app: str):
if not is_on_marketplace(app):
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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Marketplace App")
def analytics(name: str):
marketplace_app_pg: MarketplaceApp = frappe.get_pg("Marketplace App", name)
return marketplace_app_pg.get_analytics()
@frappe.whitelist()
@jingrow.whitelist()
def get_promotional_banners() -> list:
promotionalBanner = frappe.qb.DocType("Marketplace Promotional Banner")
marketplaceApp = frappe.qb.DocType("Marketplace App")
@ -858,7 +858,7 @@ def get_promotional_banners() -> list:
# like 'api/marketplace/billing.py')
@frappe.whitelist()
@jingrow.whitelist()
def get_marketplace_subscriptions_for_site(site: str):
subscriptions = frappe.db.get_all(
"Subscription",
@ -887,17 +887,17 @@ def get_marketplace_subscriptions_for_site(site: str):
return subscriptions
@frappe.whitelist()
@jingrow.whitelist()
def get_app_plans(app: str, include_disabled=True):
return get_plans_for_app(app, include_disabled=include_disabled)
@frappe.whitelist()
@jingrow.whitelist()
def get_app_info(app: str):
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):
if isinstance(apps, str):
apps = json.loads(apps)
@ -927,7 +927,7 @@ def get_apps_with_plans(apps, release_group: str):
return apps_with_plans
@frappe.whitelist()
@jingrow.whitelist()
def change_app_plan(subscription, new_plan):
is_free = frappe.db.get_value("Marketplace App Plan", new_plan, "price_usd") <= 0
if not is_free:
@ -943,7 +943,7 @@ def change_app_plan(subscription, new_plan):
subscription.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def get_publisher_profile_info():
publisher_profile_info = {}
@ -960,7 +960,7 @@ def get_publisher_profile_info():
return publisher_profile_info
@frappe.whitelist()
@jingrow.whitelist()
def update_publisher_profile(profile_data=None):
"""Update if exists, otherwise create"""
team = get_current_team()
@ -978,7 +978,7 @@ def update_publisher_profile(profile_data=None):
profile_pg.insert(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def submit_user_review(title, rating, app, review):
return frappe.get_pg(
{
@ -992,7 +992,7 @@ def submit_user_review(title, rating, app, review):
).insert(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def submit_developer_reply(review, reply):
return frappe.get_pg(
{
@ -1004,7 +1004,7 @@ def submit_developer_reply(review, reply):
).insert(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def get_subscriptions_list(marketplace_app: str) -> list:
app_sub = frappe.qb.DocType("Subscription")
app_plan = frappe.qb.DocType("Marketplace App Plan")
@ -1045,7 +1045,7 @@ def get_subscriptions_list(marketplace_app: str) -> list:
return result # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
def create_app_plan(marketplace_app: str, plan_data: dict):
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)
@frappe.whitelist()
@jingrow.whitelist()
def update_app_plan(app_plan_name: str, updated_plan_data: dict):
if not updated_plan_data.get("title"):
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)
@frappe.whitelist()
@jingrow.whitelist()
def get_payouts_list() -> list[dict]:
team = get_current_team()
payouts = frappe.get_all(
@ -1135,7 +1135,7 @@ def get_payouts_list() -> list[dict]:
return payouts # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
def get_payout_details(name: str) -> dict:
order_items = frappe.get_all(
"Payout Order Item",
@ -1197,7 +1197,7 @@ def get_discount_percent(plan, discount=0.0):
return discount
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def login_via_token(token: str, team: str, site: str):
if not token or not isinstance(token, str):
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.whitelist()
@jingrow.whitelist()
def subscriptions():
team = get_current_team(True)
free_plans = frappe.get_all("Marketplace App Plan", {"price_usd": ("<=", 0)}, pluck="name")
@ -1250,7 +1250,7 @@ def subscriptions():
@protected("App Source")
@frappe.whitelist()
@jingrow.whitelist()
def branches(name):
from press.api.github import branches as git_branches
@ -1268,14 +1268,14 @@ def branches(name):
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def change_branch(name, source, version, to_branch):
app = frappe.get_pg("Marketplace App", name)
app.change_branch(source, version, to_branch)
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def options_for_version(name):
frappe_version = frappe.get_all("Frappe Version", {"public": True}, pluck="name")
added_versions = frappe.get_all("Marketplace App Version", {"parent": name}, pluck="version")
@ -1289,21 +1289,21 @@ def options_for_version(name):
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def add_version(name, branch, version):
app = frappe.get_pg("Marketplace App", name)
app.add_version(version, branch)
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def remove_version(name, version):
app = frappe.get_pg("Marketplace App", name)
app.remove_version(version)
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def review_steps(name):
app = frappe.get_pg("Marketplace App", name)
return [
@ -1337,14 +1337,14 @@ def review_steps(name):
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def mark_app_ready_for_review(name):
app = frappe.get_pg("Marketplace App", name)
app.mark_app_ready_for_review()
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def communication(name):
comm = frappe.qb.DocType("Communication")
user = frappe.qb.DocType("User")
@ -1361,7 +1361,7 @@ def communication(name):
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def add_reply(name, message):
doctype = "Marketplace App"
app = frappe.get_pg(doctype, name)
@ -1385,14 +1385,14 @@ def add_reply(name, message):
@protected("Marketplace App")
@frappe.whitelist()
@jingrow.whitelist()
def fetch_readme(name):
app: MarketplaceApp = frappe.get_pg("Marketplace App", name)
app.long_description = app.fetch_readme()
app.save()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_marketplace_apps():
apps = frappe.cache().get_value("marketplace_apps")
if not apps:
@ -1402,7 +1402,7 @@ def get_marketplace_apps():
@protected("App Source")
@frappe.whitelist()
@jingrow.whitelist()
def add_code_review_comment(name, filename, line_number, comment):
try:
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=1200, seconds=60)
def confirmed_incident(server_title: str):
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
@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)
def targets(token=None):
if not token:
@ -136,7 +136,7 @@ def targets(token=None):
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):
user = frappe.session.user
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.document(
document_type=lambda _: "Site",
inject_values=True,
@ -78,11 +78,11 @@ def get_notifications(
return notifications
@frappe.whitelist()
@jingrow.whitelist()
def mark_all_notifications_as_read():
frappe.db.set_value("Press Notification", {"team": get_current_team()}, "read", 1, update_modified=False)
@frappe.whitelist()
@jingrow.whitelist()
def get_unread_count():
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def google_login(saas_app=None):
flow = google_oauth_flow()
authorization_url, state = flow.authorization_url()
@ -50,7 +50,7 @@ def google_login(saas_app=None):
return authorization_url
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def callback(code=None, state=None):
cached_key = f"fc_oauth_state:{state}"
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def saas_setup(key, app, country, subdomain):
if not check_subdomain_availability(subdomain, app):
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def oauth_authorize_url(provider):
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def approve_partner_request(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.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_request_status(team):
return frappe.db.get_value("Partner Approval Request", {"requested_by": team}, "status")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def update_partnership_date(team, partnership_date):
if team:
@ -52,7 +52,7 @@ def update_partnership_date(team, partnership_date):
team_pg.save()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def update_website_info(website_info):
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.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_details(partner_email):
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def send_link_certificate_request(user_email, certificate_type):
if not frappe.db.exists(
@ -126,7 +126,7 @@ def send_link_certificate_request(user_email, certificate_type):
).insert()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def approve_certificate_link_request(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.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_resource_url():
return frappe.db.get_value("Press Settings", "Press Settings", "drive_resource_link")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_name(partner_email):
return frappe.db.get_value(
@ -154,7 +154,7 @@ def get_partner_name(partner_email):
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def transfer_credits(amount, customer, partner):
# partner discount map
@ -194,7 +194,7 @@ def transfer_credits(amount, customer, partner):
frappe.db.rollback()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_contribution_list(partner_email):
partner_currency = frappe.db.get_value(
@ -223,7 +223,7 @@ def get_partner_contribution_list(partner_email):
return invoices
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_mrr(partner_email):
partner_currency = frappe.db.get_value(
@ -256,7 +256,7 @@ def get_partner_mrr(partner_email):
return [d for d in query]
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_dashboard_stats():
team = get_current_team(get_pg=True)
@ -278,7 +278,7 @@ def get_dashboard_stats():
return [d for d in data]
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_lead_stats():
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")
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_lead_activities(name):
get_docinfo("", "Partner Lead", name)
@ -419,7 +419,7 @@ def parse_grouped_versions(versions):
return version
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_invoices(due_date=None, status=None):
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_invoice_items(invoice):
data = frappe.get_all(
@ -460,7 +460,7 @@ def get_invoice_items(invoice):
return data
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_current_month_partner_contribution(partner_email):
partner_currency = frappe.db.get_value(
@ -493,7 +493,7 @@ def get_current_month_partner_contribution(partner_email):
return total
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_prev_month_partner_contribution(partner_email):
partner_currency = frappe.db.get_value(
@ -534,7 +534,7 @@ def get_prev_month_partner_contribution(partner_email):
return total
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def calculate_partner_tier(contribution, currency):
partner_tier = frappe.qb.DocType("Partner Tier")
@ -552,7 +552,7 @@ def calculate_partner_tier(contribution, currency):
return tier[0]
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def add_partner(referral_code: str):
team = get_current_team(get_pg=True)
@ -576,7 +576,7 @@ def add_partner(referral_code: str):
return None
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def validate_partner_code(code):
partner = frappe.db.get_value(
@ -589,7 +589,7 @@ def validate_partner_code(code):
return False, None
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_customers():
team = get_current_team(get_pg=True)
@ -601,7 +601,7 @@ def get_partner_customers():
return customers # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_members(partner):
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")
def get_partner_leads(lead_name=None, status=None, engagement_stage=None, source=None):
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")
def change_partner(lead_name, partner):
team = get_current_team()
@ -647,7 +647,7 @@ def change_partner(lead_name, partner):
pg.save()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def remove_partner():
team = get_current_team(get_pg=True)
@ -666,7 +666,7 @@ def remove_partner():
team.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def apply_for_certificate(member_name, certificate_type):
team = get_current_team(get_pg=True)
@ -681,7 +681,7 @@ def apply_for_certificate(member_name, certificate_type):
pg.insert(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_partner_teams(company=None, email=None, country=None, tier=None, active_only=False):
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
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_local_payment_setup():
team = get_current_team()
@ -714,20 +714,20 @@ def get_local_payment_setup():
return data
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_certificate_users():
users = frappe.get_all("Partner Certificate", ["partner_member_email", "partner_member_name"])
return users # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def get_lead_details(lead_id):
return frappe.get_pg("Partner Lead", lead_id).as_dict()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def update_lead_details(lead_name, lead_details):
lead_details = frappe._dict(lead_details)
@ -751,7 +751,7 @@ def update_lead_details(lead_name, lead_details):
pg.reload()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def update_lead_status(lead_name, status, **kwargs):
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.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def fetch_followup_details(id, lead):
return frappe.get_all(
@ -806,13 +806,13 @@ def fetch_followup_details(id, lead):
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def check_certificate_exists(email, type):
return frappe.db.count("Partner Certificate", {"partner_member_email": email, "course": type})
@frappe.whitelist()
@jingrow.whitelist()
def get_fc_plans():
site_plans = frappe.get_all(
"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"]
@frappe.whitelist()
@jingrow.whitelist()
def update_followup_details(id, lead, followup_details):
followup_details = frappe._dict(followup_details)
if id:
@ -857,7 +857,7 @@ def update_followup_details(id, lead, followup_details):
pg.reload()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def add_new_lead(lead_details):
lead_details = frappe._dict(lead_details)
@ -883,7 +883,7 @@ def add_new_lead(lead_details):
pg.reload()
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def can_apply_for_certificate():
from press.utils.billing import get_frappe_io_connection
@ -895,7 +895,7 @@ def can_apply_for_certificate():
return response # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.api("partner")
def delete_followup(id, lead_name):
frappe.delete_pg("Lead Followup", id)

2
press/api/payment.py
View File

@ -6,7 +6,7 @@
import jingrow
@frappe.whitelist()
@jingrow.whitelist()
def all():
payments = frappe.get_all(
"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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def send_verification_code_for_login(email: str, product: str):
is_user_exists = frappe.db.exists("Team", {"user": email}) and _get_active_site(
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=300)
def login_using_code(email: str, product: str, code: str):
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)
def get_account_request_for_product_signup():
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):
ar = get_account_request_from_key(key)
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:
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"]
@frappe.whitelist()
@jingrow.whitelist()
def update_mpesa_setup(mpesa_details):
"""Create Mpesa Settings for the team."""
mpesa_info = frappe._dict(mpesa_details)
@ -59,7 +59,7 @@ def update_mpesa_setup(mpesa_details):
return None
@frappe.whitelist()
@jingrow.whitelist()
def fetch_mpesa_setup():
team = get_current_team()
if frappe.db.exists("Mpesa Setup", {"team": team}):
@ -78,7 +78,7 @@ def fetch_mpesa_setup():
return None
@frappe.whitelist()
@jingrow.whitelist()
def display_invoices_by_partner():
"""Display the list of invoices by partner."""
team = get_current_team()
@ -98,7 +98,7 @@ def display_invoices_by_partner():
return invoices # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
def get_exchange_rate(from_currency, to_currency):
"""Get the latest exchange rate for the given currencies."""
exchange_rate = frappe.db.get_value(
@ -110,7 +110,7 @@ def get_exchange_rate(from_currency, to_currency):
return exchange_rate # noqa: RET504
@frappe.whitelist()
@jingrow.whitelist()
def update_payment_gateway_settings(gateway_details):
"""Create Payment Gateway Settings for the team."""
team = get_current_team()
@ -159,7 +159,7 @@ def update_payment_gateway_settings(gateway_details):
return None
@frappe.whitelist()
@jingrow.whitelist()
def get_payment_gateway_details():
team = get_current_team()
if frappe.db.exists("Payment Gateway", {"team": team}):
@ -178,7 +178,7 @@ def get_payment_gateway_details():
return None
@frappe.whitelist()
@jingrow.whitelist()
def get_gateway_controller():
# """Get the list of controllers for the given doctype."""
team = get_current_team(get_pg=True)
@ -188,7 +188,7 @@ def get_gateway_controller():
return None
@frappe.whitelist()
@jingrow.whitelist()
def get_tax_percentage(payment_partner):
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")
@ -222,7 +222,7 @@ def update_tax_id_or_phone_no(team, tax_id, phone_number):
team_pg.save()
@frappe.whitelist()
@jingrow.whitelist()
def display_mpesa_payment_partners():
"""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]
@frappe.whitelist()
@jingrow.whitelist()
def display_payment_partners():
"""Display the list of partners in the system."""
Team = DocType("Team")
@ -253,7 +253,7 @@ def display_payment_partners():
return [partner["user"] for partner in partners]
@frappe.whitelist()
@jingrow.whitelist()
def display_payment_gateway():
"""Display the payment gateway for the partner."""
gateways = frappe.get_all("Payment Gateway", filters={}, fields=["gateway"])
@ -331,7 +331,7 @@ def fetch_param_value(response, key, key_field):
return None
@frappe.whitelist()
@jingrow.whitelist()
def create_exchange_rate(**kwargs):
"""Create a new exchange rate record."""
try:
@ -385,7 +385,7 @@ def create_payment_partner_transaction(
return transaction_pg.name
@frappe.whitelist()
@jingrow.whitelist()
def fetch_payments(payment_gateway, partner, from_date, to_date):
partner = (
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
@frappe.whitelist()
@jingrow.whitelist()
def fetch_percentage_commission(partner):
"""Fetch the percentage commission for the partner."""
return frappe.get_value("Team", {"user": partner}, "partner_commission")
@frappe.whitelist()
@jingrow.whitelist()
def create_invoice_partner_site(data, gateway_controller):
gateway = frappe.get_pg("Payment Gateway", gateway_controller)
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.whitelist()
@jingrow.whitelist()
def display_payment_gateways(payment_partner):
"""Display the list of payment gateways for the partner."""
Team = DocType("Team")
@ -482,7 +482,7 @@ def display_payment_gateways(payment_partner):
return [gateway["name"] for gateway in payment_gateways]
@frappe.whitelist()
@jingrow.whitelist()
def fetch_payouts():
team = get_current_team()
payouts = frappe.get_all(

16
press/api/saas.py
View File

@ -24,7 +24,7 @@ if TYPE_CHECKING:
# ----------------------------- SIGNUP APIs ---------------------------------
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def account_request(
subdomain,
email,
@ -120,7 +120,7 @@ def create_or_rename_saas_site(app, account_request):
frappe.session.data = current_session_data
@frappe.whitelist()
@jingrow.whitelist()
def new_saas_site(subdomain, app):
frappe.only_for("System Manager")
@ -140,7 +140,7 @@ def new_saas_site(subdomain, app):
return site
@frappe.whitelist()
@jingrow.whitelist()
def get_saas_site_status(site):
if frappe.db.exists("Site", site):
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def check_subdomain_availability(subdomain, app):
"""
Checks if subdomain is available to create a new site
@ -210,7 +210,7 @@ def check_subdomain_availability(subdomain, app):
return True
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def setup_account(key, business_data=None):
"""
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):
"""
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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_site_status(key, app=None):
"""
return: Site status
@ -362,7 +362,7 @@ def get_site_status(key, app=None):
return {"status": "Pending"}
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def get_site_url_and_sid(key, app=None):
"""
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
@frappe.whitelist()
@jingrow.whitelist()
def get_servers(server_filter):
servers = get_all_servers(server_filter=server_filter)
@ -21,7 +21,7 @@ def get_servers(server_filter):
return servers
@frappe.whitelist()
@jingrow.whitelist()
def fetch_security_updates(
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):
return frappe.get_pg("Security Update", update_id).as_dict()
@frappe.whitelist()
@jingrow.whitelist()
def fetch_ssh_sessions(server, start=0, limit=10):
return frappe.get_all(
"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):
logs_to_display = []
ssh_logs = Agent(server=server).get("security/ssh_session_logs")
@ -70,7 +70,7 @@ def fetch_ssh_session_logs(server):
return logs_to_display
@frappe.whitelist()
@jingrow.whitelist()
def fetch_ssh_session_activity(server, filename):
content = Agent(server=server).get(f"security/retrieve_ssh_session_log/{filename}")
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
@frappe.whitelist()
@jingrow.whitelist()
def new(server):
server_details = frappe._dict(server)
@ -71,12 +71,12 @@ def get_hybrid_cluster():
return frappe.db.get_value("Cluster", {"hybrid": 1}, "name")
@frappe.whitelist()
@jingrow.whitelist()
def sshkey():
return frappe.db.get_value("SSH Key", {"enabled": 1, "default": 1}, "public_key")
@frappe.whitelist()
@jingrow.whitelist()
def verify(server):
server_pg = frappe.get_pg("Self Hosted Server", server)
@ -125,7 +125,7 @@ def verify_server(server_type, server_pg):
return False
@frappe.whitelist()
@jingrow.whitelist()
def setup(server):
server_pg = frappe.get_pg("Self Hosted Server", server)
server_pg.start_setup = True
@ -134,12 +134,12 @@ def setup(server):
time.sleep(1)
@frappe.whitelist()
@jingrow.whitelist()
def get_plans():
return plans("Self Hosted Server")
@frappe.whitelist()
@jingrow.whitelist()
def check_dns(domain, ip):
try:
resolver = Resolver(configure=False)
@ -152,12 +152,12 @@ def check_dns(domain, ip):
return False
@frappe.whitelist()
@jingrow.whitelist()
def options_for_new():
return {"plans": get_plans(), "ssh_key": sshkey()}
@frappe.whitelist()
@jingrow.whitelist()
def create_and_verify_selfhosted(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()
@frappe.whitelist()
@jingrow.whitelist()
def all(server_filter=None): # noqa: C901
if server_filter is None:
server_filter = {"server_type": "", "tag": ""}
@ -125,13 +125,13 @@ def all(server_filter=None): # noqa: C901
return servers
@frappe.whitelist()
@jingrow.whitelist()
def server_tags():
team = get_current_team()
return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Server"}, pluck="tag")
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def get(name):
server = poly_get_pg(["Server", "Database Server"], name)
@ -152,7 +152,7 @@ def get(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def overview(name):
server = poly_get_pg(["Server", "Database Server"], name)
@ -176,21 +176,21 @@ def overview(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def archive(name):
server = poly_get_pg(["Server", "Database Server"], name)
server.drop_server()
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server"])
def get_reclaimable_size(name):
server: Server = frappe.get_pg("Server", name)
return server.agent.get("server/reclaimable-size")
@frappe.whitelist()
@jingrow.whitelist()
def new(server):
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")
@ -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}
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def usage(name):
mount_point = get_mount_point(name)
@ -385,7 +385,7 @@ def calculate_swap(name):
return result
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60)
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60)
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60)
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
@redis_cache(ttl=10 * 60)
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}
@frappe.whitelist()
@jingrow.whitelist()
def options():
if not get_current_team(get_pg=True).servers_enabled:
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():
return frappe.db.get_single_value("Press Settings", "autoscale_discount", cache=True)
@frappe.whitelist()
@jingrow.whitelist()
def secondary_server_plans(
name,
cluster=None,
@ -621,7 +621,7 @@ def secondary_server_plans(
return filter_by_roles(plans)
@frappe.whitelist()
@jingrow.whitelist()
def plans(name, cluster=None, platform=None):
# Removed default platform of x86_64;
# 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):
play = frappe.get_pg("Ansible Play", play)
play = play.as_dict()
@ -678,13 +678,13 @@ def play(play):
return play
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def change_plan(name, plan):
poly_get_pg(["Server", "Database Server"], name).change_plan(plan)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def press_jobs(name):
jobs = []
@ -693,7 +693,7 @@ def press_jobs(name):
return jobs
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
jobs = frappe.get_all(
@ -711,7 +711,7 @@ def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return jobs
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def plays(filters=None, order_by=None, limit_start=None, limit_page_length=None):
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")
def get_title_and_cluster(name):
return frappe.db.get_value("Server", name, ["title", "cluster"], as_dict=True)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def groups(name):
server = poly_get_pg(["Server", "Database Server"], name)
@ -741,13 +741,13 @@ def groups(name):
return all_benches(server=server.name)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def reboot(name):
return poly_get_pg(["Server", "Database Server"], name).reboot()
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server", "Database Server"])
def rename(name, title):
pg = poly_get_pg(["Server", "Database Server"], name)
@ -767,7 +767,7 @@ def get_timespan_timegrain(duration: str) -> tuple[int, int]:
return timespan, timegrain
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def benches_are_idle(server: str, access_token: str) -> None:
"""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.whitelist()
@jingrow.whitelist()
@protected(["Server"])
def schedule_auto_scale(
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected(["Server"])
def get_configured_autoscale_triggers(name) -> list[dict[str, float]] | None:
return frappe.db.get_all(

2
press/api/service_health.py
View File

@ -1,7 +1,7 @@
import jingrow
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def service_health():
"""
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.whitelist()
@jingrow.whitelist()
def new(site):
if not hasattr(site, "domain") and not site.get("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
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
jobs = frappe.get_all(
@ -341,7 +341,7 @@ def jobs(filters=None, order_by=None, limit_start=None, limit_page_length=None):
return jobs
@frappe.whitelist()
@jingrow.whitelist()
def job(job):
job = frappe.get_pg("Agent Job", job)
job = job.as_dict()
@ -370,14 +370,14 @@ def job(job):
return job
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def running_jobs(name):
jobs = frappe.get_all("Agent Job", filters={"status": ("in", ("Pending", "Running")), "site": name})
return [job_detail(job.name) for job in jobs]
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def backups(name):
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def get_backup_link(name, backup, file):
try:
@ -431,7 +431,7 @@ def get_backup_link(name, backup, file):
log_error(title="Offsite Backup Response Exception")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def domains(name):
domains = frappe.get_all(
@ -447,7 +447,7 @@ def domains(name):
return domains
@frappe.whitelist()
@jingrow.whitelist()
def activities(filters=None, order_by=None, limit_start=None, limit_page_length=None):
# get all site activity except Backup by Administrator
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
@frappe.whitelist()
@jingrow.whitelist()
def app_details_for_new_public_site():
fields = [
"name",
@ -527,7 +527,7 @@ def app_details_for_new_public_site():
return marketplace_apps
@frappe.whitelist()
@jingrow.whitelist()
def options_for_new(for_bench: str | None = None): # noqa: C901
from press.utils import get_nearest_cluster
@ -720,12 +720,12 @@ def set_bench_and_clusters(version, for_bench):
version.group.clusters = clusters
@frappe.whitelist()
@jingrow.whitelist()
def get_domain():
return frappe.db.get_value("Press Settings", "Press Settings", ["domain"])
@frappe.whitelist()
@jingrow.whitelist()
def get_new_site_options(group: str | None = None):
team = get_current_team()
apps = set()
@ -814,7 +814,7 @@ def get_new_site_options(group: str | None = None):
}
@frappe.whitelist()
@jingrow.whitelist()
def get_site_plans():
plans = Plan.get_plans(
doctype="Site Plan",
@ -921,7 +921,7 @@ def get_plan_details_dict(plan_details):
return plan_details_dict
@frappe.whitelist()
@jingrow.whitelist()
def get_plans(name=None, rg=None):
site_name = name
plans = Plan.get_plans(
@ -997,7 +997,7 @@ def sites_with_recent_activity(sites, limit=3):
return query.run(pluck="site")
@frappe.whitelist()
@jingrow.whitelist()
def all(site_filter=None):
if site_filter is None:
site_filter = {"status": "", "tag": ""}
@ -1078,13 +1078,13 @@ def get_sites_query(site_filter, benches_with_updates):
return sites_query
@frappe.whitelist()
@jingrow.whitelist()
def site_tags():
team = get_current_team()
return frappe.get_all("Press Tag", {"team": team, "doctype_name": "Site"}, pluck="tag")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def get(name):
from frappe.utils.data import time_diff
@ -1197,7 +1197,7 @@ def get(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def check_for_updates(name):
site = frappe.get_pg("Site", name)
@ -1234,7 +1234,7 @@ def check_for_updates(name):
return out
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def installed_apps(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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def available_apps(name):
site = frappe.get_pg("Site", name)
@ -1412,7 +1412,7 @@ def is_prepaid_marketplace_app(app):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def current_plan(name):
from press.api.analytics import get_current_cpu_usage
@ -1461,13 +1461,13 @@ def current_plan(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def change_plan(name, plan):
frappe.get_pg("Site", name).set_plan(plan)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def change_auto_update(name, auto_update_enabled):
# 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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def deactivate(name):
frappe.get_pg("Site", name).deactivate()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def activate(name):
frappe.get_pg("Site", name).activate()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def login(name, reason=None):
return {"sid": frappe.get_pg("Site", name).login(reason), "site": name}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def update(name, skip_failing_patches=False, skip_backups=False):
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")
def last_migrate_failed(name):
return frappe.get_pg("Site", name).last_migrate_failed()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def backup(name, with_files=False):
frappe.get_pg("Site", name).backup(with_files)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def archive(name, force):
frappe.get_pg("Site", name).archive(force=force)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def reinstall(name):
return frappe.get_pg("Site", name).reinstall()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def migrate(name, skip_failing_patches=False):
frappe.get_pg("Site", name).migrate(skip_failing_patches=skip_failing_patches)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def clear_cache(name):
frappe.get_pg("Site", name).clear_site_cache()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def restore(name, files, skip_failing_patches=False):
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def validate_restoration_space_requirements(
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)
def exists(subdomain, domain):
from press.press.doctype.site.site import Site
@ -1610,84 +1610,84 @@ def exists(subdomain, domain):
return Site.exists(subdomain, domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def setup_wizard_complete(name):
return frappe.get_pg("Site", name).is_setup_wizard_complete()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def check_dns(name, domain):
return check_dns_cname_a(name, domain)
@frappe.whitelist()
@jingrow.whitelist()
def domain_exists(domain):
return frappe.db.get_value("Site Domain", domain.lower(), "site")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def add_domain(name, domain):
frappe.get_pg("Site", name).add_domain(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def remove_domain(name, domain):
frappe.get_pg("Site", name).remove_domain(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def retry_add_domain(name, domain):
frappe.get_pg("Site", name).retry_add_domain(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def set_host_name(name, domain):
frappe.get_pg("Site", name).set_host_name(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def set_redirect(name, domain):
frappe.get_pg("Site", name).set_redirect(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def unset_redirect(name, domain):
frappe.get_pg("Site", name).unset_redirect(domain)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def install_app(name, app, plan=None):
frappe.get_pg("Site", name).install_app(app, plan)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def uninstall_app(name, app):
frappe.get_pg("Site", name).uninstall_app(app)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def logs(name):
return frappe.get_pg("Site", name).server_logs
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def log(name, log):
return frappe.get_pg("Site", name).get_server_log(log)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def site_config(name):
site = frappe.get_pg("Site", name)
@ -1702,7 +1702,7 @@ def site_config(name):
return config
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def update_config(name, 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))
@frappe.whitelist()
@jingrow.whitelist()
def get_trial_plan():
return frappe.db.get_value("Press Settings", None, "press_trial_plan")
@frappe.whitelist()
@jingrow.whitelist()
def get_upload_link(file, parts=1):
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
@ -1777,7 +1777,7 @@ def get_upload_link(file, parts=1):
log_error("Failed to Generate Presigned URL", content=e)
@frappe.whitelist()
@jingrow.whitelist()
def multipart_exit(file, id, action, parts=None):
bucket_name = frappe.db.get_single_value("Press Settings", "remote_uploads_bucket")
s3_client = client(
@ -1805,7 +1805,7 @@ def multipart_exit(file, id, action, parts=None):
return response
@frappe.whitelist()
@jingrow.whitelist()
def uploaded_backup_info(file=None, path=None, type=None, size=None, url=None):
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
@frappe.whitelist()
@jingrow.whitelist()
def get_backup_links(url, email, password):
try:
files = get_frappe_backups(url, email, password)
@ -1843,7 +1843,7 @@ def get_backup_links(url, email, password):
return remote_files
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def enable_auto_update(name):
site_pg = frappe.get_pg("Site", name)
@ -1852,7 +1852,7 @@ def enable_auto_update(name):
site_pg.save()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def disable_auto_update(name):
site_pg = frappe.get_pg("Site", name)
@ -1861,13 +1861,13 @@ def disable_auto_update(name):
site_pg.save()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def get_auto_update_info(name):
return frappe.get_pg("Site", name).get_auto_update_info()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def update_auto_update_info(name, info=None):
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()
@frappe.whitelist()
@jingrow.whitelist()
def get_job_status(job_name):
return {"status": frappe.db.get_value("Agent Job", job_name, "status")}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def send_change_team_request(name, 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):
from frappe import _
@ -1937,7 +1937,7 @@ def confirm_site_transfer(key: str):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def add_server_to_release_group(name, group_name, server=None):
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")
@frappe.whitelist()
@jingrow.whitelist()
def validate_group_for_upgrade(name, group_name):
server = frappe.db.get_value("Site", name, "server")
rg = frappe.get_pg("Release Group", group_name)
@ -1975,7 +1975,7 @@ def validate_group_for_upgrade(name, group_name):
return True
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@role_guard.document(
document_type=lambda _: "Release Group",
@ -2014,7 +2014,7 @@ def change_group_options(name, release_groups=None):
return query.run(as_dict=True)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def clone_group(name: str, new_group_title: str, server: str | None = None):
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")
def change_group(name, group, skip_failing_patches=False):
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def change_region_options(name):
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")
def change_region(name, cluster, scheduled_datetime=None, skip_failing_patches=False):
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()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
@role_guard.document(
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)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def version_upgrade(
name, destination_group, scheduled_datetime=None, skip_failing_patches=False, skip_backups=False
@ -2196,7 +2196,7 @@ def version_upgrade(
version_upgrade.start()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def change_server_options(name):
site = Site("Site", name)
@ -2210,7 +2210,7 @@ def change_server_options(name):
}
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def is_server_added_in_group(name, server):
site_group = frappe.get_value("Site", name, "group")
@ -2220,7 +2220,7 @@ def is_server_added_in_group(name, server):
return True
@frappe.whitelist()
@jingrow.whitelist()
@protected("Site")
def change_server(name, server, scheduled_datetime=None, skip_failing_patches=False):
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()
@frappe.whitelist()
@jingrow.whitelist()
def get_site_config_standard_keys():
return frappe.get_all(
"Site Config Key",
@ -2267,7 +2267,7 @@ def get_site_config_standard_keys():
)
@frappe.whitelist()
@jingrow.whitelist()
def fetch_sites_data_for_export():
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
@frappe.whitelist(allow_guest=True, methods="POST")
@jingrow.whitelist(allow_guest=True, methods="POST")
def create_snapshot(name: str, key: str):
"""
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
@frappe.whitelist(allow_guest=True, methods=["POST"])
@jingrow.whitelist(allow_guest=True, methods=["POST"])
def sync_product_site_user(**data):
"""
Sync user info from product site
@ -61,7 +61,7 @@ def sync_product_site_user(**data):
).insert(ignore_permissions=True)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=10, seconds=60)
@disabled
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)
def send_otp(email: str):
"""
@ -112,7 +112,7 @@ def send_otp(email: str):
return session.send_otp()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
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)
@disabled
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()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60)
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
@frappe.whitelist()
@jingrow.whitelist()
def spaces(space_filter: Dict | None) -> Dict:
"""
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():
"""
Returns the domain for code servers
@ -53,7 +53,7 @@ def code_server_domain():
return frappe.db.get_single_value("Press Settings", "spaces_domain")
@frappe.whitelist()
@jingrow.whitelist()
def code_server_group_options():
return frappe.get_all(
"Release Group",
@ -67,7 +67,7 @@ def code_server_group_options():
)
@frappe.whitelist()
@jingrow.whitelist()
def code_server_bench_options(group):
valid_candidates = frappe.get_all(
"Deploy Candidate",
@ -91,38 +91,38 @@ def code_server_bench_options(group):
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Code Server")
def code_server(name):
return frappe.get_pg("Code Server", name)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Code Server")
def stop_code_server(name) -> None:
frappe.get_pg("Code Server", name).stop()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Code Server")
def start_code_server(name) -> None:
frappe.get_pg("Code Server", name).start()
@frappe.whitelist()
@jingrow.whitelist()
def code_server_password(name) -> str:
if get_current_team() != frappe.db.get_value("Code Server", name, "team"):
frappe.throw("Not allowed", frappe.PermissionError)
return frappe.utils.password.get_decrypted_password("Code Server", name, "password")
@frappe.whitelist()
@jingrow.whitelist()
@protected("Code Server")
def drop_code_server(name) -> None:
frappe.get_pg("Code Server", name).archive()
@frappe.whitelist()
@jingrow.whitelist()
def create_code_server(subdomain, domain, bench) -> str:
"""
Create a new code server pg
@ -143,7 +143,7 @@ def create_code_server(subdomain, domain, bench) -> str:
return code_server.name
@frappe.whitelist()
@jingrow.whitelist()
def exists(subdomain, domain) -> bool:
"""
Checks if a subdomain is already taken
@ -161,7 +161,7 @@ def exists(subdomain, domain) -> bool:
)
@frappe.whitelist()
@jingrow.whitelist()
@protected("Code Server")
def code_server_jobs(
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
@frappe.whitelist(allow_guest=True, xss_safe=True)
@jingrow.whitelist(allow_guest=True, xss_safe=True)
def hook(*args, **kwargs):
try:
# 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
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def available_events():
return frappe.get_all(
"Press Webhook Event",
@ -21,7 +21,7 @@ def available_events():
)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.document(document_type=lambda _: "Press Webhook")
def add(endpoint: str, secret: str, events: list[str]):
pg = frappe.new_pg("Press Webhook")
@ -33,7 +33,7 @@ def add(endpoint: str, secret: str, events: list[str]):
pg.save()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Press Webhook")
@role_guard.document(document_type=lambda _: "Press Webhook")
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()
@frappe.whitelist()
@jingrow.whitelist()
@protected("Press Webhook")
@role_guard.document(document_type=lambda _: "Press Webhook Log")
def attempts(webhook: str):
@ -73,7 +73,7 @@ def attempts(webhook: str):
return query.run(as_dict=1)
@frappe.whitelist()
@jingrow.whitelist()
@role_guard.document(document_type=lambda _: "Press Webhook Attempt")
def attempt(name: str):
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):
@frappe.whitelist()
@jingrow.whitelist()
def allocate_credits(self):
# Credits have already been 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,
)
@frappe.whitelist()
@jingrow.whitelist()
def start_investigation(self):
if self.status == "Pending":
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 agent_job.status == "Success"
@frappe.whitelist()
@jingrow.whitelist()
def remove_build_from_deploy_candidate(self, build: str):
"""
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.commit()
@frappe.whitelist()
@jingrow.whitelist()
def retry(self):
server: Server = frappe.get_pg("Server", self.server)
server.collect_arm_images()
self.delete(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def cancel_all_jobs(self):
"""Cancel all current running jobs"""
self.sync_status()
@ -109,7 +109,7 @@ class ARMBuildRecord(Document):
self.sync_status()
@frappe.whitelist()
@jingrow.whitelist()
def pull_images(self):
"""Pull images on app server using image tags"""
builds = []
@ -125,7 +125,7 @@ class ARMBuildRecord(Document):
)
self._pull_images(image_tags)
@frappe.whitelist()
@jingrow.whitelist()
def update_image_tags_on_benches(self):
"""
This step replaces the image tags on the app server itself.
@ -139,7 +139,7 @@ class ARMBuildRecord(Document):
)
self._update_image_tags_on_benches()
@frappe.whitelist()
@jingrow.whitelist()
def sync_status(self):
for arm_image in self.arm_images:
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):
self.set_inventory()
@frappe.whitelist()
@jingrow.whitelist()
def run(self):
frappe.only_for("System Manager")
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()
return False
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
if not self.get_lock():
return
@ -527,7 +527,7 @@ class VirtualDiskResize(Document):
self.old_volume_status = "Deleted"
return StepStatus.Success
@frappe.whitelist()
@jingrow.whitelist()
def propagate_volume_id(self) -> StepStatus:
"Propagate volume id"
machine = self.machine
@ -605,7 +605,7 @@ class VirtualDiskResize(Document):
self.duration = (self.end - self.start).total_seconds()
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self, ignore_version=False) -> None:
self.status = Status.Running
self.save(ignore_version=ignore_version)
@ -625,7 +625,7 @@ class VirtualDiskResize(Document):
at_front=True,
)
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self) -> None:
# Mark all failed and skipped steps as pending
for step in self.steps:
@ -633,7 +633,7 @@ class VirtualDiskResize(Document):
step.status = StepStatus.Pending
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self) -> None:
# Mark all pending steps as failure
for step in self.steps:
@ -649,7 +649,7 @@ class VirtualDiskResize(Document):
return step
return None
@frappe.whitelist()
@jingrow.whitelist()
def execute_step(self, 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.Failure
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
self.status = "Running"
self.start = frappe.utils.now_datetime()
@ -598,7 +598,7 @@ class VirtualMachineMigration(Document):
self.duration = (self.end - self.start).total_seconds()
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self, ignore_version=False) -> None:
self.status = "Running"
self.save(ignore_version=ignore_version)
@ -618,7 +618,7 @@ class VirtualMachineMigration(Document):
at_front=True,
)
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self) -> None:
# Mark all failed and skipped steps as pending
for step in self.steps:
@ -626,7 +626,7 @@ class VirtualMachineMigration(Document):
step.status = "Pending"
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self) -> None:
# Mark all pending steps as failure
for step in self.steps:
@ -641,7 +641,7 @@ class VirtualMachineMigration(Document):
return step
return None
@frappe.whitelist()
@jingrow.whitelist()
def execute_step(self, 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))
return StepStatus.Success
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
self.status = "Running"
self.start = frappe.utils.now_datetime()
@ -257,7 +257,7 @@ class VirtualMachineReplacement(Document):
self.duration = (self.end - self.start).total_seconds()
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self, ignore_version=False) -> None:
self.status = "Running"
self.save(ignore_version=ignore_version)
@ -277,7 +277,7 @@ class VirtualMachineReplacement(Document):
at_front=True,
)
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self) -> None:
# Mark all failed and skipped steps as pending
for step in self.steps:
@ -285,7 +285,7 @@ class VirtualMachineReplacement(Document):
step.status = "Pending"
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self) -> None:
# Mark all pending steps as failure
for step in self.steps:
@ -300,7 +300,7 @@ class VirtualMachineReplacement(Document):
return step
return None
@frappe.whitelist()
@jingrow.whitelist()
def execute_step(self, 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)
@frappe.whitelist()
@jingrow.whitelist()
def activate(self):
if self.status == "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
@frappe.whitelist()
@jingrow.whitelist()
def upload_file():
files = frappe.request.files
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.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def send_verification_email(self): # noqa: C901
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
# end: auto-generated types
@frappe.whitelist()
@jingrow.whitelist()
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
subs = frappe.get_all(

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

@ -249,7 +249,7 @@ class AgentJob(Document):
)
pg.insert()
@frappe.whitelist()
@jingrow.whitelist()
def retry(self):
return frappe.get_pg(
{
@ -269,12 +269,12 @@ class AgentJob(Document):
}
).insert()
@frappe.whitelist()
@jingrow.whitelist()
def retry_in_place(self):
self.enqueue_http_request()
frappe.db.commit()
@frappe.whitelist()
@jingrow.whitelist()
def get_status(self):
agent = Agent(self.server, server_type=self.server_type)
@ -287,7 +287,7 @@ class AgentJob(Document):
update_job(self.name, polled_job)
update_steps(self.name, polled_job)
@frappe.whitelist()
@jingrow.whitelist()
def retry_skip_failing_patches(self):
# Add the skip flag and update request data
updated_request_data = json.loads(self.request_data) if self.request_data else {}
@ -296,23 +296,23 @@ class AgentJob(Document):
return self.retry()
@frappe.whitelist()
@jingrow.whitelist()
def succeed_and_process_job_updates(self):
self.status = "Success"
self.save()
self.process_job_updates()
@frappe.whitelist()
@jingrow.whitelist()
def fail_and_process_job_updates(self):
self.status = "Failure"
self.save()
self.process_job_updates()
@frappe.whitelist()
@jingrow.whitelist()
def process_job_updates(self):
process_job_updates(self.name)
@frappe.whitelist()
@jingrow.whitelist()
def cancel_job(self):
agent = Agent(self.server, server_type=self.server_type)
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:
self.append("servers", {"server": server, "server_type": "Proxy Server", "status": "Draft"})
@frappe.whitelist()
@jingrow.whitelist()
def split_updates(self, no_of_batches: int):
if self.status != "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.whitelist()
@jingrow.whitelist()
def create_execution_plan(self):
frappe.enqueue_pg(
self.doctype,
@ -360,12 +360,12 @@ class AgentUpdate(Document):
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def pause(self):
self.status = "Paused"
self.save(ignore_version=True)
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
if self._process_next_step():
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())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def show_plausible_password(self):
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.whitelist()
@jingrow.whitelist()
def execute_command(pg):
frappe.enqueue(
"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):
self.patch_app(revert=True)
@frappe.whitelist()
@jingrow.whitelist()
def delete_patch(self):
if self.status != "Not Applied":
frappe.throw(
@ -146,7 +146,7 @@ class AppPatch(Document):
app_patch.save()
@frappe.whitelist()
@jingrow.whitelist()
def revert_all_patches(self):
# TODO: Agent job: git reset RELEASE_COMMIT --hard
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 f"{self.get_source().repository_url}/commit/{self.hash}"
@frappe.whitelist()
@jingrow.whitelist()
def clone(self):
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):
shutil.rmtree(self.clone_directory)
@frappe.whitelist()
@jingrow.whitelist()
def cleanup(self):
self.on_trash()
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",
)
@frappe.whitelist()
@jingrow.whitelist()
def start_screening(self):
self.release = frappe.get_pg("App Release", self.app_release, for_update=True)
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.create_release()
@frappe.whitelist()
@jingrow.whitelist()
def create_release(
self,
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":
self.execute_scale_steps()
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self):
self.execute_scale_steps()

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

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

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

@ -56,7 +56,7 @@ class BuildMetric(Document):
)
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def get_metrics(self):
"""Retrigger 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:
frappe.delete_pg("Virtual Machine", machine)
@frappe.whitelist()
@jingrow.whitelist()
def add_images(self):
if self.images_available == 1:
frappe.throw("Images are already available", frappe.ValidationError)
@ -737,7 +737,7 @@ class Cluster(Document):
frappe.db.commit()
yield from copies
@frappe.whitelist()
@jingrow.whitelist()
def create_proxy(self):
"""Creates a proxy server for the cluster"""
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)
@frappe.whitelist()
@jingrow.whitelist()
def create_servers(self):
"""Creates servers for the cluster"""
if self.images_available < 1:
@ -805,7 +805,7 @@ class Cluster(Document):
"""
return True
@frappe.whitelist()
@jingrow.whitelist()
def check_machine_availability(self, machine_type: str) -> bool:
"Check availability of machine in the region before allowing provision"
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):
self.setup()
@frappe.whitelist()
@jingrow.whitelist()
def setup(self):
try:
create_dns_record(pg=self, record_name=self.name)
@ -69,7 +69,7 @@ class CodeServer(Document):
except Exception as e:
log_error(title="Setup Code Server Failed", data=e)
@frappe.whitelist()
@jingrow.whitelist()
def stop(self):
try:
self.status = "Pending"
@ -78,7 +78,7 @@ class CodeServer(Document):
except Exception as e:
log_error(title="Stop Code Server Failed", data=e)
@frappe.whitelist()
@jingrow.whitelist()
def start(self):
try:
self.status = "Pending"
@ -89,7 +89,7 @@ class CodeServer(Document):
except Exception as e:
log_error(title="Start Code Server Failed", data=e)
@frappe.whitelist()
@jingrow.whitelist()
def archive(self):
try:
self.status = "Pending"

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

@ -470,7 +470,7 @@ class DatabaseServer(BaseServer):
if restart:
self._restart_mariadb()
@frappe.whitelist()
@jingrow.whitelist()
def restart_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_restart_mariadb")
@ -488,7 +488,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure":
log_error("MariaDB Restart Error", server=self.name)
@frappe.whitelist()
@jingrow.whitelist()
def stop_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_stop_mariadb", timeout=1800)
@ -506,11 +506,11 @@ class DatabaseServer(BaseServer):
if play.status == "Failure":
log_error("MariaDB Stop Error", server=self.name)
@frappe.whitelist()
@jingrow.whitelist()
def run_upgrade_mariadb_job(self):
self.run_press_job("Upgrade MariaDB")
@frappe.whitelist()
@jingrow.whitelist()
def upgrade_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb", timeout=1800)
@ -528,7 +528,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure":
log_error("MariaDB Upgrade Error", server=self.name)
@frappe.whitelist()
@jingrow.whitelist()
def update_mariadb(self):
frappe.enqueue_pg(self.doctype, self.name, "_update_mariadb", timeout=1800)
@ -546,7 +546,7 @@ class DatabaseServer(BaseServer):
if play.status == "Failure":
log_error("MariaDB Update Error", server=self.name)
@frappe.whitelist()
@jingrow.whitelist()
def upgrade_mariadb_patched(self):
frappe.enqueue_pg(self.doctype, self.name, "_upgrade_mariadb_patched", timeout=1800)
@ -789,7 +789,7 @@ class DatabaseServer(BaseServer):
inventory = f"{self.ip},"
return AnsibleAdHoc(sources=inventory).run(command, self.name)[0]
@frappe.whitelist()
@jingrow.whitelist()
def setup_essentials(self):
"""Setup missing essentials after server setup"""
config = self._get_config()
@ -942,7 +942,7 @@ class DatabaseServer(BaseServer):
if primary.status == "Active":
self._setup_secondary()
@frappe.whitelist()
@jingrow.whitelist()
def setup_replication(self):
if self.is_primary:
return
@ -950,7 +950,7 @@ class DatabaseServer(BaseServer):
self.save()
frappe.enqueue_pg(self.doctype, self.name, "_setup_replication", queue="long", timeout=18000)
@frappe.whitelist()
@jingrow.whitelist()
def perform_physical_backup(self, path):
if not path:
frappe.throw("Provide a path to store the physical backup")
@ -1013,7 +1013,7 @@ class DatabaseServer(BaseServer):
server.database_server = self.name
server.save()
@frappe.whitelist()
@jingrow.whitelist()
def trigger_failover(self):
if self.is_primary:
return
@ -1049,7 +1049,7 @@ class DatabaseServer(BaseServer):
log_error("Database Server Conversion Exception", server=self.as_dict())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def convert_from_frappe_server(self):
self.status = "Installing"
self.save()
@ -1074,7 +1074,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("Exporters Install Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def reset_root_password(self):
if self.is_primary:
self.reset_root_password_primary()
@ -1106,7 +1106,7 @@ class DatabaseServer(BaseServer):
def get_replication_status(self):
return self.agent.get_replication_status(self)
@frappe.whitelist()
@jingrow.whitelist()
def sync_replication_config(self):
data = self.get_replication_status()
if not data.get("success"):
@ -1239,7 +1239,7 @@ class DatabaseServer(BaseServer):
if not data.get("success"):
frappe.throw(data.get("message", "Failed to stop replication"))
@frappe.whitelist()
@jingrow.whitelist()
def setup_deadlock_logger(self):
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())
return None
@frappe.whitelist()
@jingrow.whitelist()
def setup_pt_stalk(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_pt_stalk", queue="long", timeout=1200)
@ -1313,7 +1313,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("Percona Stalk Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_logrotate(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_logrotate", queue="long", timeout=1200)
@ -1326,7 +1326,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("Logrotate Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def provide_frappe_user_du_and_find_permission(self):
frappe.enqueue_pg(
self.doctype, self.name, "_provide_frappe_user_du_and_find_permission", queue="long", timeout=1200
@ -1344,7 +1344,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("MariaDB Provide Frappe User DU Permission Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_mariadb_debug_symbols(self):
frappe.enqueue_pg(
self.doctype, self.name, "_setup_mariadb_debug_symbols", queue="long", timeout=1200
@ -1362,7 +1362,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("MariaDB Debug Symbols Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def fetch_stalks(self):
frappe.enqueue(
"press.press.doctype.mariadb_stalk.mariadb_stalk.fetch_server_stalks",
@ -1508,7 +1508,7 @@ class DatabaseServer(BaseServer):
int(self.ram_for_mariadb * 0.65),
)
@frappe.whitelist()
@jingrow.whitelist()
def adjust_memory_config(self): # noqa: C901
if not self.ram:
return
@ -1570,7 +1570,7 @@ class DatabaseServer(BaseServer):
"innodb_force_recovery", "value_str", str(value), skip=False, persist=True, save=True
)
@frappe.whitelist()
@jingrow.whitelist()
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_enabled = read_only_mode_value in (1, "1", "ON")
@ -1580,7 +1580,7 @@ class DatabaseServer(BaseServer):
else:
self.enable_read_only_mode()
@frappe.whitelist()
@jingrow.whitelist()
def enable_read_only_mode(self, update_variables_synchronously: bool = False):
"""Enable read-only mode for the database server"""
self.add_or_update_mariadb_variable(
@ -1593,7 +1593,7 @@ class DatabaseServer(BaseServer):
update_variables_synchronously=update_variables_synchronously,
)
@frappe.whitelist()
@jingrow.whitelist()
def disable_read_only_mode(self, update_variables_synchronously: bool = False):
"""Disable read-only mode for the database server"""
self.add_or_update_mariadb_variable(
@ -1606,7 +1606,7 @@ class DatabaseServer(BaseServer):
update_variables_synchronously=update_variables_synchronously,
)
@frappe.whitelist()
@jingrow.whitelist()
def reconfigure_mariadb_exporter(self):
frappe.enqueue_pg(
self.doctype, self.name, "_reconfigure_mariadb_exporter", queue="long", timeout=1200
@ -1629,7 +1629,7 @@ class DatabaseServer(BaseServer):
except Exception:
log_error("Database Server MariaDB Exporter Reconfigure Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def update_memory_allocator(self, memory_allocator):
frappe.enqueue_pg(
self.doctype,
@ -1703,7 +1703,7 @@ class DatabaseServer(BaseServer):
binlogs = sorted(binlogs, key=lambda x: x["modified_at"], reverse=True)
return [binlog for binlog in binlogs if binlog.get("name") != current_binlog]
@frappe.whitelist()
@jingrow.whitelist()
def get_binlog_summary(self):
binlogs_in_disk = self.get_binlogs_raw_data().get("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:
log_error("Set MariaDB Mount Dependency Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def update_database_schema_sizes(self):
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)
@frappe.whitelist()
@jingrow.whitelist()
def build(
self,
no_push: bool = False,
@ -234,7 +234,7 @@ class DeployCandidate(Document):
deploy_candidate_build.insert()
return dict(error=False, message=deploy_candidate_build.name)
@frappe.whitelist()
@jingrow.whitelist()
def schedule_build_and_deploy(
self,
run_now: bool = True,
@ -659,7 +659,7 @@ def ansi_escape(text):
return ansi_escape.sub("", text)
@frappe.whitelist()
@jingrow.whitelist()
def desk_app(doctype, txt, searchfield, start, page_len, filters):
return frappe.get_all(
"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")
@frappe.whitelist()
@jingrow.whitelist()
def toggle_builds(suspend):
frappe.only_for("System Manager")
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()
@frappe.whitelist()
@jingrow.whitelist()
def deploy(self):
try:
return dict(
@ -1247,7 +1247,7 @@ class DeployCandidateBuild(Document):
except Exception:
log_error("Deploy Creation Error", pg=self)
@frappe.whitelist()
@jingrow.whitelist()
def redeploy(self, no_cache: bool = False):
deploy_candidate: DeployCandidate | None = self.candidate.get_duplicate_dc()
if not deploy_candidate:
@ -1256,7 +1256,7 @@ class DeployCandidateBuild(Document):
deploy_candidate_build_name = deploy_candidate.build_and_deploy(no_cache=no_cache)
return dict(error=False, message=deploy_candidate_build_name)
@frappe.whitelist()
@jingrow.whitelist()
def cleanup_build_directory(self):
if not self.build_directory:
return
@ -1268,7 +1268,7 @@ class DeployCandidateBuild(Document):
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def stop_and_fail(dn: str):
# We can avoid lock here in testing it did not raise a timestamp mismatch error.
build: DeployCandidateBuild = frappe.get_pg("Deploy Candidate Build", dn)
@ -1276,7 +1276,7 @@ def stop_and_fail(dn: str):
build._stop_and_fail()
@frappe.whitelist()
@jingrow.whitelist()
def fail_and_redeploy(dn: str):
stop_and_fail(dn)
@ -1285,7 +1285,7 @@ def fail_and_redeploy(dn: str):
return build.redeploy()
@frappe.whitelist()
@jingrow.whitelist()
def redeploy(dn: str) -> dict[str, str | bool]:
"""Allow redeploy preserving app sources if the deploy is in terminal stage"""
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()
@frappe.whitelist()
@jingrow.whitelist()
def fail_remote_job(dn: str) -> bool:
agent_job: "AgentJob" = frappe.get_pg(
"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):
frappe.only_for("Desk User")
@frappe.whitelist()
@jingrow.whitelist()
def fetch_report(self):
frappe.only_for("Desk User")
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()
log_error("Drip Email Error", drip_email=self.name, site=site)
@frappe.whitelist()
@jingrow.whitelist()
def send_test_email(self, site: str, email: str):
"""Send test email to the given email address."""
self.send_drip_email(site, email)
@ -267,7 +267,7 @@ def send_welcome_email():
welcome_email.send(site)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
@rate_limit(limit=5, seconds=60 * 60)
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.save()
@frappe.whitelist()
@jingrow.whitelist()
def regather_info_and_screenshots(self):
self.identify_affected_resource()
self.identify_problem()
@ -392,7 +392,7 @@ class Incident(WebsiteGenerator):
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def reboot_database_server(self):
db_server_name = frappe.db.get_value("Server", self.server, "database_server")
if not db_server_name:
@ -405,7 +405,7 @@ class Incident(WebsiteGenerator):
self.add_likely_cause("Rebooted database server.")
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def cancel_stuck_jobs(self):
"""
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):
self.likely_cause = self.likely_cause + cause + "\n" if self.likely_cause else cause + "\n"
@frappe.whitelist()
@jingrow.whitelist()
def restart_down_benches(self):
"""
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]:
return self.monitor_server.get_sites_down_for_server(str(self.server))
@frappe.whitelist()
@jingrow.whitelist()
def get_down_site(self):
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):
frappe.only_for("Desk User")
@frappe.whitelist()
@jingrow.whitelist()
def fetch(self):
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.apply_taxes_if_applicable()
@frappe.whitelist()
@jingrow.whitelist()
def finalize_invoice(self): # noqa: C901
if self.type == "Prepaid Credits":
return
@ -501,7 +501,7 @@ class Invoice(Document):
period_string = f"{start.strftime('%b %d')} - {end.strftime('%b %d')} {end.year}"
return f"Frappe Cloud Subscription ({period_string})"
@frappe.whitelist()
@jingrow.whitelist()
def finalize_stripe_invoice(self):
stripe = get_stripe()
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"
)
@frappe.whitelist()
@jingrow.whitelist()
def create_invoice_on_frappeio(self): # noqa: C901
if self.flags.skip_frappe_invoice:
return None
@ -894,7 +894,7 @@ class Invoice(Document):
data={"invoice": self.name, "traceback": traceback},
)
@frappe.whitelist()
@jingrow.whitelist()
def fetch_invoice_pdf(self):
if self.frappe_invoice:
from urllib.parse import urlencode
@ -993,7 +993,7 @@ class Invoice(Document):
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def fetch_mpesa_invoice_pdf(self):
if not (self.mpesa_payment_record and self.mpesa_invoice):
return
@ -1034,7 +1034,7 @@ class Invoice(Document):
except Exception as e:
frappe.log_error(str(e), "Error fetching Sales Invoice PDF on external site")
@frappe.whitelist()
@jingrow.whitelist()
def refund(self, reason):
stripe = get_stripe()
charge = None
@ -1054,7 +1054,7 @@ class Invoice(Document):
self.save()
self.add_comment(text=f"Refund reason: {reason}")
@frappe.whitelist()
@jingrow.whitelist()
def change_stripe_invoice_status(self, status):
stripe = get_stripe()
if status == "Paid":
@ -1064,7 +1064,7 @@ class Invoice(Document):
elif status == "Void":
stripe.Invoice.void_invoice(self.stripe_invoice_id)
@frappe.whitelist()
@jingrow.whitelist()
def refresh_stripe_payment_link(self):
stripe = get_stripe()
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())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def show_kibana_password(self):
return self.get_password("kibana_password")
@frappe.whitelist()
@jingrow.whitelist()
def install_elasticsearch_exporter(self):
frappe.enqueue_pg(
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)
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
if self.stage_status == "Running":
frappe.msgprint("Replication is already in Running state. It will be executed soon.")
@ -1011,7 +1011,7 @@ class LogicalReplicationBackup(Document):
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self) -> None:
if self.stage_status != "Running" and self.stage_status not in ("Success", "Failure"):
self.stage_status = "Running"
@ -1043,7 +1043,7 @@ class LogicalReplicationBackup(Document):
timeout=600,
)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def retry(self):
# Reset the states
self.stage_status = "Pending"
@ -1055,7 +1055,7 @@ class LogicalReplicationBackup(Document):
step.status = "Pending"
self.save(ignore_version=True)
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self) -> None:
# Mark all failed and skipped steps as pending
for step in self.current_execution_steps:
@ -1067,7 +1067,7 @@ class LogicalReplicationBackup(Document):
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self) -> None:
# Mark all pending steps as failure
for step in self.current_execution_steps:
@ -1105,7 +1105,7 @@ class LogicalReplicationBackup(Document):
def is_restoration_steps_successful(self) -> bool:
return all(step.status == "Success" for step in self.current_execution_steps)
@frappe.whitelist()
@jingrow.whitelist()
def execute_step(self, 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.save()
@frappe.whitelist()
@jingrow.whitelist()
def start(self):
self.status = "Pending"
self.save()

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

@ -25,7 +25,7 @@ class ManagedDatabaseService(Document):
pass
@frappe.whitelist()
@jingrow.whitelist()
def show_root_password(self):
frappe.only_for("System Manager")
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()
frappe.delete_pg("Remote File", remote_file)
@frappe.whitelist()
@jingrow.whitelist()
def download_binlog(self):
frappe.enqueue_pg(
"MariaDB Binlog",

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

@ -40,7 +40,7 @@ class MariaDBVariable(Document):
return float(value)
return value
@frappe.whitelist()
@jingrow.whitelist()
def set_on_all_servers(self):
value = self.get_default_value()
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())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def reconfigure_monitor_server(self):
frappe.enqueue_pg(self.doctype, self.name, "_reconfigure_monitor_server", queue="long", timeout=1200)
@ -235,7 +235,7 @@ class MonitorServer(BaseServer):
except Exception:
log_error("Monitoring Server Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def show_grafana_password(self):
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()
@frappe.whitelist()
@jingrow.whitelist()
def add_mount_enabled_server(
self,
server: str,
@ -106,7 +106,7 @@ class NFSServer(BaseServer):
)
return nfs_volume_attachment.insert()
@frappe.whitelist()
@jingrow.whitelist()
def remove_mount_enabled_server(self, server: str) -> NFSVolumeDetachment:
secondary_server = frappe.get_value("Server", server, "secondary_server")
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")
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self):
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:
frappe.throw("Benches are currently running on the secondary server!")
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self):
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.whitelist()
@jingrow.whitelist()
def submit_payment_payout(partner, payment_gateway, from_date, to_date, partner_commission, transactions):
partner = (
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
@frappe.whitelist()
@jingrow.whitelist()
def create_payout_order_from_invoice_items(
invoice_items: List[InvoiceItem],
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 None
@frappe.whitelist()
@jingrow.whitelist()
def sync(self):
self.no_of_sites = len(self.site_backups)
# Check site backup's status
@ -58,12 +58,12 @@ class PhysicalBackupGroup(Document):
)
self.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def set_db_sizes(self):
for site in self.site_backups:
site.set_db_size()
@frappe.whitelist()
@jingrow.whitelist()
def trigger_next_backup(self):
frappe.enqueue_pg(self.doctype, self.name, "_trigger_next_backup", queue="default", at_front=True)
frappe.msgprint("Triggered next backup")
@ -87,7 +87,7 @@ class PhysicalBackupGroup(Document):
enqueue_after_commit=True,
)
@frappe.whitelist()
@jingrow.whitelist()
def retry_failed_backups(self):
for site in self.site_backups:
if site.status == "Failure":
@ -96,19 +96,19 @@ class PhysicalBackupGroup(Document):
site.status = "Pending"
site.save(ignore_permissions=True)
@frappe.whitelist()
@jingrow.whitelist()
def delete_backups(self):
for site in self.site_backups:
site.delete_backup()
@frappe.whitelist()
@jingrow.whitelist()
def activate_all_sites(self):
for site_backup in self.site_backups:
site = frappe.get_pg("Site", site_backup.site)
agent = Agent(site.server)
agent.activate_site(site)
@frappe.whitelist()
@jingrow.whitelist()
def create_duplicate_group(self):
suffix = 2
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"})
self.append("steps", step)
@frappe.whitelist()
@jingrow.whitelist()
def execute(self):
if self.status == "Scheduled":
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.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self) -> None:
if self.status != "Running" and self.status not in ("Success", "Failure"):
self.status = "Running"
@ -686,7 +686,7 @@ class PhysicalBackupRestoration(Document):
job_id=f"physical_restoration||{self.name}||{next_step_to_run.name}",
)
@frappe.whitelist()
@jingrow.whitelist()
def cleanup(self):
is_cleanup_required = False
for step in self.steps:
@ -702,7 +702,7 @@ class PhysicalBackupRestoration(Document):
if is_cleanup_required:
self.next()
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def retry(self):
# Check if all the cleanup steps are completed
for step in self.steps:
@ -722,7 +722,7 @@ class PhysicalBackupRestoration(Document):
step.status = "Pending"
self.save(ignore_version=True)
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self) -> None:
first_failed_step: PhysicalBackupRestorationStep = None
# Mark all failed and skipped steps as pending
@ -737,7 +737,7 @@ class PhysicalBackupRestoration(Document):
self.job = None
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self) -> None:
# Mark all pending steps as failure
for step in self.steps:
@ -771,7 +771,7 @@ class PhysicalBackupRestoration(Document):
# 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)
@frappe.whitelist()
@jingrow.whitelist()
def execute_step(self, 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)
@frappe.whitelist()
@jingrow.whitelist()
def start(self):
self.sync()
record = None
@ -105,12 +105,12 @@ class PhysicalRestorationTest(Document):
self.save()
frappe.throw("No pending restoration found")
@frappe.whitelist()
@jingrow.whitelist()
def sync(self):
for result in self.results:
result.save()
@frappe.whitelist()
@jingrow.whitelist()
def reset_failed_restorations(self):
for result in self.results:
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.save()
@frappe.whitelist()
@jingrow.whitelist()
def next(self, arguments=None):
if 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.whitelist()
@jingrow.whitelist()
def force_continue(self):
for step in frappe.get_all(
"Press Job Step",
@ -125,7 +125,7 @@ class PressJob(Document):
frappe.db.set_value("Press Job Step", step, "status", "Pending")
self.next()
@frappe.whitelist()
@jingrow.whitelist()
def force_fail(self):
for step in frappe.get_all(
"Press Job Step",
@ -172,7 +172,7 @@ class PressJob(Document):
"press_job_update", doctype=self.doctype, docname=self.name, message=self.detail()
)
@frappe.whitelist()
@jingrow.whitelist()
def mark_callback_failure_issue_resolved(self):
self.callback_failure_issue_resolved = True
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
# end: auto-generated types
@frappe.whitelist()
@jingrow.whitelist()
def execute(self): # noqa: C901
if not self.start:
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:
frappe.throw("Minimum rebuild memory needs to be 2 GB or more.")
@frappe.whitelist()
@jingrow.whitelist()
def create_stripe_webhook(self):
stripe = get_stripe()
url = frappe.utils.get_url(
@ -237,7 +237,7 @@ class PressSettings(Document):
self.flags.ignore_mandatory = True
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def get_github_app_manifest(self):
if frappe.conf.developer_mode:
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,
)
@frappe.whitelist()
@jingrow.whitelist()
def route_requests_from_primary_to_secondary(self, step=None):
"""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.save()
@frappe.whitelist()
@jingrow.whitelist()
def force_continue(self):
self.error = None
self.save()

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

@ -154,7 +154,7 @@ class ProxyServer(BaseServer):
except Exception:
log_error("Exporters Install Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_ssh_proxy(self):
if not self.ssh_certificate_authority:
frappe.throw("SSH Certificate Authority is required to setup SSH Proxy")
@ -190,7 +190,7 @@ class ProxyServer(BaseServer):
except Exception:
log_error("SSH Proxy Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_fail2ban(self):
self.status = "Installing"
self.save()
@ -212,7 +212,7 @@ class ProxyServer(BaseServer):
log_error("Fail2ban Setup Exception", server=self.as_dict())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def setup_proxysql(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql", queue="long", timeout=1200)
@ -246,7 +246,7 @@ class ProxyServer(BaseServer):
except Exception:
log_error("ProxySQL Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_replication(self):
self.status = "Installing"
self.save()
@ -303,7 +303,7 @@ class ProxyServer(BaseServer):
log_error("Secondary Proxy Server Setup Exception", server=self.as_dict())
self.save()
@frappe.whitelist()
@jingrow.whitelist()
def trigger_failover(self):
# TODO: should also be automatic based on monitoring/some kind of health check mechanism
if self.is_primary:
@ -319,7 +319,7 @@ class ProxyServer(BaseServer):
return f"Failover Reference: {frappe.get_desk_link(failover.doctype, failover.name)}"
@frappe.whitelist()
@jingrow.whitelist()
def setup_proxysql_monitor(self):
frappe.enqueue_pg(self.doctype, self.name, "_setup_proxysql_monitor", queue="long", timeout=1200)
@ -346,7 +346,7 @@ class ProxyServer(BaseServer):
except Exception:
log_error("ProxySQL Monitor Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def setup_wireguard(self):
if not self.private_ip_interface_id:
play = frappe.get_last_pg("Ansible Play", {"play": "Ping Server", "server": self.name})
@ -395,7 +395,7 @@ class ProxyServer(BaseServer):
except Exception:
log_error("Wireguard Setup Exception", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def reload_wireguard(self):
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.submit()
@frappe.whitelist()
@jingrow.whitelist()
def sync(self):
try:
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)
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def razorpay_authorized_payment_handler():
client = get_razorpay_client()
form_dict = frappe.local.form_dict
@ -92,7 +92,7 @@ def razorpay_authorized_payment_handler():
raise Exception from e
@frappe.whitelist(allow_guest=True)
@jingrow.whitelist(allow_guest=True)
def razorpay_webhook_handler():
client = get_razorpay_client()
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:
log_error("Mirror Registry Prune Failed", server=self.as_dict())
@frappe.whitelist()
@jingrow.whitelist()
def show_registry_password(self):
"""Show registry password"""
frappe.msgprint(self.get_password("registry_password"))
@frappe.whitelist()
@jingrow.whitelist()
def create_registry_mirror(
self,
hostname: str,
@ -204,7 +204,7 @@ class RegistryServer(BaseServer):
except Exception as e:
log_error("Error during mirror config rewrite", e)
@frappe.whitelist()
@jingrow.whitelist()
def rewrite_config(self):
"""Rewrite mirror's config"""
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
return self.get_password("redis_password")
@frappe.whitelist()
@jingrow.whitelist()
def create_duplicate_deploy_candidate(self):
return self.create_deploy_candidate([])
@ -707,7 +707,7 @@ class ReleaseGroup(Document, TagHelpers):
"Please scale down all the server before deploying."
)
@frappe.whitelist()
@jingrow.whitelist()
def create_deploy_candidate(
self,
apps_to_update=None,
@ -847,7 +847,7 @@ class ReleaseGroup(Document, TagHelpers):
return sorted_apps
@frappe.whitelist()
@jingrow.whitelist()
def deploy_information(self):
out = frappe._dict(update_available=False)
last_deployed_bench = get_last_pg(
@ -1459,7 +1459,7 @@ class ReleaseGroup(Document, TagHelpers):
except frappe.DoesNotExistError:
return None
@frappe.whitelist()
@jingrow.whitelist()
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
@ -1503,7 +1503,7 @@ class ReleaseGroup(Document, TagHelpers):
except ImageNotFoundInRegistry:
return self.add_server(server=server, deploy=True, force_new_build=True)
@frappe.whitelist()
@jingrow.whitelist()
def change_server(self, server: str):
"""
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.add_server(server, deploy=True)
@frappe.whitelist()
@jingrow.whitelist()
def update_benches_config(self):
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.create_release(force=True)
@frappe.whitelist()
@jingrow.whitelist()
def archive(self):
benches = frappe.get_all("Bench", filters={"group": self.name, "status": "Active"}, pluck="name")
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):
return self.get_download_link()
@frappe.whitelist()
@jingrow.whitelist()
def exists(self):
self.db_set("status", "Available")
@ -210,7 +210,7 @@ class RemoteFile(Document):
self.db_set("status", "Unavailable")
return False
@frappe.whitelist()
@jingrow.whitelist()
def delete_remote_object(self):
self.db_set("status", "Unavailable")
return self.s3_client.delete_object(
@ -221,7 +221,7 @@ class RemoteFile(Document):
def on_trash(self):
self.delete_remote_object()
@frappe.whitelist()
@jingrow.whitelist()
def get_download_link(self):
return self.url or self.s3_client.generate_presigned_url(
"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
)
@frappe.whitelist()
@jingrow.whitelist()
def add_to_proxies(self):
proxies = frappe.get_all("Proxy Server", {"status": "Active"}, pluck="name")
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):
self.start()
@frappe.whitelist()
@jingrow.whitelist()
def start(self):
self.status = "Pending"
self.save()

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