import datetime from collections import defaultdict from rest_framework import serializers, status from api.models import TtUsagePreference, TtStartPreference, TtAcademicTerm, TtSetting, TtWeek from api.models.audit_trail import AuditTrail from api.models.audit_trail_details import AuditTrailDetails from api.models.tt_location import TtLocation 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_update, log_critical_error, get_exception_detail, \ get_add_new_data, get_ip, get_old_new_data, bulk_sync_to_redis, get_multiple_old_new_data, search_old_new_data, \ convert_to_redis_week from rest_framework.exceptions import ValidationError from api.translation import __ from backend.kafka import send_request from backend.redis_client import redis_client class AcademicTermUpdate(AdminApiBase): def validate_request(self,request): rules = { "id": "required|array|exists:api.TtAcademicTerm,id", } # if need rename field, can put here attribute = { # "email": __("attr.email"), } # validate id first, cause need get academic_term by id, if wrong id direct return error validator = BaseValidator(request.data,rules,attribute) error = validator.validate() if error: raise ValidationError(error) edit_academic_term = ( TtAcademicTerm.objects .prefetch_related( "week", # "tag__tag" # tags means the relation add in models, __tag means the relation table tag_id get the tag object #2 ) .filter(id__in=request.data.get("id")) ) status_code_string = ",".join(str(v) for v in TtAcademicTerm.STATUS_TO_CODE.values()) rules = { "name": "nullable", "start_date": "nullable|date", "end_date": "nullable|date", "start_time": "nullable|time", "end_time": "nullable|time", "status": "nullable|in:"+status_code_string+"?academic_term_status", } if "start_date" in request.data or "end_date" in request.data: raise ValidationError({ "error": __('validation.cant_update_date'), "errors": {"id": [__("validation.cant_update_date")]} }) if edit_academic_term.count() == 1: if request.data.get("code"): academic_term = edit_academic_term.first() if request.data.get("code") != academic_term.code: rules['code'] = "nullable|not_exists:api.TtAcademicTerm,code" else: # throw error say only can update 1 record raise ValidationError({ "error": __('validation.not_allow_bulk_update'), "errors": {"id": [__("validation.not_allow_bulk_update")]} }) # if need rename field, can put here attribute = { # "email": __("attr.email"), } validator = BaseValidator(request.data,rules,attribute) error = validator.validate() # custom error after basic validation if error: raise ValidationError(error) return edit_academic_term def post(self, request): # Validate input try: edit_academic_term = self.validate_request(request) action="academic_term_update" # this is for audit log only updated = False update_fields = {} ignore_fields = ['id','timestamp','signature'] # if more than 1 academic_term edit, ignore code if edit_academic_term.count() > 1 or not request.data.get("code"): ignore_fields.append('code') valid_fields = {f.column for f in TtAcademicTerm._meta.fields} for key, val in request.data.items(): if key not in ignore_fields and key in valid_fields: updated = True match key: case _: # default the key will same as db column name update_fields[key] = val # be4 save need get the old new data already, because bulk update is no matter got change or no changes also will update old_new_data = get_multiple_old_new_data(edit_academic_term,request.data.items(),ignore_fields,valid_fields) if update_fields: # 2026-04-27, ignore updated param, it is useless, this code is replace by "replace in file", so didnt remove param updated update_fields['updated_by'] = request.user.id edit_academic_term.update(**update_fields) # get setting if got update start time and end time if request.data.get("start_time") or request.data.get("end_time"): setting_params = { "minute_per_slot", "slot_per_day", "slot_per_week", } settings = TtSetting.get_multiple_setting(setting_params) # will need update 1 by 1, cause if only change start_time, every academic_term has different end_time, so need 1 by 1 calculate for academic_term in edit_academic_term: default_availability = "" default_usage = "" default_start = "" start_time = academic_term.start_time end_time = academic_term.end_time if request.data.get("start_time"): start_time = datetime.datetime.strptime(request.data.get("start_time"), "%H:%M").time() if request.data.get("end_time"): end_time = datetime.datetime.strptime(request.data.get("end_time"), "%H:%M").time() time_count = [0, 0] for i in range(int(settings.get("slot_per_week"))): time_format = datetime.time(time_count[0], time_count[1]) if start_time <= time_format < end_time: default_availability += "0" else: default_availability += "1" default_usage += "5" default_start += "5" time_count[1] += int(settings.get("minute_per_slot")) # add minutes if time_count[1] >= 60: # move to next hour time_count[1] -= 60 time_count[0] += 1 if time_count[0] >= 24: # reset after 23:59 time_count[0] = 0 fields = ["default_availability", "default_usage", "default_start"] for field in fields: old_new_data["old_data"].setdefault(academic_term.id, {})[field] = getattr(academic_term, field) old_new_data["new_data"].setdefault(academic_term.id, {})[field] = locals()[field] # calculate default usage/start/availability academic_term.default_availability = default_availability academic_term.default_usage = default_usage academic_term.default_start = default_start academic_term.save() # if in update, TtWeek table wont be empty, so no need check is empty or not if request.data.get("end_date"): latest_week = TtWeek.objects.order_by("-week").first() week_idata = [] current_week_id = latest_week.id current_week = int(latest_week.week) current_start_date = latest_week.start_date # must convert to datetime format only can compare academic_term_end_date = datetime.datetime.strptime(request.data.get("end_date"), "%Y-%m-%d").date() # calculate how many week need to insert while current_start_date <= academic_term_end_date: current_week_id = current_week_id + 1 current_week = current_week + 1 current_start_date = current_start_date + datetime.timedelta(days=7) week_idata.append( TtWeek( id=current_week_id, week=current_week, start_date=current_start_date, ) ) if week_idata: TtWeek.objects.bulk_create(week_idata) week_for_redis = {} # cant update tgt, cause if only update either 1 data, another 1 will have different value if "start_date" in request.data or "end_date" in request.data: for academic_term in edit_academic_term: start_date = academic_term.start_date end_date = academic_term.end_date if request.data.get("start_date"): start_date = request.data.get("start_date") if request.data.get("end_date"): end_date = request.data.get("end_date") weeks_data = TtWeek.objects.filter(start_date__gte=start_date,start_date__lte=end_date).order_by("week") week_ids = weeks_data.values_list("id",flat=True) old_week_ids = [week.id for week in academic_term.week.all()] week_for_redis[academic_term.id] = convert_to_redis_week(list(weeks_data.values_list("week",flat=True))) self.update_m2m_field(academic_term,'week',old_week_ids,week_ids,old_new_data) old_new_data["old_data"].setdefault(academic_term.id, {})["week_id"] = old_week_ids old_new_data["new_data"].setdefault(academic_term.id, {})["week_id"] = list(week_ids) redis_data = { "update": {} } redis_academic_term_table = "academic_term" redis_academic_term_data = {} redis_academic_term_column = [ "name","start_date","end_date","start_time","end_time","week","default_availability","default_usage","default_start" ] # if only 1 academic_term, can edit code if edit_academic_term.count() == 1: redis_academic_term_column.append('code') # got new data only means got update, then will for loop request.data, cause the old_new_data['new_data'] for foreign key name, like academic_term_id, will return in academic_term, so cant use it if old_new_data['new_data']: for edit_id in request.data.get("id"): # every new academic_term reset the redis_academic_term_data and append to redis_data['update'] redis_academic_term_data = {"id": edit_id} for key, val in request.data.items(): if key in redis_academic_term_column: redis_academic_term_data[key] = val # when got changes of start date or end date, only need update week_id if request.data.get("start_date") or request.data.get("end_date"): redis_week_ids = old_new_data['new_data'].get(edit_id, {}).get("week_id") # not null means got update week, so will update to week column in redis if redis_week_ids is not None: if edit_id in week_for_redis: redis_academic_term_data["week"] = week_for_redis[edit_id] if request.data.get("start_time") or request.data.get("end_time"): fields = ["default_availability", "default_usage", "default_start"] for field in fields: redis_academic_term_data[field] = old_new_data['new_data'].get(edit_id, {}).get(field) if len(redis_academic_term_data)>1:# > 1 means not only id redis_data["update"].setdefault(redis_academic_term_table, []).append(redis_academic_term_data) bulk_sync_to_redis(redis_client,redis_data) if old_new_data['old_data'] or old_new_data['new_data']: #kafka update/ split by id kafka_academic_term = [] method = "academic_term_update" kafka_topic = self.kafka_config['MICROSERVICES_TT_TOPIC'] if kafka_topic: new_data = old_new_data.get("new_data") relation_fields = [ # "week" //comment week since alr disable updating start date and end date ] relation_data = generate_kafka_data_update(new_data, relation_fields) update_fields.pop("updated_by", None) for aca in edit_academic_term: data = {"id": aca.id, **update_fields, **relation_data} kafka_academic_term.append(data) kafka_request_data = { "session_id": request.user.name, "academic_term": kafka_academic_term, } 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) ) name = ",".join(edit_academic_term.values_list("name", flat=True)) remark_param = { "name": 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'], old_data=old_new_data['old_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)