import copy from collections import defaultdict from django.db.models import Func, Value, F, Prefetch from django.utils import timezone from rest_framework import serializers, status from api.models import TtSetting, TtWeekPattern, TtAvailability, TtStartPreference, \ TtUsagePreference, TtActivityTemplate, TtActivity, TtWeek, TtAcademicTerm 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_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 api.services.integration.tracking import track_activity_ids from backend.kafka import send_request from backend.redis_client import redis_client class ActivityTemplateUpdate(AdminApiBase): def validate_request(self,request,settings): # wont update module id, just want based on module id get the activity template rules = { "id": "required|exists:api.TtActivityTemplate,id", # "module_id": "required|exists:api.TtModule,id", } # if need rename field, can put here attribute = { # "email": __("attr.email"), } # validate id first, cause need get activity_template by id, if wrong id direct return error validator = BaseValidator(request.data,rules,attribute) error = validator.validate() if error: raise ValidationError(error) edit_activity_template = ( TtActivityTemplate.objects .select_related("department", "academic_term", "week_pattern","module", "activity_type", "zone", "availability","start_preference", "usage_preference") .prefetch_related( "week", "staff", "staff_suitability", "location", "location_suitability", "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")) ) slot_per_week = settings["slot_per_week"] rules = { "name": "nullable", "desc": "nullable", "duration": "nullable", "planned_size": "nullable", "department_id": "nullable|exists:api.TtDepartment,id", "sequence_number": "nullable|integer", "activity_type_id": "nullable|exists:api.TtActivityType,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", "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]+", "tag": "nullable|array|exists:api.TtTag,id", } if request.data.get("code") and edit_activity_template.count() == 1: activity_template = edit_activity_template.first() if request.data.get("code") != activity_template.code: rules['code'] = "nullable|not_exists:api.TtActivityTemplate,code" # 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_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"]) edit_activity_template = self.validate_request(request,settings) action="activity_template_update" # this is for audit log only # since got filter by academic_term, so this part all the activity template will in same academic_term, just get the first template to find academic_term_id first_template = edit_activity_template.first() academic_term_id = first_template.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()])) # remain the old data just for handle update activity name edit_activity_template_copy = copy.deepcopy(list(edit_activity_template)) # used to find all affected activity name record now = timezone.now() if "staff_requirement" in request.data: staff_requirement = request.data.get("staff_requirement") or 0 if "location_requirement" in request.data: location_requirement = request.data.get("location_requirement") or 0 # 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 updated = False update_fields = {} # not allow update academic_term, so even FE got give also ignore ignore_fields = ['id',"module_id",'academic_term_id','tag','timestamp','signature'] # if more than 1 activity_template edit, ignore code if edit_activity_template.count() > 1 or not request.data.get("code"): ignore_fields.append('code') valid_fields = {f.column for f in TtActivityTemplate._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 "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 update_fields[key] = locals()[key] case "duration": update_fields[key] = val if val != 0: update_fields['slot_required'] = val // minute_per_slot else: update_fields['slot_required'] = 0 case _: # default the key will same as db column name update_fields[key] = val # if FE got pass in either 1 param, will start do checking based on pass in data need update to default pattern or not # if both is None/0/"", means will update to default pattern if "availability_id" in request.data or "availability_pattern" in request.data: if not availability_id and not availability_pattern: availability_pattern = default_availability_pattern update_fields['availability_pattern'] = availability_pattern if "start_preference_id" in request.data or "start_preference_pattern" in request.data: if not start_preference_id and not start_preference_pattern: start_preference_pattern = default_start_preference_pattern update_fields['start_preference_pattern'] = start_preference_pattern if "usage_preference_id" in request.data or "usage_preference_pattern" in request.data: if not usage_preference_id and not usage_preference_pattern: usage_preference_pattern = default_usage_preference_pattern update_fields['usage_preference_pattern'] = usage_preference_pattern # FE got pass in either 1 also will update the requirement_type if "staff" in request.data or "staff_suitability" in request.data or "staff_requirement" in request.data: """ used case for request.data.get("staff_suitability") or ("staff_suitability" not in request.data and first_template.staff_suitability.exists()) request.data.get("staff_suitability") FE got pass in value for staff_suitability OR ("staff_suitability" not in request.data and first_template.staff_suitability.exists()) FE no pass in param for staff_suitability, and current the activity have preset for staff_suitability this case will remain type as "suitability" but if FE got pass in param staff_suitability but is None or [], the type will change to wildcard """ if request.data.get("staff") or ("staff" not in request.data and first_template.staff.exists()): update_fields['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['preset'] # if got pass in staff key, ignore FE requirement, BE self handle it if request.data.get("staff"): staff_requirement = len(request.data.get("staff")) else: staff_requirement = len(first_template.staff.all()) update_fields['staff_requirement'] = staff_requirement elif ( request.data.get("staff_suitability") or ("staff_suitability" not in request.data and first_template.staff_suitability.exists()) or request.data.get("staff_requirement") or ("staff_requirement" not in request.data and first_template.staff_requirement > 0) ): update_fields['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['wildcard'] else: update_fields['staff_requirement_type'] = TtActivityTemplate.STAFF_REQUIREMENT_TYPE['none'] if "location" in request.data or "location_suitability" in request.data or "location_requirement" in request.data: if request.data.get("location") or ("location" not in request.data and first_template.location.exists()): update_fields['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['preset'] if request.data.get("location"): location_requirement = len(request.data.get("location") or []) else: location_requirement = len(first_template.location.all()) update_fields['location_requirement'] = location_requirement elif ( request.data.get("location_suitability") or ("location_suitability" not in request.data and first_template.location_suitability.exists()) or request.data.get("location_requirement") or ("location_requirement" not in request.data and first_template.location_requirement > 0) ): update_fields['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['wildcard'] else: update_fields['location_requirement_type'] = TtActivityTemplate.LOCATION_REQUIREMENT_TYPE['none'] # 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_activity_template,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_activity_template.update(**update_fields) if "staff" in request.data: new_ids = request.data.get("staff", []) old_new_data = self.update_m2m_field_bulk(edit_activity_template,'staff',new_ids,old_new_data) if "staff_suitability" in request.data: new_ids = request.data.get("staff_suitability", []) old_new_data = self.update_m2m_field_bulk(edit_activity_template,'staff_suitability',new_ids,old_new_data) if "location" in request.data: new_ids = request.data.get("location", []) old_new_data = self.update_m2m_field_bulk(edit_activity_template,'location',new_ids,old_new_data) if "location_suitability" in request.data: new_ids = request.data.get("location_suitability", []) old_new_data = self.update_m2m_field_bulk(edit_activity_template,'location_suitability',new_ids,old_new_data) # custom week pattern store in relation, so need handle like this # if both not passing in, will not touch this, if got pass in [] or "", will handle also week_pattern_id = request.data.get("week_pattern_id") week_pattern = request.data.get("week_pattern") if "week_pattern" in request.data or "week_pattern_id" in request.data: # if is None, put in the default week_pattern first, so if got id, will reset to null, if no id, will update to default week_pattern if not week_pattern: week_pattern = default_week_pattern else: # if not empty of week_pattern, will get this data for update redis # week store in redis need - 1, cause schedule there week is start from 0 week_pattern_for_redis = convert_to_redis_week(list(TtWeek.objects.filter(id__in=week_pattern).values_list("week",flat=True))) if week_pattern_id: week_pattern = None week_pattern_for_redis = [] old_new_data = self.update_m2m_field_bulk(edit_activity_template,'week',week_pattern,old_new_data) if "tag" in request.data: new_ids = request.data.get("tag", []) old_new_data = self.update_m2m_field_bulk(edit_activity_template,'tag',new_ids,old_new_data,False,True) redis_data = { "update": {} } redis_activity_table = "activity" kafka_activity = [] # update activity table activity type if got update activity type if "activity_type_id" in request.data: activities = TtActivity.objects.filter(activity_template_id__in=request.data.get("id")) track_activity_ids(activities.values_list("id", flat=True)) activities.update(activity_type_id=request.data.get("activity_type_id")) for activity in activities: data = { "id": activity.id, "activity_type_id": activity.activity_type_id } redis_data["update"].setdefault(redis_activity_table, []).append(data) kafka_activity.append(data) # if got update name, need update all activity name prefix same as template # only update redis activity table name column if "name" in request.data: for val in edit_activity_template_copy: # update per template old_prefix = val.name+self.auto_generate_name_seperator new_prefix = request.data['name']+self.auto_generate_name_seperator affected_template_activities = TtActivity.objects.filter( activity_template_id=val.id, name__startswith=old_prefix, ) track_activity_ids(affected_template_activities.values_list("id", flat=True)) ( affected_template_activities .update( name=Func(# replace old prefix become new prefix but not changing the number for auto generate name Value(new_prefix), Func(F('name'), Value(len(old_prefix) + 1), function='SUBSTR'), function='CONCAT' ), updated_by=request.user.id, updated_at=now, ) ) affected_activity = TtActivity.objects.filter(updated_at=now) for val in affected_activity: data = { "id": val.id, "name": val.name } redis_data["update"].setdefault(redis_activity_table, []).append(data) kafka_activity.append(data) redis_activity_template_table = "activity_template" redis_activity_template_data = {} # from here make it same name as db first, got different, only do extra handle redis_activity_template_column = [ "name", "desc", "planned_size", "duration","activity_type_id", "department_id","sequence_number", "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" ] if edit_activity_template.count() == 1: redis_activity_template_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 department_id, will return in department, so cant use it if old_new_data['new_data']: for edit_id in request.data.get("id"): # every new activity reset the redis_activity_template_data and append to redis_data['update'] redis_activity_template_data = {"id": edit_id} for key, val in request.data.items(): if key in redis_activity_template_column: if key in ["usage_preference_id", "availability_id", "start_preference_id","week_pattern_id"]: # jose request if no id, dun store null, want to store "0" redis_activity_template_data[key] = 0 if val in (None, "") else val else: redis_activity_template_data[key] = val # extra handle for update slot_required if key == "duration": redis_activity_template_data['slot_required'] = int(val / minute_per_slot) if "location" in request.data or "location_suitability" in request.data or "location_requirement" in request.data: redis_activity_template_data["location_requirement_type"] = update_fields['location_requirement_type'] if "staff" in request.data or "staff_suitability" in request.data or "staff_requirement" in request.data: redis_activity_template_data["staff_requirement_type"] = update_fields['staff_requirement_type'] if "staff" in request.data: redis_activity_template_data["staff_preset"] = request.data.get("staff") if "location" in request.data: redis_activity_template_data["location_preset"] = request.data.get("staff") if "staff_suitability" in request.data: suitability = request.data.get("staff_suitability") redis_activity_template_data["staff_suitability_id"] = suitability[0] if isinstance(suitability,list) and suitability else None if "location_suitability" in request.data: suitability = request.data.get("location_suitability") redis_activity_template_data["location_suitability_id"] = suitability[0] if isinstance(suitability,list) and suitability else None if "staff_requirement" in request.data: redis_activity_template_data["staff_required_no"] = staff_requirement if "location_requirement" in request.data: redis_activity_template_data["location_required_no"] = location_requirement # this must custom the handle, for pattern, if not in some scenario will store null in redis when no id if "availability_id" in request.data or "availability_pattern" in request.data: redis_activity_template_data["availability_pattern"] = availability_pattern if "start_preference_id" in request.data or "start_preference_pattern" in request.data: redis_activity_template_data["start_preference_pattern"] = start_preference_pattern if "usage_preference_id" in request.data or "usage_preference_pattern" in request.data: redis_activity_template_data["usage_preference_pattern"] = usage_preference_pattern if "week_pattern_id" in request.data or "week_pattern" in request.data: redis_activity_template_data["week_pattern"] = week_pattern_for_redis if len(redis_activity_template_data) > 1: # > 1 means not only id redis_data["update"].setdefault(redis_activity_template_table, []).append(redis_activity_template_data) if redis_data["update"]: 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_activity_templat = [] method = "activity_template_update" kafka_topic = self.kafka_config['MICROSERVICES_TT_TOPIC'] if kafka_topic: new_data = old_new_data.get("new_data") relation_fields = [ "staff_preset", "staff_suitability", "location_preset", "location_suitability", "week", "tag", ] relation_data = generate_kafka_data_update(new_data, relation_fields) update_fields.pop("updated_by", None) for act in edit_activity_template: data = {"id": act.id, **update_fields, **relation_data} kafka_activity_templat.append(data) kafka_request_data = { "session_id": request.user.name, "activity_template": kafka_activity_templat, } if kafka_activity: kafka_request_data['activity'] = kafka_activity 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_activity_template.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)