from collections import defaultdict from rest_framework import serializers, status from api.models import TtLocation, TtLocationSuitability, TtSetting, TtModule, TtWeekPattern, TtAvailability, \ TtStartPreference, TtUsagePreference, TtAcademicTerm, TtPos, TtPosModuleGroup 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 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, get_missing_code_from_db, \ get_auto_generate_name, get_auto_generate_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 PosCreate(AdminApiBase): def validate_request(self,request): rules = { "academic_term_id": "required|exists:api.TtAcademicTerm,id", } # validate academic_term first, cause need get preset pattern, if wrong id direct return error validator = BaseValidator(request.data,rules) error = validator.validate() if error: raise ValidationError(error) setting_params = { "slot_per_week", } settings = TtSetting.get_multiple_setting(setting_params) slot_per_week = settings["slot_per_week"] # based on academic_term_id get the start_time and end time academic_term_id = request.data.get("academic_term_id") # academic_term = TtAcademicTerm.objects.filter(id=academic_term_id).first() rules = { "code": "nullable|not_exists:api.TtPos,code", "name": "required", "desc": "nullable", "department_id": "nullable|exists:api.TtDepartment,id", "planned_size": "required|integer", "max_credit": "required|integer", "module_group": "required|array|exists:api.TtModuleGroup,id", "tag": "nullable|array|exists:api.TtTag,id", } # 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 # 2025-10-01 PMO say no need check too much in pattern first, if not take too much time to do it, wait until got feedback only depends how to check # if using pattern, the pattern must follow default rules def post(self, request): # Validate input try: self.validate_request(request) old_new_data = { "old_data": None, "new_data": None, } action="pos_create" # this is for audit log only idata = {} # not insert to pos table ignore_field = ['tag','timestamp','signature'] valid_fields = {f.column for f in TtPos._meta.fields} for key, val in request.data.items(): if key not in ignore_field: match 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 code or is null or empty, will used default code code = request.data.get("code") if not code: idata["code"] = get_next_available_code(TtPos, "code", "MV", 10) idata['status'] = TtPos.STATUS_TO_CODE['active'] idata['created_by'] = request.user.id pos = TtPos.objects.create(**idata) pos_id = pos.id old_new_data['new_data']=get_add_new_data(pos) module_group_ids = request.data.get("module_group", []) new_pos_module_groups = [] if module_group_ids: pos_module_group_idata = [] missing_code = get_missing_code_from_db(self.default_code_prefix, "tt_pos_module_group", 10) last_code = ( TtPosModuleGroup.objects .filter(code__startswith=self.default_code_prefix) .values_list('code', flat=True) .order_by('-code') .first() ) for module_group_id in module_group_ids: # handle for code part if missing_code: new_code = missing_code[0] missing_code.pop(0) else: last_code = get_auto_generate_code(last_code, self.default_code_prefix, 10) new_code = last_code pos_module_group_idata.append(TtPosModuleGroup(code=new_code, pos_id=pos_id, module_group_id=module_group_id)) if pos_module_group_idata: old_new_data['new_data']['module_group'] = module_group_ids new_pos_module_groups = TtPosModuleGroup.objects.bulk_create(pos_module_group_idata) new_ids = request.data.get("tag", []) old_new_data = self.update_m2m_field(pos,'tag',None,new_ids,old_new_data,False,True) redis_pos_table = "pos" # from here make it same name as db first, got different, only do extra handle redis_pos_column = [ "id","code","name","desc","department_id","academic_term_id","planned_size","max_credit","module_group_id" ] redis_data = { "insert": {}, } redis_pos_data = {} for column in redis_pos_column: match column: case "module_group_id": redis_pos_data[column] = request.data.get("module_group") or [] case _: redis_pos_data[column] = getattr(pos, column) redis_data["insert"].setdefault(redis_pos_table, []).append(redis_pos_data) bulk_sync_to_redis(redis_client, redis_data) # kafka push method = "pos_create" kafka_topic = self.kafka_config['MICROSERVICES_TT_TOPIC'] new_data = old_new_data.get("new_data") kafka_pos = [] if new_data and kafka_topic: relation_fields = [ "module_group", "tag", ] kafka_pos = generate_kafka_data(new_data, relation_fields) # if new_pos_module_groups: # kafka_pos_module_group = [] # for new_pos_module_group in new_pos_module_groups: # kafka_pos_module_group.append({ # "code": new_pos_module_group.code, # "pos_id": new_pos_module_group.pos_id, # "module_group_id": new_pos_module_group.module_group_id # }) kafka_request_data = { "session_id": request.user.name, "pos": kafka_pos, } 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":pos.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)