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)
