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

1from typing import Optional, Tuple 

2import random 

3 

4from flask import url_for 

5 

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 

12 

13class AccountService: 

14 """Business logic for account login and verification.""" 

15 

16 # Defaults for passwordless login code 

17 LOGIN_CODE_LENGTH = 6 

18 LOGIN_CODE_TIMEOUT = 600 # seconds (10 minutes) 

19 

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) 

27 

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 

36 

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") 

44 

45 params = {"email": user.email, "code": code} 

46 if redirected: 

47 params["redirected"] = redirected 

48 if next_url: 

49 params["next"] = next_url 

50 

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") 

59 

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 ) 

71 

72 return login_url 

73 

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") 

91 

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 

105 

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. 

115 

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 

134 

135 if not tok_email or not tok_code: 

136 raise exceptions.ArgumentException("Required parameters not available.") 

137 

138 account = Account.pull_by_email(tok_email) 

139 if not account: 

140 raise exceptions.NoSuchObjectException("Account not recognised.") 

141 

142 if not account.is_login_code_valid(tok_code): 

143 raise exceptions.IllegalStatusException("Invalid or expired verification code") 

144 

145 # Business state change: clear and persist the code 

146 account.remove_login_code() 

147 account.save() 

148 

149 return account, redirected, next_url