def post(self, request):
ser = AddReviewSerializer(data=request.data)
if ser.is_valid():
ser.save(addresser=request.user)
id = request.data.get("addressee")
profile = self.get_profile(id)
reviews = Review.objects.filter(addressee__id=id)
sum = 0
for review in reviews:
sum = sum + review.estimation
rating = sum / len(reviews)
estimation = request.data.get("estimation")
positiveAssessment = profile.positiveAssessment
negativeAssessment = profile.negativeAssessment
if(float(estimation) > 3):
positiveAssessment += 1
else:
negativeAssessment += 1
profileSerializer = ProfileSerializer(instance=profile, data={}, partial=True)
if profileSerializer.is_valid():
profileSerializer.save(rating = rating, positiveAssessment = positiveAssessment, negativeAssessment = negativeAssessment)
return Response(rating, status=200)
else:
logger.error(ser.error_messages)
return Response(status=400)
def post(self, request):
ser = AddDecisionSerializer(data=request.data)
if ser.is_valid():
ser.save(arbitrator=request.user)
task = self.get_object(request.data.get("dispute"))
rightContractor = request.data.get("rightContractor")
if(int(rightContractor) == task.contractor.id):
profileContractor = self.get_profile(task.contractor)
balance = profileContractor.balance + task.price
profileSerializer = ProfileSerializer(instance=profileContractor, data={}, partial=True)
if profileSerializer.is_valid():
profileSerializer.save(balance = balance)
self.updateHistory(task.id)
else:
if (int(rightContractor) == task.author.id):
profileSender = self.get_profile(task.author)
balance = profileSender.balance + task.price
profileSerializer = ProfileSerializer(instance=profileSender, data={}, partial=True)
if profileSerializer.is_valid():
profileSerializer.save(balance = balance)
paymentHistory = self.get_payment(task.id)
self.check_object_permissions(request, paymentHistory)
paymentHistory.delete()
serializer = TaskSerializer(instance=task, data={}, partial=True)
if serializer.is_valid():
serializer.save(state=STATE.resolved.value)
return Response(status=200)
else:
logger.error(ser.error_messages)
return Response(status=400)
class AuthorizedProfileSerializer(serializers.ModelSerializer):
user = ProfileSerializer(source="user.profile", read_only=True)
follow_status = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Profile
fields = ['user', 'biography', 'image', 'isPrivate', 'follow_status']
def get_follow_status(self, profile):
visiter = self.context.get("request_user")
if not visiter:
return None
elif visiter.pk == profile.user.pk:
return "is_owner"
elif FollowRequest.objects.filter(sender=visiter,
receiver=profile.user,
accepted=True).exists():
return "following"
elif FollowRequest.objects.filter(sender=visiter,
receiver=profile.user,
accepted=False).exists():
return "sent"
elif FollowRequest.objects.filter(sender=visiter,
receiver=profile.user).count() == 0:
return "not_sent"
class PostSerializer(serializers.ModelSerializer):
author = ProfileSerializer(source="author.profile", read_only=True)
image = serializers.SerializerMethodField(read_only=True)
likes = serializers.SerializerMethodField(read_only=True)
is_liked = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Post
fields = [
'author', 'id', 'image', 'title', 'content', 'likes', 'is_liked',
'date_posted'
]
def get_image(self, post):
return post.author.profile.image.url
def get_likes(self, post):
return post.likes.count()
def get_is_liked(self, post):
user = self.context.get("request_user")
if user in post.likes.all():
return True
else:
return False
class LikeNotificationSerializer(serializers.ModelSerializer):
sender = ProfileSerializer(source="sender.profile", read_only=True)
sender_image = serializers.SerializerMethodField(read_only=True)
receiver = ProfileSerializer(source="receiver.profile", read_only=True)
post = PostForNotificationsSerializer(read_only=True)
notification_type = serializers.SerializerMethodField(read_only=True)
class Meta:
model = LikeNotification
fields = [
'sender', 'receiver', 'post', 'timestamp', 'viewed',
'notification_type', 'sender_image'
]
def get_sender_image(self, obj):
return obj.sender.profile.image.url
def get_notification_type(self, obj):
return 'like'
def get(self, request, pk, format=None):
task = self.get_object(pk)
doneJobs = DoneJob.objects.filter(task__category=task.category)
authors = []
for job in doneJobs:
profile = Profile.objects.get(user=job.author)
if profile not in authors and job.author != task.author:
authors.append(Profile.objects.get(user=job.author))
authors = sorted(authors, key=byRatingSort, reverse=True)[:10]
serializer = ProfileSerializer(authors, many=True)
return Response(serializer.data)
def put(self, request, pk, format=None):
try:
snippet = self.get_object(pk)
dataDict = json.dumps(request.data)
dataString = json.loads(dataDict)
profile = self.get_profile(request.user)
if(profile.balance<0):
return Response("insufficient cash", status=400)
profileDict = ProfileSerializer(profile)
profileSerializer = ProfileSerializer( instance=profile, data={}, partial=True)
req = Request.objects.filter(task=snippet)
if(not snippet.approved and dataString["contractor"] and request.user == snippet.author and req):
serializer = ApprovedTaskSerializer(
instance=snippet, data=request.data, partial=True)
self.check_object_permissions(request, snippet)
self.addHistory(request.user.id, dataString["contractor"], snippet.price, snippet.id)
if profileSerializer.is_valid():
newBalance = profile.balance - snippet.price
profileSerializer.save(balance = newBalance)
if serializer.is_valid():
serializer.save(state=STATE.inProgress.value)
return Response(serializer.data)
return Response(serializer.errors, status=400)
except:
return Response(status=400)
class LatestMessageSerializer(serializers.ModelSerializer):
user = ProfileSerializer(source="user.profile", read_only=True)
latest_message = serializers.SerializerMethodField(read_only=True)
class Meta:
model = Profile
fields = ['id', 'image', 'user', 'latest_message']
def get_latest_message(self, profile):
user = self.context.get('request_user')
message = Message.objects.filter(receiver=user,
sender=profile.user).last()
message = Message.objects.filter(
Q(receiver=user, sender=profile.user)
| Q(receiver=profile.user, sender=user)).distinct().order_by(
"-timestamp").first()
return MessageSerializer(message, context={"request_user": user}).data
def get(self, request, pk, format=None):
try:
snippet = self.get_object(pk)
profile = self.get_profile(snippet.contractor)
profileDict = ProfileSerializer(profile)
profileSerializer = ProfileSerializer(instance=profile, data={}, partial=True)
req = Request.objects.filter(task=snippet)
if(profile and request.user == snippet.author and req):
serializer = ApprovedTaskSerializer(instance=snippet, data=request.data, partial=True)
self.check_object_permissions(request, snippet)
self.updateHistory(snippet.id)
if profileSerializer.is_valid():
newBalance = profile.balance + snippet.price
profileSerializer.save(balance = newBalance)
if serializer.is_valid():
serializer.save(state=STATE.completed.value)
return Response(serializer.data)
return Response(serializer.errors, status=400)
except:
return Response(status=400)