196 lines
6.4 KiB
Python
196 lines
6.4 KiB
Python
from datetime import timedelta
|
|
|
|
from django.apps import apps
|
|
from django.conf import settings
|
|
from django.contrib.auth.models import Permission
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.utils import timezone
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.db import models
|
|
from django.contrib.auth.models import UserManager as DjangoUserManager
|
|
from core.logger import get_logger
|
|
|
|
from users.licenses import get_license_dict
|
|
|
|
license_dict = get_license_dict()
|
|
|
|
logger = get_logger(__name__)
|
|
|
|
|
|
class RoleManager(models.Manager):
|
|
use_in_migrations = True
|
|
|
|
TEACHER_KEY = "teacher"
|
|
STUDENT_KEY = "student"
|
|
PARENT_KEY = "parent"
|
|
|
|
DEFAULT_ROLES = {
|
|
TEACHER_KEY: _("Lehrperson"),
|
|
STUDENT_KEY: _("Schüler"),
|
|
# PARENT_KEY: _(u'Aufsichtsperson'),
|
|
# SCHOOL_ADMIN_KEY: _(u'Schuladministrator')
|
|
}
|
|
|
|
READONLY_ROLES = []
|
|
|
|
DEFAULT_ROLE_KEYS = DEFAULT_ROLES.keys()
|
|
|
|
def is_key_in_defaults(self, key):
|
|
return key in self.DEFAULT_ROLE_KEYS
|
|
|
|
def is_key_readonly(self, key):
|
|
return key in self.READONLY_ROLES
|
|
|
|
def get_roles_for_user(self, user):
|
|
return self.model.objects.filter(user_roles__user=user)
|
|
|
|
def create_default_roles(self):
|
|
for key, value in self.DEFAULT_ROLES.items():
|
|
role, created = self.get_or_create(name=value, key=key)
|
|
|
|
(can_manage_school_class_content,) = self._create_default_permissions()
|
|
|
|
if key == "teacher":
|
|
role.role_permission.add(can_manage_school_class_content.id)
|
|
|
|
def get_default_teacher_role(self):
|
|
return self._get_default_role(self.TEACHER_KEY)
|
|
|
|
def get_default_student_role(self):
|
|
return self._get_default_role(self.STUDENT_KEY)
|
|
|
|
def _get_default_role(self, key):
|
|
try:
|
|
return self.get(name=self.DEFAULT_ROLES[key])
|
|
except self.model.DoesNotExist:
|
|
return None
|
|
|
|
def _create_default_permissions(self):
|
|
content_type = ContentType.objects.get_for_model(self.model)
|
|
# edit_events = Permission.objects.get(content_type=content_type, codename="can_edit_events")
|
|
# 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")
|
|
# 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, codename="can_manage_school_class_content"
|
|
)
|
|
|
|
return (can_manage_school_class_content,)
|
|
|
|
|
|
class UserRoleManager(models.Manager):
|
|
def get_or_create_role_for_user(self, user, role_key):
|
|
from users.models import Role
|
|
|
|
try:
|
|
role = Role.objects.get(key=role_key)
|
|
except Role.DoesNotExist:
|
|
return None
|
|
|
|
try:
|
|
user_role = self.model.objects.get(role=role, user=user)
|
|
return user_role
|
|
except self.model.DoesNotExist:
|
|
return self._create_user_role(user, role)
|
|
|
|
def _create_user_role(self, user, role):
|
|
user_role = self.model(user=user, role=role)
|
|
user_role.save()
|
|
return user_role
|
|
|
|
|
|
class UserManager(DjangoUserManager):
|
|
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.first_name = first_name
|
|
user.last_name = last_name
|
|
# Todo: remove if not used
|
|
# user.set_password(self.model.objects.make_random_password())
|
|
user.set_unusable_password()
|
|
return user
|
|
|
|
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.save()
|
|
return user
|
|
|
|
def create_user_from_hep(self, user_data):
|
|
try:
|
|
user = self.model.objects.get(email=user_data["email"])
|
|
user.set_unusable_password()
|
|
except self.model.DoesNotExist:
|
|
user = self._create_user_with_random_password_no_save(
|
|
user_data["first_name"], user_data["last_name"], user_data["email"]
|
|
)
|
|
|
|
user.hep_id = user_data["id"]
|
|
user.save()
|
|
|
|
# todo: how to handle
|
|
# if user.hep_group_id == settings.HEP_MYSKILLBOX_GROUP_ID:
|
|
# apps.get_model('users.UserData').objects.create(user=user, accepted_terms=True)
|
|
|
|
return user
|
|
|
|
def get_or_create_hep_user(self, user_data):
|
|
try:
|
|
user = self.get(hep_id=user_data["id"])
|
|
logger.info(f"Got user {user.id}")
|
|
except self.model.DoesNotExist:
|
|
user = self.create_user_from_hep(user_data)
|
|
logger.info(f"Created user {user.id}")
|
|
|
|
return user
|
|
|
|
|
|
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"])
|
|
|
|
if role == "teacher":
|
|
user_role = Role.objects.get_default_teacher_role()
|
|
else:
|
|
user_role = Role.objects.get_default_student_role()
|
|
|
|
new_license = self._create_license_for_role(
|
|
licensee, expiry_date, raw, user_role, order_id, isbn, activation_date
|
|
)
|
|
new_license.licensee.license_expiry_date = new_license.expire_date
|
|
new_license.licensee.save()
|
|
|
|
return new_license
|
|
|
|
def _create_license_for_role(
|
|
self, licensee, expiry_date, raw, role, order_id, isbn, 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):
|
|
licenses = self.filter(licensee=user, expire_date__gte=timezone.now()).order_by(
|
|
"-expire_date"
|
|
)
|
|
licenses = [license for license in licenses if license.is_valid()]
|
|
if len(licenses) == 0:
|
|
return None
|
|
|
|
license = licenses[0]
|
|
|
|
# update license on user
|
|
user.license_expiry_date = license.expire_date
|
|
user.save()
|
|
|
|
return license
|