def put(self, request, pk, format=None): user = self.get_object(pk) data = request.data serializer = ChangePasswordSerializer(data=data) if serializer.is_valid(): # Check old password if not user.check_password( serializer.data.get("current_password")): return Response( { 'error': { "current_password": ["Wrong current password."] } }, status=status.HTTP_400_BAD_REQUEST) # set_password also hashes the password that the user will get user.set_password(serializer.data.get("new_password")) UserNoteManager.change_password_logger( None, None, user, 'Changed on {now}'.format( now=UserNoteManager.get_current_time()), user) user.save() return Response("Success.", status=status.HTTP_200_OK) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): file_id = request.data.get('fileID') size = request.data.get('fileSize') course_obj = None data = {} type_ = request.data.get('fileType') if file_id: obj = TalentPicture.objects.get(id=int(file_id)) obj.size = int(size) obj.uploaded = True obj.file_type = type_ obj.save() data['id'] = obj.id data['saved'] = True # Logging talent_user = obj.talent.user UserNoteManager.profile_logger( None, None, talent_user, '{user} uploaded {picture_caption}.'.format( user=talent_user.first_name, picture_caption=obj.caption), obj) return Response(data, status=status.HTTP_200_OK)
def delete(self, request, pk, format=None): talent_sub_skill_video_item = self.get_object(pk) user = request.user if user: talent_user = talent_sub_skill_video_item.talent.user note = '' if user.type == 'agency': note = 'Greeting video ({sub_skill_name}) {status} by {user}. Comment: {comment}'.format( sub_skill_name=talent_sub_skill_video_item.sub_skill.name, status='Rejected', user=user.first_name, comment=request.data['comment'] if request.data and ('comment' in request.data) else '') elif user.type == 'talent': note = '{user} removed a greeing video ({sub_skill_name}).'.format( user=user.first_name, sub_skill_name=talent_sub_skill_video_item.sub_skill.name, ) UserNoteManager.profile_logger(None, user, talent_user, note, talent_sub_skill_video_item) talent_sub_skill_video_item.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def post(self, request, *args, **kwargs): file_id = request.data.get('fileID') size = request.data.get('fileSize') course_obj = None data = {} file_type = request.data.get('fileType') tmp = file_type.split('/') file_type = tmp[len(tmp) - 1] print(file_id, size, file_type) if file_id: obj = TalentMedicalUpload.objects.get(id=int(file_id)) obj.size = int(size) obj.uploaded = True # obj.file_type = file_type obj.save() data['id'] = obj.id data['saved'] = True # Logging talent_user = obj.talent.user UserNoteManager.profile_logger( None, None, talent_user, '{user} uploaded resume.'.format(user=talent_user.first_name), obj) return Response(data, status=status.HTTP_200_OK)
def get(self, request, pk, format=None): try: talent = Talent.objects.get(pk=pk) except Talent.DoesNotExist: raise Http404 serializer = TalentSerializer(talent) # In the case client require this talent info, save this history in Favorite table. user = request.user client = Client.objects.filter(user_id=user.id).first() if client: # Logging UserNoteManager.search_logger( None, user, talent.user, 'TALENT VIEWED BY {finder}'.format(finder=user), user) # Favoriting favorite = Favorite.objects.filter(client=client, talent=talent).first() if favorite: favorite.save() else: new_favorite = Favorite.objects.create(client=client, talent=talent) new_favorite.save() # Logging UserNoteManager.favorite_logger( None, user, talent.user, 'TALENT FAVORITED BY {finder}'.format(finder=user), user) return Response(serializer.data)
def post(self, request, format=None): client = self.get_object(request.user) serializer = CastingRequestCreateSerializer(data=request.data) if serializer.is_valid(): data = serializer.validated_data new_casting_request = CastingRequest.objects.create( client=client, name=data['name'], ship_name=data['ship_name'], employment_start_date=data['employment_start_date'], employment_end_date=data['employment_end_date'], talent_join_date=data['talent_join_date'], rehearsal_start_date=data['rehearsal_start_date'], rehearsal_end_date=data['rehearsal_end_date'], performance_start_date=data['performance_start_date'], performance_end_date=data['performance_end_date'], visa_requirements=data['visa_requirements'], comments=data['comments']) new_casting_request.save() UserNoteManager.casting_request_logger( None, None, client.user, '{client} created a new casting reqeust.'.format( client=client.user.first_name, casting_request_id=new_casting_request.id), new_casting_request) return Response(serializer.data, status=status.HTTP_201_CREATED) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): client = self.get_object(request.user) serializer = CastingRequestTalentCreateSerializer(data=request.data, many=True) if serializer.is_valid(): new_crt_ids = [] for casting_request_talent_data in serializer.validated_data: new_casting_request_talent = CastingRequestTalent( **casting_request_talent_data) new_casting_request_talent.save() client_user = new_casting_request_talent.casting_request.client.user talent_user = new_casting_request_talent.talent.user UserNoteManager.casting_request_talent_logger( None, client_user, talent_user, '{client} added talent {talent} into casting reqeust.'. format(client=client_user.first_name, talent=talent_user.first_name, casting_request=new_casting_request_talent. casting_request.id), new_casting_request_talent) new_crt_ids.append(new_casting_request_talent.id) new_casting_request_talents = CastingRequestTalent.objects.all( ).filter(id__in=new_crt_ids) new_serializer = CastingRequestTalentSerializer( new_casting_request_talents, many=True) return Response(new_serializer.data, status=status.HTTP_201_CREATED) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, pk, format=None): talent_picture_item = self.get_object(pk) talent_picture_item.delete() user = request.user if user: talent_user = talent_picture_item.talent.user note = '' if user.type == 'agency': note = '{picture_caption} {status} by {user}. Comment: {comment}'.format( picture_caption=talent_picture_item.caption, status='Rejected', user=user.first_name, comment=request.data['comment'] if request.data and ('comment' in request.data) else '') elif user.type == 'talent': note = '{user} removed {picture_caption}.'.format( user=user.first_name, picture_caption=talent_picture_item.caption, ) UserNoteManager.profile_logger(None, user, talent_user, note, talent_picture_item) return Response({'id': pk}, status=status.HTTP_204_NO_CONTENT)
def post(self, request, *args, **kwargs): file_id = request.data.get('fileID') size = request.data.get('fileSize') course_obj = None data = {} type_ = request.data.get('fileType') print(file_id, size, type_) if file_id: obj = TalentVideoGreeting.objects.get(id=int(file_id)) obj.size = int(size) obj.uploaded = True obj.file_type = type_ obj.save() data['id'] = obj.id data['saved'] = True # Logging talent_user = obj.talent.user UserNoteManager.profile_logger( None, None, talent_user, '{user} uploaded a greetings video ({language}).'.format( user=talent_user.first_name, language=obj.language ), obj ) return Response(data, status=status.HTTP_200_OK)
def delete(self, request, pk, format=None): casting_request = self.get_object(pk) casting_request.delete() user = request.user if user: UserNoteManager.casting_request_logger( None, None, user, '{client} deleted this casting reqeust.'.format( client=user.first_name), casting_request) return Response({'id': int(pk)}, status=status.HTTP_200_OK)
def delete(self, request, pk, format=None): blocked_profile = self.get_object(pk) note = '{client} REMOVED BLOCK.'.format( client=blocked_profile.client.user.email) UserNoteManager.block_logger(None, blocked_profile.client.user, blocked_profile.talent.user, note, blocked_profile) blocked_profile.delete() return Response({'id': int(pk)}, status=status.HTTP_200_OK)
def delete(self, request, pk, format=None): casting_request = self.get_object(pk) agency = request.user client_user = casting_request.client.user UserNoteManager.casting_request_logger(agency, agency, client_user, 'deteled casting reqeust.', casting_request) casting_request.delete() return Response(status=status.HTTP_204_NO_CONTENT)
def put(self, request, pk, format=None): casting_request = self.get_object(pk) serializer = CastingRequestSetStatusSerializer(casting_request, data=request.data) if serializer.is_valid(): casting_request.status = request.data['status'] casting_request.status_updated_date = request.data[ 'status_updated_date'] casting_request.save() agency_user = request.user if agency_user: client_user = casting_request.client.user status = casting_request.status if status == 'Requested': note = '{client_user} requested.'.format( client_user=client_user.first_name) elif status == 'Reviewing': note = 'Reviewing' elif status == 'In Progress': note = 'Contracted to confirm request.' elif status == 'Accepted.': note = 'Accepted' elif status == 'Declined.': note = 'Declined' elif status == 'Canceled.': note = '{client_user} canceled.'.format( client_user=client_user) elif status == 'Completed': note = 'Completed.' UserNoteManager.casting_request_logger(agency_user.first_name, client_user, client_user, note, casting_request) casting_request_talents = CastingRequestTalent.objects.filter( casting_request=casting_request) if len(casting_request_talents) > 0: for casting_request_talent in casting_request_talents: talent_user = casting_request_talent.talent.user UserNoteManager.casting_request_talent_logger( agency_user.first_name, client_user, talent_user, note, casting_request_talent) new_serializer = CastingRequestDetailSerializer(casting_request) return Response(new_serializer.data) # serializer.save() # return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def generate_tid_by_one(self, talent, position): tid = "{prefix}{talent_id}".format(prefix=position[0], talent_id=talent.id) UserNoteManager.tid_logger( None, None, talent.user, '{action} {tid} by SYS'.format( action='Changed to' if talent.tid else 'Assigned', tid=tid), talent) talent.tid = tid talent.save() return tid
def delete(self, request, pk, format=None): casting_request_talent = self.get_object(pk) casting_request_talent.delete() client_user = casting_request_talent.casting_request.client.user talent_user = casting_request_talent.talent.user UserNoteManager.casting_request_talent_logger( None, client_user, talent_user, '{client} removed talent {talent} from casting reqeust.'.format( client=client_user.first_name, talent=talent_user.first_name), casting_request_talent) return Response({'id': int(pk)}, status=status.HTTP_200_OK)
def generate_tid_by_list(self, talent, positions): tid = self.wrap_generate_tid('', positions) tid = "{tid}{talent_id}".format(tid=tid, talent_id=talent.id) UserNoteManager.tid_logger( None, None, talent.user, '{action} {tid} by SYS'.format( action='Changed to' if talent.tid else 'Assigned', tid=tid), talent) talent.tid = tid talent.save() return tid
def post(self, request, *args, **kwargs): # simply delete the token to force a login user = request.user UserNoteManager.logout_logger( None, None, user, '{now} logged out'.format(now=UserNoteManager.get_current_time()), user ) try: user.auth_token.delete() except (AttributeError, ObjectDoesNotExist): pass return Response(status=status.HTTP_200_OK)
def put(self, request, pk, format=None): casting_request = self.get_object(pk) serializer = CastingRequestSerializer(casting_request, data=request.data) if serializer.is_valid(): serializer.save() user = request.user if user: note = '{client} updated casting reqeust.'.format(client=user.first_name) if casting_request.status == 'Requested': note = '{client} submited.'.format(client=user.first_name) UserNoteManager.casting_request_logger(None, None, user, note, casting_request) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None): casting_request = self.get_object(pk) serializer = CastingRequestSerializer(casting_request, data=request.data) if serializer.is_valid(): serializer.save() agency = request.user client_user = casting_request.client.user UserNoteManager.casting_request_logger(agency, agency, client_user, 'updated casting reqeust.', casting_request) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs): serializer = self.serializer_class( data=request.data, context={'request': request} ) serializer.is_valid(raise_exception=True) user = serializer.validated_data['user'] payload = jwt_payload_handler(user) payload['type'] = user.type token = jwt_encode_handler(payload) UserNoteManager.login_logger( None, None, user, '{now} logged in'.format(now=UserNoteManager.get_current_time()), user ) return Response({'token': token})
def post(self, request, format=None): admin = self.get_object(request.user) serializer = UserNoteCreateSerializer(data=request.data) if serializer.is_valid(): data = serializer.validated_data try: object_id = data['object_id'] obj = None if object_id: obj = self.get_object_by_type_and_id(data['note_type'], object_id) note = UserNoteManager.generate_prefix(admin) + data['note'] new_user_note = UserNote.objects.create( creator=admin.first_name, actor=admin, receiver=data['receiver'], note_type=data['note_type'], note=note, object_id=object_id if object_id else 0, object_type=type(obj).__name__ if obj else '' ) if 'object_type' in data: new_user_note.object_type = data['object_type'] new_user_note.object_id = data['object_id'] new_user_note.save() new_serializer = UserNoteDetailSerializer(new_user_note) return Response(new_serializer.data, status=status.HTTP_201_CREATED) except User.DoesNotExist: raise Http404 return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None): casting_request_talent = self.get_object(pk) serializer = CastingRequestTalentSerializer(casting_request_talent, data=request.data) if serializer.is_valid(): serializer.save() client_user = casting_request_talent.casting_request.client.user talent_user = casting_request_talent.talent.user UserNoteManager.casting_request_talent_logger( None, client_user, talent_user, '{client} updated status of talent {talent} in casting reqeust.' .format(client=client_user.first_name, talent=talent_user.first_name), casting_request_talent) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None): talent_greeting_video_item = self.get_object(pk) serializer = TalentVideoGreetingSerializer(talent_greeting_video_item, data=request.data) if serializer.is_valid(): serializer.save() user = request.user if user and 'approved' in serializer.data: talent_user = talent_greeting_video_item.talent.user UserNoteManager.profile_logger( None, user, talent_user, 'Greetings video ({language}) {status} by {user}.'.format( language=talent_greeting_video_item.language, status='Approved' if serializer.data['approved'] else 'Rejected', user=user.first_name), talent_greeting_video_item) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk, format=None): talent_picture_item = self.get_object(pk) serializer = TalentPictureSerializer(talent_picture_item, data=request.data) if serializer.is_valid(): serializer.save() user = request.user if user and 'approved' in serializer.data: talent_user = talent_picture_item.talent.user UserNoteManager.profile_logger( None, user, talent_user, '{picture_caption} {status} by {user}.'.format( picture_caption=talent_picture_item.caption, status='Approved' if serializer.data['approved'] else 'Rejected', user=user.first_name), talent_picture_item) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def delete(self, request, pk, format=None): talent_medical_upload_item = self.get_object(pk) talent_medical_upload_item.delete() user = request.user if user: talent_user = talent_medical_upload_item.talent.user note = '' if user.type == 'agency': note = 'Resume of {talent} {status} by {user}. Comment: {comment}'.format( talent=talent_user.first_name, status='Rejected', user=user.first_name, comment=request.data['comment'] if 'comment' in request.data else '') elif user.type == 'talent': note = '{user} removed resume.'.format(user=user.first_name) UserNoteManager.profile_logger(None, user, talent_user, note, talent_medical_upload_item) return Response({'id': int(pk)}, status=status.HTTP_200_OK)
def put(self, request, pk, format=None): talent_medical_upload_item = self.get_object(pk) serializer = TalentMedicalUploadSerializer(talent_medical_upload_item, data=request.data) if serializer.is_valid(): serializer.save() # Logging user = request.user if user and 'approved' in serializer.data: talent_user = talent_medical_upload_item.talent.user UserNoteManager.profile_logger( None, user, talent_user, 'Resume of {talent} {status} by {user}.'.format( talent=talent_user.first_name, status='Approved' if serializer.data['approved'] else 'Rejected', user=user.first_name), talent_medical_upload_item) return Response(serializer.data) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None): user = request.user client = Client.objects.get(user_id=user.id) serializer = BlockedProfileCreateSerializer(data=request.data, many=False) if serializer.is_valid(): new_blocked_profile = BlockedProfile(client_id=client.id, **serializer.validated_data) new_blocked_profile.save() note = '{client} BLOCKED FOR {duration}.'.format( client=client.user.email, duration=new_blocked_profile.description) UserNoteManager.block_logger(None, client.user, new_blocked_profile.talent.user, note, new_blocked_profile) new_serializer = BlockedProfileDetailSerializer( new_blocked_profile, many=False) return Response(new_serializer.data, status=status.HTTP_201_CREATED) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
class SharedProfileBulkCreate(ListBulkCreateUpdateDestroyAPIView): """ Create Team member info """ # authentication_classes = (authentication.TokenAuthentication, ) # permission_classes = (permissions.IsAuthenticated,) queryset = SharedProfile.objects.all() datas = queryset.values('team_member', 'talent', 'comment') member_names = '' client = None talent = None for data in datas: team_member = TeamMember.objects.get(id=data['team_member']) talent = Talent.objects.get(id=data['talent']) comment = data['comment'] client = team_member.team.client member_names = '{prev}, {name}'.format(prev=member_names, name=team_member.member_email) note = 'PROFILE SHARED BY {client} with {member_names}.'.format(client=client.user.email, member_names=member_names) UserNoteManager.share_logger(None, client.user, talent.user, note, None) serializer_class = SharedProfileCreateSerializer
def post(self, request, format=None): """ Get talents matching to search condition """ # Filter talents according to search condition search_conditions = request.data hasAnyConditions = len(search_conditions.values()) > 0 talent_name = self.pickout_data(search_conditions, 'talent_name') talent_tid = self.pickout_data(search_conditions, 'talent_tid') casting_request_id = self.pickout_data(search_conditions, 'casting_request_id') talent_name_or_tid = self.pickout_data(search_conditions, 'talent_name_or_tid') ages = self.pickout_data(search_conditions, 'ages') availability = self.pickout_data(search_conditions, 'availability') heights = self.pickout_data(search_conditions, 'heights') languages = self.pickout_data(search_conditions, 'languages') position_ids = self.pickout_data(search_conditions, 'position_ids') position_sub_type_ids = self.pickout_data(search_conditions, 'position_sub_type_ids') ratings = self.pickout_data(search_conditions, 'ratings') sexes = self.pickout_data(search_conditions, 'sexes') skill_ids = self.pickout_data(search_conditions, 'skill_ids') sub_skill_ids = self.pickout_data(search_conditions, 'sub_skill_ids') approved = self.pickout_data(search_conditions, 'approved') locked_dance_combination = self.pickout_data( search_conditions, 'locked_dance_combination') talents = Talent.objects.all() # Check talent_tid if talent_tid: try: talents = talents.filter(tid__icontains=talent_tid) except Talent.DoesNotExist: raise Http404 # Check talent_name if talent_name: talents = talents.filter( Q(user__first_name__icontains=talent_name) | Q(user__last_name__icontains=talent_name)) # Check casting_request_id if casting_request_id: casting_request = CastingRequest.objects.get(pk=casting_request_id) # casting_request_talent_ids talent_ids = CastingRequestTalent.objects\ .filter(casting_request_id=casting_request.id)\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter(~Q(id__in=talent_ids)) # Check talent_name_or_tid if talent_name_or_tid: talents = talents.filter( Q(user__first_name__icontains=talent_name_or_tid) | Q(user__last_name__icontains=talent_name_or_tid) | Q(tid__icontains=talent_name_or_tid)) # Check sexes if sexes: talents = talents.filter(Q(sex__in=sexes)) # Check position_ids if position_ids: talent_position_talent_ids = TalentPositionType.objects.filter( Q(position_type_id__in=position_ids) )\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter(Q(id__in=talent_position_talent_ids)) # Check position_sub_type_ids if position_sub_type_ids: talent_position_sub_type_talent_ids = TalentPositionSubType.objects.filter( Q(position_sub_type_id__in=position_sub_type_ids) )\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter( Q(id__in=talent_position_sub_type_talent_ids)) # Check skill_ids if skill_ids: talent_skill_talent_ids = TalentSkill.objects.filter( reduce(or_, (Q(skill_id=skill_id) for skill_id in skill_ids)) )\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter(Q(id__in=talent_skill_talent_ids)) # Check sub_skill_ids if sub_skill_ids: talent_sub_skill_talent_ids = TalentSubSkill.objects.filter(Q(sub_skill_id__in=sub_skill_ids))\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter(Q(id__in=talent_sub_skill_talent_ids)) # Check availability if availability and (availability['start_date'] or availability['end_date']): queries = Q() if availability['end_date']: queries = Q(start_date__lte=parse(availability['end_date'])) if availability['start_date']: queries &= Q(end_date__gte=parse(availability['start_date'])) talent_availabilities_talent_ids = TalentAvailability.objects.filter(queries)\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter( Q(id__in=talent_availabilities_talent_ids)) # Check ages if ages: talents = talents.filter(Q(age_range__in=ages)) # Check heights if heights: queries = Q() for height_range in heights: start_height = height_range['start_height'] end_height = height_range['end_height'] if end_height == 0: end_height = start_height + 1 queries |= Q(height__contained_by=NumericRange( start_height, end_height)) talents = talents.filter(queries) # Check languages if languages: talent_languages_talent_ids = TalentLanguage.objects.filter(language__in=languages)\ .values_list('talent', flat=True)\ .order_by('talent')\ .distinct() talents = talents.filter(Q(id__in=talent_languages_talent_ids)) # Check ratings if ratings: rated_talent_ids = [] for talent in talents: talent_average_rating = TalentRating.objects.filter(talent=talent)\ .aggregate(Avg('rating'))['rating__avg'] if talent_average_rating: for rating_range in ratings: if (talent_average_rating >= rating_range['start_rating']) and ( talent_average_rating <= rating_range['end_rating']): rated_talent_ids.append(talent.id) talents = talents.filter(Q(id__in=rated_talent_ids)) # Check approved if approved is not None: talents = talents.filter(approved=approved) if locked_dance_combination: talents = talents.filter( locked_dance_combination=locked_dance_combination) talents = self.check_sort_condition(talents, search_conditions) # Logging user = request.user if user and user.type != 'agency' and len( talents) > 0 and hasAnyConditions: for talent in talents: UserNoteManager.search_logger( None, user, talent.user, 'TALENT APPEARED INSEARCH BY {finder}'.format(finder=user), user) serializer = TalentSerializer(talents, many=True) return Response(serializer.data)
def put(self, request, pk, format=None): talent_item = self.get_object(pk) talent_data = request.data # pick out user data user_data = self.pickout_data(talent_data, 'user') # pick out position sub type data talent_position_type_data = self.pickout_data(talent_data, 'talent_position_type') # pick out position sub type data talent_position_sub_type_data = self.pickout_data( talent_data, 'talent_position_sub_type') # pick out multiple position sub types data talent_position_sub_types_data = self.pickout_data( talent_data, 'talent_position_sub_types') # pick out skills data talent_skills_data = self.pickout_data(talent_data, 'talent_skills') # pick out sub skills data talent_sub_skills_data = self.pickout_data(talent_data, 'talent_sub_skills') # pick out visa data talent_visas_data = self.pickout_data(talent_data, 'talent_visas') # pick out approved data # approved_data = self.pickout_data(talent_data, 'approved') # pick out locked_dance_combination # locked_dance_combination_data = self.pickout_data(talent_data, 'locked_dance_combination') print('==== talent_data: ', talent_data) print('==== talent_skills_data: ', talent_skills_data) print('==== talent_sub_skills_data: ', talent_sub_skills_data) serializer = TalentSerializer(talent_item, data=talent_data) # Reset tid if talent_position_type_data: serializer.tid = self.generate_tid_by_one( talent_item, talent_position_type_data) if serializer.is_valid(): serializer.save() # In the case approved or locked_dance_combination, logging agency = request.user if 'approved' in talent_data: approved = talent_data['approved'] note = 'TALENT {approve_status} by {admin}'.format( approve_status='Approved' if approved else 'Rejected', admin=agency.first_name) UserNoteManager.profile_logger(agency, None, talent_item.user, note, talent_item.user) if 'locked_dance_combination' in talent_data: locked_dance_combination = talent_data[ 'locked_dance_combination'] note = 'Lockout Reset by Agent ({admin})'.format( admin=agency.first_name) if locked_dance_combination: note = 'TALENT LOCKED OUT FOR MULTIPLE DOWNLOADS' UserNoteManager.dance_combination_logger( None, None, talent_item.user, note, talent_item.user) if 'tid' in talent_data: tid = talent_data['tid'] note = 'Changed to {tid} by {admin}'.format( tid=tid, admin=agency.first_name) UserNoteManager.tid_logger(None, None, talent_item.user, note, talent_item.user) # Check and save position sub type if talent_position_type_data: self.delete_all_talent_position_and_skill(talent_item) self.save_talent_position_type(talent_item, talent_position_type_data) # Check and save position sub type if talent_position_sub_type_data: self.save_talent_position_sub_type( talent_item, talent_position_sub_type_data, talent_position_type_data) # Check and save multiple position sub types if talent_position_sub_types_data: self.save_talent_position_sub_types( talent_item, talent_position_sub_types_data, talent_position_type_data) # Check and save skills if talent_skills_data: self.save_talent_skills(talent_item, talent_skills_data) # Check and save skills if talent_sub_skills_data: self.save_talent_sub_skills(talent_item, talent_sub_skills_data) # Check and save visa types if talent_visas_data: self.save_talent_visas(talent_item, talent_visas_data) return Response(request.data, status=status.HTTP_200_OK) return Response({'error': serializer.errors}, status=status.HTTP_400_BAD_REQUEST)