Coverage for portality/bll/services/account.py: 75%
85 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 13:43 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 13:43 +0000
1from typing import Optional, Tuple
2import random
4from flask import url_for
6from portality.core import app
7from portality.models import Account
8from portality.bll import exceptions
9from portality.lib.security import Encryption
10from portality.app_email import send_mail
11from portality.ui import templates
13class AccountService:
14 """Business logic for account login and verification."""
16 # Defaults for passwordless login code
17 LOGIN_CODE_LENGTH = 6
18 LOGIN_CODE_TIMEOUT = 600 # seconds (10 minutes)
20 def resolve_user(self, username: str) -> Optional[Account]:
21 """Resolve a user by account id or email, depending on config."""
22 if username is None or username == "":
23 return None
24 if app.config.get('LOGIN_VIA_ACCOUNT_ID', False):
25 return Account.pull(username) or Account.pull_by_email(username)
26 return Account.pull_by_email(username)
28 def initiate_login_code(self, user: Account) -> str:
29 """Generate and persist a passwordless login code for the user; return the code."""
30 if user is None or user.email is None:
31 raise exceptions.ArgumentException("User account is not available for login code.")
32 code = ''.join(str(random.randint(0, 9)) for _ in range(self.LOGIN_CODE_LENGTH))
33 user.set_login_code(code, timeout=self.LOGIN_CODE_TIMEOUT)
34 user.save()
35 return code
37 def send_login_code_email(self, user: Account, code: str, redirected: Optional[str] = "",
38 next_url: Optional[str] = "") -> Optional[str]:
39 """Compose and send the passwordless login email with code and a direct link.
40 next_url, if supplied, is carried in the encrypted token so the link returns the user there after login.
41 """
42 if user is None or not user.email:
43 raise exceptions.ArgumentException("Cannot send login code email: user/email missing")
45 params = {"email": user.email, "code": code}
46 if redirected:
47 params["redirected"] = redirected
48 if next_url:
49 params["next"] = next_url
51 login_url = None
52 try:
53 encrypted = Encryption(app.config.get('PASSWORDLESS_ENCRYPTION_KEY')).encrypt_params(params)
54 login_url = url_for('account.verify_code', token=encrypted, _external=True)
55 except (ValueError, TypeError, Exception) as e:
56 # login_url is mandatory; propagate as an argument/config problem
57 app.logger.error(f"Failed to create encrypted login URL: {e.__class__.__name__}: {str(e)}")
58 raise exceptions.ArgumentException("Invalid encryption key or login url creation error")
60 send_mail(
61 to=[user.email],
62 fro=app.config.get('SYSTEM_EMAIL_FROM'),
63 html_body_flag=True,
64 subject="Your Login Code for DOAJ",
65 template_name=templates.EMAIL_LOGIN_LINK,
66 plaintext_template_name=templates.EMAIL_LOGIN_LINK_PLAINTEXT,
67 code=code,
68 login_url=login_url,
69 expiry_minutes=10
70 )
72 return login_url
74 def verify_password_login(self, user: Account, password: Optional[str]) -> Account:
75 """
76 Check the user's password.
77 Raises IllegalStatusException('no_password') if no password set.
78 Raises IllegalStatusException('incorrect_password') if password does not match.
79 Returns the user on success.
80 """
81 if user is None:
82 raise exceptions.NoSuchObjectException("Account not recognised.")
83 try:
84 if user.check_password(password):
85 return user
86 # wrong password
87 raise exceptions.IllegalStatusException("incorrect_password")
88 except KeyError:
89 # account has no password set
90 raise exceptions.IllegalStatusException("no_password")
92 def parse_login_token(self, encrypted_token: Optional[str]) -> dict:
93 """Decrypt token to params; raise ArgumentException on failure or if not provided."""
94 if not encrypted_token:
95 raise exceptions.ArgumentException("login token is required")
96 try:
97 enc = Encryption(app.config.get('PASSWORDLESS_ENCRYPTION_KEY'))
98 params = enc.decrypt_params(encrypted_token) or {}
99 except ValueError as e:
100 app.logger.error(f"Invalid encryption key: {e.__class__.__name__}: {str(e)}")
101 raise exceptions.ArgumentException("Invalid encryption key")
102 if not isinstance(params, dict) or not params:
103 raise exceptions.ArgumentException("invalid login token")
104 return params
106 def verify_login_code(
107 self,
108 *,
109 encrypted_token: Optional[str] = None,
110 email: Optional[str] = None,
111 code: Optional[str] = None,
112 ) -> Tuple[Account, Optional[str], Optional[str]]:
113 """
114 Verify a login either from an encrypted token or plain email/code.
116 Returns: (account, redirected, next_url)
117 Raises:
118 - exceptions.ArgumentException if params missing
119 - exceptions.NoSuchObjectException if account not found
120 - exceptions.IllegalStatusException if code invalid/expired
121 """
122 params = {}
123 if encrypted_token:
124 params = self.parse_login_token(encrypted_token)
125 tok_email = params.get('email')
126 tok_code = params.get('code')
127 redirected = params.get('redirected')
128 next_url = params.get('next')
129 else:
130 tok_email = email
131 tok_code = code
132 redirected = None
133 next_url = None
135 if not tok_email or not tok_code:
136 raise exceptions.ArgumentException("Required parameters not available.")
138 account = Account.pull_by_email(tok_email)
139 if not account:
140 raise exceptions.NoSuchObjectException("Account not recognised.")
142 if not account.is_login_code_valid(tok_code):
143 raise exceptions.IllegalStatusException("Invalid or expired verification code")
145 # Business state change: clear and persist the code
146 account.remove_login_code()
147 account.save()
149 return account, redirected, next_url