from collections import defaultdict from rest_framework import serializers, status from api.models import TtUsagePreference, TtWeekPattern, TtAcademicTerm, 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 WeekPatternUpdate(AdminApiBase): def validate_request(self,request): rules = { "id": "required|array|exists:api.TtWeekPattern,id", } # if need rename field, can put here attribute = { # "email": __("attr.email"), } # validate id first, cause need get week_pattern by id, if wrong id direct return error validator = BaseValidator(request.data,rules,attribute) error = validator.validate() if error: raise ValidationError(error) edit_week_pattern = ( TtWeekPattern.objects .select_related("academic_term") .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")) ) rules = { "name": "nullable", "academic_term_id": "nullable|exists:api.TtAcademicTerm,id" , "department_id": "nullable|exists:api.TtDepartment,id", "week_id": "nullable|array|exists:api.TtWeek,id", # if no change academic_term, this can be null "tag": "nullable|array|exists:api.TtTag,id", } if request.data.get("academic_term_id"): # if got pass in academic_term, must pass in week_id also rules["week_id"] = "required|array|exists:api.TtWeek,id" if request.data.get("code") and edit_week_pattern.count() == 1: week_pattern = edit_week_pattern.first() if request.data.get("code") != week_pattern.code: rules['code'] = "nullable|not_exists:api.TtWeekPattern,code" # 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 if request.data.get("academic_term_id"): academic_term = TtAcademicTerm.objects.filter(id=request.data.get("academic_term_id")).prefetch_related("week").first() requested_week_ids = request.data.get("week_id") or [] # array from request valid_week_ids = set(academic_term.week.values_list("id", flat=True)) invalid_ids = [wid for wid in requested_week_ids if wid not in valid_week_ids] if invalid_ids: error = { "error": __("validation.exists",field=__("attr.week_id"), values=invalid_ids), "errors": {"week_id":__("validation.exists",field=__("attr.week_id"), values=invalid_ids)}, } raise ValidationError(error) return edit_week_pattern def post(self, request): # Validate input try: edit_week_pattern = self.validate_request(request) action="week_pattern_update" # this is for audit log only updated = False update_fields = {} ignore_fields = ['id','tag','timestamp','signature'] # if more than 1 week_pattern edit, ignore code if edit_week_pattern.count() > 1 or not request.data.get("code"): ignore_fields.append('code') valid_fields = {f.column for f in TtWeekPattern._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_week_pattern,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_week_pattern.update(**update_fields) week_for_redis = [] if "week_id" in request.data: new_ids = request.data.get("week_id", []) weeks_data = TtWeek.objects.filter(id__in=new_ids).order_by("week") week_name = list(weeks_data.values_list("week",flat=True)) week_for_redis = convert_to_redis_week(week_name) old_new_data = self.update_m2m_field_bulk(edit_week_pattern,'week',new_ids,old_new_data) if "tag" in request.data: new_ids = request.data.get("tag", []) old_new_data = self.update_m2m_field_bulk(edit_week_pattern,'tag',new_ids,old_new_data,False,True) redis_data = { "update": {} } redis_week_pattern_table = "week_pattern" redis_week_pattern_data = {} # wont update self sub_week_pattern_id redis_week_pattern_column = [ "name", "department_id" ] # if only 1 week_pattern, can edit code if edit_week_pattern.count() == 1: redis_week_pattern_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 week_pattern_id, will return in week_pattern, so cant use it if old_new_data['new_data']: for edit_id in request.data.get("id"): # every new week_pattern reset the redis_week_pattern_data and append to redis_data['update'] redis_week_pattern_data = {"id": edit_id} for key, val in request.data.items(): if key in redis_week_pattern_column: redis_week_pattern_data[key] = val if key == "week_id": redis_week_pattern_data["week"] = week_for_redis if len(redis_week_pattern_data)>1:# > 1 means not only id redis_data["update"].setdefault(redis_week_pattern_table, []).append(redis_week_pattern_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_week_pattern = [] method = "week_pattern_update" kafka_topic = self.kafka_config['MICROSERVICES_TT_TOPIC'] if kafka_topic: new_data = old_new_data.get("new_data") relation_fields = [ "week", "tag" ] relation_data = generate_kafka_data_update(new_data, relation_fields) update_fields.pop("updated_by", None) for week in edit_week_pattern: data = {"id": week.id, **update_fields, **relation_data} kafka_week_pattern.append(data) kafka_request_data = { "session_id": request.user.name, "week_pattern": kafka_week_pattern, } 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_week_pattern.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)