from collections import defaultdict from django.db.models import Prefetch from rest_framework import serializers, status from api.models import TtSetting, TtActivityTemplate, TtAcademicTerm, TtWeek from api.models.audit_trail import AuditTrail from api.models.audit_trail_details import AuditTrailDetails from api.views.admin.base import AdminApiBase from api.validator import BaseValidator from api.utils import convert_to_redis_week, decrypt_aes_128_cbc, encrypt_aes_128_cbc, generate_kafka_data, log_critical_error, get_exception_detail, \ get_add_new_data, get_ip, bulk_sync_to_redis, get_next_available_code from rest_framework.exceptions import ValidationError from api.translation import __ from backend.kafka import send_request from backend.redis_client import redis_client class ActivityTemplateCreate(AdminApiBase): def validate_request(self,request,settings): slot_per_week = settings["slot_per_week"] rules = { "code": "nullable|not_exists:api.TtActivityTemplate,code", "name": "required", "desc": "nullable", "duration": "required", "planned_size": "required", "activity_type_id": "required|exists:api.TtActivityType,id", "department_id": "nullable|exists:api.TtDepartment,id", "sequence_number": "nullable|integer", "academic_term_id": "required|exists:api.TtAcademicTerm,id", "module_id": "required|exists:api.TtModule,id", "staff_requirement": "nullable|integer", "staff": "nullable|array|exists:api.TtStaff,id", "staff_suitability": "nullable|array|exists:api.TtSuitability,id", "location_requirement": "nullable|integer", "location": "nullable|array|exists:api.TtLocation,id", "location_suitability": "nullable|array|exists:api.TtSuitability,id", "zone_id": "nullable|exists:api.TtZone,id", "tag": "nullable|array|exists:api.TtTag,id", "week_pattern_id": "nullable|exists:api.TtWeekPattern,id", "week_pattern": "nullable|array|exists:api.TtWeek,id", "availability_id": "nullable|exists:api.TtAvailability,id", "availability_pattern": "nullable|char_count:" + slot_per_week + "|regex:[01]+", "start_preference_id": "nullable|exists:api.TtStartPreference,id", "start_preference_pattern": "nullable|char_count:" + slot_per_week + "|regex:[1-9]+", "usage_preference_id": "nullable|exists:api.TtUsagePreference,id", "usage_preference_pattern": "nullable|char_count:" + slot_per_week + "|regex:[1-9]+", } # if need rename field, can put here attribute = { # "email": __("attr.email"), } validator = BaseValidator(request.data,rules,attribute) error = validator.validate() if error: raise ValidationError(error) # custom error after basic validation # need a checking to check this module already create template # check_module = TtActivityTemplate.objects.filter(module_id=request.data.get("module_id")).first() # if check_module: # raise ValidationError({ # "error": __('validation.module_already_create_activity_template'), # "errors": {"module_id": __("validation.module_already_create_activity_template")} # }) def post(self, request): # Validate input try: setting_params = { "slot_per_week", "minute_per_slot", } settings = TtSetting.get_multiple_setting(setting_params) slot_per_week = int(settings["slot_per_week"]) minute_per_slot = int(settings["minute_per_slot"]) self.validate_request(request,settings) old_new_data = { "old_data": None, "new_data": None, } action="activity_template_create" # this is for audit log only academic_term_id = request.data.get("academic_term_id") academic_term = TtAcademicTerm.objects.filter(id=academic_term_id).prefetch_related(Prefetch("week", queryset=TtWeek.objects.order_by("week"))).first() default_availability_pattern = academic_term.default_availability default_start_preference_pattern = academic_term.default_start default_usage_preference_pattern = academic_term.default_usage default_week_pattern = [w.id for w in academic_term.week.all()] week_pattern_for_redis = convert_to_redis_week(list([w.week for w in academic_term.week.all()])) staff_requirement = request.data.get("staff_requirement") or 0 location_requirement = request.data.get("location_requirement") or 0 # if got pass in preset, requirement will follow preset count if request.data.get("staff"): staff_requirement = len(request.data.get("staff")) if request.data.get("location"): location_requirement = len(request.data.get("location")) # this 3 pattern if got give id, force pattern to null availability_id = request.data.get("availability_id") availability_pattern = request.data.get("availability_pattern") if availability_id: availability_pattern = None start_preference_id = request.data.get("start_preference_id") start_preference_pattern = request.data.get("start_preference_pattern") if start_preference_id: start_preference_pattern = None usage_preference_id = request.data.get("usage_preference_id") usage_preference_pattern = request.data.get("usage_preference_pattern") if usage_preference_id: usage_preference_pattern = None idata = {} # not insert to activity_template table ignore_field = ['tag','timestamp','signature'] valid_fields = {f.column for f in TtActivityTemplate._meta.fields} for key, val in request.data.items(): if key not in ignore_field: match key: case "staff_requirement" | "location_requirement" | "availability_pattern" | "start_preference_pattern" | "usage_preference_pattern": # got extra handle the value for these key, so the param same name as the key, so can using this code to handle idata[key] = locals()[key] case _: if key in valid_fields:#for insert, key can check in default part, cause if got special handle, i can check the way to use key also # default the key will same as db column name idata[key] = val # if FE no pass in this 2 value, the loop wont add default pattern, so having this code to handle default pattern if not availability_id and not availability_pattern: idata['availability_pattern'] = default_availability_pattern if not usage_preference_id and not usage_preference_pattern: idata['usage_preference_pattern'] = default_usage_preference_pattern if not start_preference_id and not start_preference_pattern: idata['start_preference_pattern'] = default_start_preference_pattern if request.data.get("duration") != 0: idata['slot_required'] = request.data.get("duration") // minute_per_slot else: idata['slot_required'] = 0 # if FE no pass in code or is null or empty, will used default code code = request.data.get("code") if not code: idata["code"] = get_next_available_code(TtActivityTemplate, "code", "MV", 10) idata['status'] = TtActivityTemplate.STATUS_TO_CODE['active'] idata['created_by'] = request.user.id if request.data.get("staff"): idata['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['preset'] staff_requirement = len(request.data.get("staff")) elif request.data.get("staff_suitability") or request.data.get("staff_requirement"): idata['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['wildcard'] else: idata['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['none'] if request.data.get("location"): idata['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['preset'] location_requirement = len(request.data.get("location")) elif request.data.get("location_suitability") or request.data.get("location_requirement"): idata['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['wildcard'] else: idata['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['none'] activity_template = TtActivityTemplate.objects.create(**idata) old_new_data['new_data']=get_add_new_data(activity_template) new_ids = request.data.get("staff", []) old_new_data = self.update_m2m_field(activity_template,'staff',None,new_ids,old_new_data) new_ids = request.data.get("staff_suitability", []) old_new_data = self.update_m2m_field(activity_template,'staff_suitability',None,new_ids,old_new_data) new_ids = request.data.get("location", []) old_new_data = self.update_m2m_field(activity_template,'location',None,new_ids,old_new_data) new_ids = request.data.get("location_suitability", []) old_new_data = self.update_m2m_field(activity_template,'location_suitability',None,new_ids,old_new_data) week_pattern_id = request.data.get("week_pattern_id") week_pattern = request.data.get("week_pattern") if week_pattern_id: week_pattern = None week_pattern_for_redis = [] else : if week_pattern: week_pattern_for_redis = convert_to_redis_week(list(TtWeek.objects.filter(id__in=week_pattern).values_list("week",flat=True))) old_new_data = self.update_m2m_field(activity_template,'week',None,week_pattern,old_new_data) else: old_new_data = self.update_m2m_field(activity_template, 'week', None, default_week_pattern, old_new_data) new_ids = request.data.get("tag", []) old_new_data = self.update_m2m_field(activity_template,'tag',None,new_ids,old_new_data,False,True) redis_activity_template_table = "activity_template" # from here make it same name as db first, got different, only do extra handle redis_activity_template_column = [ "id", "code", "name", "desc", "planned_size", "slot_required", "activity_type_id", "duration", "department_id","sequence_number", "module_id", "academic_term_id", "week_pattern_id", "week_pattern", "availability_id", "availability_pattern", "start_preference_id", "start_preference_pattern", "usage_preference_id", "usage_preference_pattern", "staff_requirement_type", "staff_required_no", "staff_preset", "staff_suitability_id", "location_requirement_type", "location_required_no", "location_preset", "location_suitability_id", "status" ] redis_data = { "insert": {}, "update": {} } redis_activity_template_data = {} for column in redis_activity_template_column: match column: case "staff_suitability_id": suitability_list = list(activity_template.staff_suitability.all()) redis_activity_template_data[column] = suitability_list[0].id if suitability_list else None case "location_suitability_id": suitability_list = list(activity_template.location_suitability.all()) redis_activity_template_data[column] = suitability_list[0].id if suitability_list else None case "staff_preset": redis_activity_template_data[column] = [s.id for s in activity_template.staff.all()] case "location_preset": redis_activity_template_data[column] = [l.id for l in activity_template.location.all()] case "week_pattern": redis_activity_template_data[column] = week_pattern_for_redis case "student_sets": # when create dun have student set, so can force to empty list redis_activity_template_data[column] = [] case "staff_required_no": redis_activity_template_data[column] = activity_template.staff_requirement case "location_required_no": redis_activity_template_data[column] = activity_template.location_requirement case "usage_preference_id" | "availability_id" | "start_preference_id" | "week_pattern_id": # jose request if no id, dun store null, want to store "0" value = getattr(activity_template, column) redis_activity_template_data[column] = 0 if value in (None, "") else value case _: redis_activity_template_data[column] = getattr(activity_template, column) redis_data["insert"].setdefault(redis_activity_template_table, []).append(redis_activity_template_data) bulk_sync_to_redis(redis_client, redis_data) # kafka push method = "activity_template_create" kafka_topic = self.kafka_config['MICROSERVICES_TT_TOPIC'] new_data = old_new_data.get("new_data") kafka_activity_template = [] if new_data and kafka_topic: relation_fields = [ "staff", "staff_suitability", "location", "location_suitability", "week", "tag" ] kafka_activity_template = generate_kafka_data(new_data, relation_fields) kafka_request_data = { "session_id": request.user.name, "activity_template": kafka_activity_template, } send_request(kafka_topic, kafka_request_data, None ,method) # insert audit trail and details # can insert the parent first, then only insert details audit_trail = AuditTrail.objects.create( user_id=request.user.id, type=self.audit_type, ip_address=get_ip(request) ) remark_param = { "name":activity_template.name, } # call to a function for insert details, so in future if want change to used worker, can modify in function only AuditTrailDetails.custom_insert( audit_trail=audit_trail, action=action, remark_param=remark_param, new_data=old_new_data['new_data'], ) response = { } return self.api_response(data=response) except ValidationError as e: first_message = e.detail['error'] errors = e.detail['errors'] return self.api_response(error=first_message,errors=errors,code=status.HTTP_400_BAD_REQUEST) except Exception as e: e_details = get_exception_detail(e) log_critical_error(user_id=None,descr=e_details['descr'],url=e_details['url'],trace=e_details['trace']) return self.api_response(error=__("message.internal_server_error"),code=status.HTTP_500_INTERNAL_SERVER_ERROR)