from django.db import connection from rest_framework import serializers, status from api.models import TtUsagePreference, TtConstraintProfile, TtSetting, TtResourceBreak, TtMaximumWorkspan, \ TtMaximumHour, \ TtTravelTable, TtFreeBlock 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_start_and_end_slot from rest_framework.exceptions import ValidationError from api.translation import __ from backend.kafka import send_request from backend.redis_client import redis_client from django.db.models import Prefetch class ConstraintProfileCreate(AdminApiBase): def validate_request(self,request): status_code_string = ",".join(str(v) for v in TtConstraintProfile.STATUS_TO_CODE.values()) # FE will request by pattern, so can reduce the changes from FE, and BE will convert this pattern become start_slot and end_slot rules = { "code": "nullable|not_exists:api.TtConstraintProfile,code", "name": "required", "desc": "nullable", "department_id": "nullable|exists:api.TtDepartment,id", "active_constraints": "nullable|array", "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 if "active_constraints" in request.data: category_as_key = {} required_fields = {"id", "category"} active_constraints = request.data.get("active_constraints") for active_constraint in active_constraints: if not required_fields.issubset(active_constraint.keys()): raise ValidationError({ "error": __('validation.invalid', field=__("attr.active_constraints")), "errors": {"active_constraints": __('validation.invalid', field=__("attr.active_constraints"))} }) category_as_key.setdefault(active_constraint["category"], set()).add(active_constraint["id"]) if category_as_key: category_to_table = { "free_block": TtFreeBlock, "resource_break": TtResourceBreak, "maximum_workspan": TtMaximumWorkspan, "maximum_hour": TtMaximumHour, "travel_table": TtTravelTable } for key,val in category_as_key.items(): model = category_to_table.get(key) # FE passing invalid category, throw error if not model: raise ValidationError({ "error": __('validation.invalid', field=__("attr.active_constraints")), "errors": {"active_constraints": __('validation.invalid', field=__("attr.active_constraints"))} }) count = model.objects.filter(id__in=val).count() # if got id not found, return invalid format for active_constraints only if count != len(val): raise ValidationError({ "error": __('validation.invalid', field=__("attr.active_constraints")), "errors": {"active_constraints": __('validation.invalid', field=__("attr.active_constraints"))} }) def post(self, request): # Validate input try: self.validate_request(request) old_new_data = { "old_data": None, "new_data": None, } action="constraint_profile_create" # this is for audit log only idata = {} ignore_field = ["tag","active_constraints"] valid_fields = {f.column for f in TtConstraintProfile._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(TtConstraintProfile, "code", "MV", 10) idata["status"] = TtConstraintProfile.STATUS_TO_CODE['active'] idata['created_by'] = request.user.id constraint_profile = TtConstraintProfile.objects.create(**idata) old_new_data['new_data']=get_add_new_data(constraint_profile) active_constraints = {} if "active_constraints" in request.data: # group to key as category and val is ids, make it easier to insert to relation table for val in request.data.get("active_constraints"): active_constraints.setdefault(val['category'],[]).append(val['id']) for category, ids in active_constraints.items(): # normally category is same as the relation name inside model, if got different, can put if else to handle it old_new_data = self.update_m2m_field(constraint_profile,category,None,ids,old_new_data) new_ids = request.data.get("tag", []) old_new_data = self.update_m2m_field(constraint_profile,'tag',None,new_ids,old_new_data,False,True) redis_constraint_profile_table = "constraint_profile" # from here make it same name as db first, got different, only do extra handle redis_constraint_profile_column = [ "id", "code", "name", "department_id", "free_block_ids", "resource_break_ids", "maximum_workspan_ids", "maximum_hour_ids","travel_table_ids", ] redis_data = { "insert": {}, } redis_constraint_profile_data = {} query_map= { "free_block": TtFreeBlock, "resource_break": TtResourceBreak, "maximum_workspan": TtMaximumWorkspan, "maximum_hour": TtMaximumHour, "travel_table": TtTravelTable, } relation_map = [ "free_block", "resource_break", "maximum_workspan", "maximum_hour", "travel_table", ] prefetches = [] for relation_name in relation_map: model = query_map[relation_name] prefetches.append( Prefetch( relation_name, queryset=model.objects.filter( status=model.STATUS_TO_CODE["active"] ), ) ) profile = ( TtConstraintProfile.objects .filter(id=constraint_profile.id) .prefetch_related(*prefetches) .get() ) for column in redis_constraint_profile_column: match column: case "free_block_ids"|"resource_break_ids"|"maximum_workspan_ids"|"maximum_hour_ids"|"travel_table_ids": key = column.removesuffix("_ids") redis_constraint_profile_data[column] = sorted([ obj.id for obj in getattr(profile, key).all() ]) case _: redis_constraint_profile_data[column] = getattr(constraint_profile, column) redis_data["insert"].setdefault(redis_constraint_profile_table, []).append(redis_constraint_profile_data) bulk_sync_to_redis(redis_client, redis_data) # 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":constraint_profile.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)