ramon
/
skillbox
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects 1 Releases 1 Wiki Activity

Add some light logging to login process to see when licenses are created

This commit is contained in:
Ramon Wenger 2023-08-17 16:07:55 +02:00
parent ccdf916e83
commit 67ebcbcaa0
2 changed files with 69 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
server/oauth/user_signup_login_handler.py
View File

@ -1,11 +1,14 @@
from core.logger import get_logger
from oauth.hep_client import HepClient, HepClientException from oauth.hep_client import HepClient, HepClientException
from users.models import License from users.models import License
from users.models import User, UserRole, Role, SchoolClass from users.models import User, UserRole, Role, SchoolClass
EMAIL_NOT_VERIFIED = 'email_not_verified' EMAIL_NOT_VERIFIED = "email_not_verified"
UNKNOWN_ERROR = 'unknown_error' UNKNOWN_ERROR = "unknown_error"
NO_VALID_LICENSE = 'no_valid_license' NO_VALID_LICENSE = "no_valid_license"
logger = get_logger(__name__)
def handle_user_and_verify_products(user_data, token): def handle_user_and_verify_products(user_data, token):
@ -15,6 +18,7 @@ def handle_user_and_verify_products(user_data, token):
try: try:
if not hep_client.is_email_verified(user_data): if not hep_client.is_email_verified(user_data):
logger.info("email not verified")
return user, EMAIL_NOT_VERIFIED return user, EMAIL_NOT_VERIFIED
except HepClientException: except HepClientException:
return user, UNKNOWN_ERROR return user, UNKNOWN_ERROR
@ -22,14 +26,18 @@ def handle_user_and_verify_products(user_data, token):
license = License.objects.get_active_license_for_user(user) license = License.objects.get_active_license_for_user(user)
if not license: if not license:
logger.info("license not found, trying to create")
license, error_msg = check_and_create_licenses(hep_client, user, token) license, error_msg = check_and_create_licenses(hep_client, user, token)
if error_msg: if error_msg:
logger.warn(error_msg)
return user, error_msg return user, error_msg
logger.info("creating role")
create_role_for_user(user, license.for_role.key) create_role_for_user(user, license.for_role.key)
if license and not license.is_valid(): if license and not license.is_valid():
logger.info("license is not valid")
return user, NO_VALID_LICENSE return user, NO_VALID_LICENSE
return user, None return user, None
@ -37,15 +45,23 @@ def handle_user_and_verify_products(user_data, token):
def check_and_create_licenses(hep_client, user, token): def check_and_create_licenses(hep_client, user, token):
try: try:
logger.info("fetching products")
product = hep_client.active_myskillbox_product_for_customer(token_dict=token) product = hep_client.active_myskillbox_product_for_customer(token_dict=token)
except HepClientException: except HepClientException:
return None, UNKNOWN_ERROR return None, UNKNOWN_ERROR
if product: if product:
license = License.objects.create_license_for_role(user, product['activated'], product['raw'], logger.info("product found, creating license")
product['license']['edition'], license = License.objects.create_license_for_role(
product['order_id'], product['isbn']) user,
product["activated"],
product["raw"],
product["license"]["edition"],
product["order_id"],
product["isbn"],
)
else: else:
logger.info("no product found")
return None, NO_VALID_LICENSE return None, NO_VALID_LICENSE
return license, None return license, None
@ -59,4 +75,3 @@ def create_role_for_user(user, role_key):
if SchoolClass.objects.filter(users__in=[user]).count() == 0: if SchoolClass.objects.filter(users__in=[user]).count() == 0:
SchoolClass.create_default_group_for_teacher(user) SchoolClass.create_default_group_for_teacher(user)

76
server/users/managers.py
View File

@ -8,21 +8,25 @@ from django.utils import timezone
from django.utils.translation import gettext_lazy as _ from django.utils.translation import gettext_lazy as _
from django.db import models from django.db import models
from django.contrib.auth.models import UserManager as DjangoUserManager from django.contrib.auth.models import UserManager as DjangoUserManager
from core.logger import get_logger
from users.licenses import get_license_dict from users.licenses import get_license_dict
license_dict = get_license_dict() license_dict = get_license_dict()
logger = get_logger(__name__)
class RoleManager(models.Manager): class RoleManager(models.Manager):
use_in_migrations = True use_in_migrations = True
TEACHER_KEY = 'teacher' TEACHER_KEY = "teacher"
STUDENT_KEY = 'student' STUDENT_KEY = "student"
PARENT_KEY = 'parent' PARENT_KEY = "parent"
DEFAULT_ROLES = { DEFAULT_ROLES = {
TEACHER_KEY: _(u'Lehrperson'), TEACHER_KEY: _("Lehrperson"),
STUDENT_KEY: _(u'Schüler'), STUDENT_KEY: _("Schüler"),
# PARENT_KEY: _(u'Aufsichtsperson'), # PARENT_KEY: _(u'Aufsichtsperson'),
# SCHOOL_ADMIN_KEY: _(u'Schuladministrator') # SCHOOL_ADMIN_KEY: _(u'Schuladministrator')
} }
@ -44,7 +48,7 @@ class RoleManager(models.Manager):
for key, value in self.DEFAULT_ROLES.items(): for key, value in self.DEFAULT_ROLES.items():
role, created = self.get_or_create(name=value, key=key) role, created = self.get_or_create(name=value, key=key)
can_manage_school_class_content, = self._create_default_permissions() (can_manage_school_class_content,) = self._create_default_permissions()
if key == "teacher": if key == "teacher":
role.role_permission.add(can_manage_school_class_content.id) role.role_permission.add(can_manage_school_class_content.id)
@ -67,15 +71,17 @@ class RoleManager(models.Manager):
# edit_own_comments = Permission.objects.get(content_type=content_type, codename="can_edit_own_comments") # edit_own_comments = Permission.objects.get(content_type=content_type, codename="can_edit_own_comments")
# delete_comments = Permission.objects.get(content_type=content_type, codename="can_delete_comments") # delete_comments = Permission.objects.get(content_type=content_type, codename="can_delete_comments")
# admin_school = Permission.objects.get(content_type=content_type, codename="can_admin_school") # admin_school = Permission.objects.get(content_type=content_type, codename="can_admin_school")
can_manage_school_class_content = Permission.objects.get(content_type=content_type, can_manage_school_class_content = Permission.objects.get(
codename='can_manage_school_class_content') content_type=content_type, codename="can_manage_school_class_content"
)
return can_manage_school_class_content, return (can_manage_school_class_content,)
class UserRoleManager(models.Manager): class UserRoleManager(models.Manager):
def get_or_create_role_for_user(self, user, role_key): def get_or_create_role_for_user(self, user, role_key):
from users.models import Role from users.models import Role
try: try:
role = Role.objects.get(key=role_key) role = Role.objects.get(key=role_key)
except Role.DoesNotExist: except Role.DoesNotExist:
@ -94,7 +100,6 @@ class UserRoleManager(models.Manager):
class UserManager(DjangoUserManager): class UserManager(DjangoUserManager):
def _create_user_with_random_password_no_save(self, first_name, last_name, email): def _create_user_with_random_password_no_save(self, first_name, last_name, email):
user, created = self.model.objects.get_or_create(email=email, username=email) user, created = self.model.objects.get_or_create(email=email, username=email)
user.first_name = first_name user.first_name = first_name
@ -105,20 +110,22 @@ class UserManager(DjangoUserManager):
return user return user
def create_user_with_random_password(self, first_name, last_name, email): def create_user_with_random_password(self, first_name, last_name, email):
user = self._create_user_with_random_password_no_save(first_name, last_name, email) user = self._create_user_with_random_password_no_save(
first_name, last_name, email
)
user.save() user.save()
return user return user
def create_user_from_hep(self, user_data): def create_user_from_hep(self, user_data):
try: try:
user = self.model.objects.get(email=user_data['email']) user = self.model.objects.get(email=user_data["email"])
user.set_unusable_password() user.set_unusable_password()
except self.model.DoesNotExist: except self.model.DoesNotExist:
user = self._create_user_with_random_password_no_save(user_data['first_name'], user = self._create_user_with_random_password_no_save(
user_data['last_name'], user_data["first_name"], user_data["last_name"], user_data["email"]
user_data['email']) )
user.hep_id = user_data['id'] user.hep_id = user_data["id"]
user.save() user.save()
# todo: how to handle # todo: how to handle
@ -128,36 +135,48 @@ class UserManager(DjangoUserManager):
return user return user
def get_or_create_hep_user(self, user_data): def get_or_create_hep_user(self, user_data):
try: try:
user = self.get(hep_id=user_data['id']) user = self.get(hep_id=user_data["id"])
logger.info(f"Got user {user.id}")
except self.model.DoesNotExist: except self.model.DoesNotExist:
user = self.create_user_from_hep(user_data) user = self.create_user_from_hep(user_data)
logger.info(f"Created user {user.id}")
return user return user
class LicenseManager(models.Manager): class LicenseManager(models.Manager):
def create_license_for_role(
self, licensee, activation_date, raw, role, order_id, isbn
):
Role = apps.get_model("users", "Role")
expiry_date = activation_date + timedelta(license_dict[isbn]["duration"])
def create_license_for_role(self, licensee, activation_date, raw, role, order_id, isbn): if role == "teacher":
Role = apps.get_model('users', 'Role')
expiry_date = activation_date + timedelta(license_dict[isbn]['duration'])
if role == 'teacher':
user_role = Role.objects.get_default_teacher_role() user_role = Role.objects.get_default_teacher_role()
else: else:
user_role = Role.objects.get_default_student_role() user_role = Role.objects.get_default_student_role()
new_license = self._create_license_for_role(licensee, expiry_date, raw, user_role, order_id, isbn, new_license = self._create_license_for_role(
activation_date) licensee, expiry_date, raw, user_role, order_id, isbn, activation_date
)
new_license.licensee.license_expiry_date = new_license.expire_date new_license.licensee.license_expiry_date = new_license.expire_date
new_license.licensee.save() new_license.licensee.save()
return new_license return new_license
def _create_license_for_role(self, licensee, expiry_date, raw, role, order_id, isbn, activation_date): def _create_license_for_role(
return self.create(licensee=licensee, expire_date=expiry_date, new_api_raw=raw, for_role=role, order_id=order_id, self, licensee, expiry_date, raw, role, order_id, isbn, activation_date
isbn=isbn, hep_created_at=activation_date) ):
return self.create(
licensee=licensee,
expire_date=expiry_date,
new_api_raw=raw,
for_role=role,
order_id=order_id,
isbn=isbn,
hep_created_at=activation_date,
)
def get_active_license_for_user(self, user): def get_active_license_for_user(self, user):
licenses = self.filter(licensee=user, expire_date__gte=timezone.now()).order_by( licenses = self.filter(licensee=user, expire_date__gte=timezone.now()).order_by(
@ -174,4 +193,3 @@ class LicenseManager(models.Manager):
user.save() user.save()
return license return license