class ReviewSeializer(serializers.ModelSerializer):
user = UserDetailSerializer(many=False)
rated_user = UserDetailSerializer(many=False)
class Meta:
model = Review
fields = '__all__'
def get(self, request):
print(self.request.user)
ser = UserDetailSerializer(request.user)
exhibitor = Exhibitor.objects.filter(user=self.request.user)
serializer = ExhibitorSerializer(exhibitor, many=True)
total = serializer.data
for elem in total:
ua = []
es = Bid.objects.filter(mine_exhib_id=elem['id'], work_status=True)
if len(es) > 0:
esr = BidSerializer(es, many=True)
for delta in esr.data:
ua.append(delta["fabs_user"])
else:
bs = Bid.objects.filter(mine_exhib_id=elem['id'])
bsr = BidSerializer(bs, many=True)
for dub in bsr.data:
ua.append(dub["fabs_user"])
elem["FAB_USER"] = ua
portfolio = Portfolio.objects.filter(user=self.request.user)
serial = FabricatorSerializer(portfolio, many=True)
exi_bid = Bid.objects.filter(mine_exhib__user__id=request.user.id)
exi_bid_serial = BidSerializer(exi_bid, many=True)
fab_bid = Bid.objects.filter(fabs_user_id=self.request.user.id,
work_status=False)
fab_bid_serial = BidDetailSerializer(fab_bid, many=True)
qoutes_data = []
if fab_bid_serial.data is not None:
for data in fab_bid_serial.data:
quotes_dict = {}
user_data = User.objects.get(id=data['fabs_user'])
user_data_serial = UserDetailSerializer(user_data,
many=False).data
data['user_company_name'] = user_data_serial['company_name']
data['user_email'] = user_data_serial['email']
data['phone'] = user_data_serial['phone']
data['bid_id'] = data['id']
quote = Exhibitor.objects.get(id=data['mine_exhib'])
quote_serial = ExhibitorSerializer(quote, many=False).data
quotes_dict.update(data)
quotes_dict.update(quote_serial)
qoutes_data.append(quotes_dict)
return Response([
ser.data, {
"exhbhition_request": total
}, {
"Portfolio": serial.data
}, {
"Exhibitor_bid_request": exi_bid_serial.data
}, {
"Fabricator_bid_request": qoutes_data
}
])
def get(self, request, format=None, pk=None, user_pk=None):
exi = ExhibitFab.objects.get(exhibition_id=pk, user_id=user_pk)
serializer = ExhibitFabricators(exi, many=False)
print(serializer.data)
user = User.objects.get(id=serializer.data['user'], is_active=True)
serial = UserDetailSerializer(user, many=False)
return Response(serial.data)
def post(self, request, format=None, exi_pk=None):
user = self.request.user
own_ser = UserDetailSerializer(user, many=False)
my_name = own_ser.data['company_name']
existed = []
confirm = []
for data in request.data['fab_ids']:
fab_user = User.objects.get(pk=data, is_active=True)
exhibhition = Exhibitor.objects.get(pk=exi_pk)
exi_ser = ExhibitorSerializer(exhibhition, many=False)
exhibition_name = exi_ser.data['exhibition']['exhibition_name']
ser = UserDetailSerializer(fab_user, many=False)
devices = FCMDevice.objects.get(user=ser.data['id'])
devices.send_message(title="Notification",
body="Notification from " + my_name +
" You have beed Invited for " +
exhibition_name)
bid = Bid.objects.filter(fabs_user_id=fab_user.id,
mine_exhib_id=exhibhition.id)
if not bid:
confirm.append(fab_user.company_name)
bid = Bid(fabs_user_id=fab_user.id,
mine_exhib_id=exhibhition.id)
bid.save()
serializer = BidSerializer(bid, many=False)
devices = FCMDevice.objects.get(user=ser.data['id'])
devices.send_message(title="Notification",
body="Notification from " + my_name +
" You have beed Invited for " +
exhibition_name)
else:
existed.append(fab_user.company_name)
if confirm:
if existed:
return Response({
"success":
True,
"Message":
"already sended to {}".format(",".join(existed))
})
if confirm:
return Response({"success": True})
if existed:
return Response({
"Message":
"Bid already sended to {}".format(",".join(existed))
})
def get(self, request, format=None):
user = User.objects.filter(role='exhibitor',
is_active=True) #filter(role="exhibitor")
if len(user) > 0:
serialzier = UserDetailSerializer(user, many=True)
return Response(serialzier.data)
else:
return Response("Exhibitor List Empty")
def get(self, request, format=None):
user = User.objects.filter(role='fabricator')
if len(user) > 0:
serialzier = UserDetailSerializer(user, many=True)
return Response(serialzier.data)
else:
return Response("Fabricator List Empty")
def get(self, request, pk=None):
user = User.objects.get(id=pk)
serialzizer = UserDetailSerializer(user, many=False)
senderUser = serialzizer.data
sender = self.request.user
my = Message.objects.filter(sender_id=user.id,
receiver_id=sender.fcm_token,
is_read=False)
serial = MessageSerializer(my, many=True)
senderUser["messages"] = serial.data
return Response(senderUser)
def get(self, request, format=None, pk=None):
exi = ExhibitFab.objects.filter(exhibition_id=pk)
serializer = ExhibitFabricators(exi, many=True)
user_list = []
for data in serializer.data:
user = User.objects.get(id=data['user'], is_active=True)
serial = UserDetailSerializer(user, many=False)
tp = serial.data
tp['selected'] = False
user_list.append(tp)
return Response(user_list)
def UserRating():
rv = User.objects.filter(cron_review=False,is_active=True,is_superuser=False,is_staff=False).first()
if rv:
rv.cron_review = True
rv.save()
serila = UserDetailSerializer(rv,many=False)
ID = serila.data['id']
us = Review.objects.filter(rated_user_id=ID).aggregate(total=Avg(F('rating')))
rate = User.objects.get(id=ID)
rate.avg_rating = us['total']
rate.save()
else:
pass
def post(self, request, pk=None, pk_exi=None):
sender = self.request.user
exi_req = Exhibitor.objects.get(id=pk_exi)
message = request.data.get("message")
reciever = User.objects.get(id=pk)
ser = UserDetailSerializer(reciever, many=False)
send_msg = Message(sender_id=sender.id,
receiver_id=reciever.id,
exhibition_request_id=exi_req.id,
message=message)
send_msg.save()
msg_id = send_msg.id
serialzier = MessageSerializer(send_msg, many=False)
if request.data['shared_image']:
for elem in request.data['shared_image']:
image_data = "data:image/gif;base64," + elem
format, imgstr = image_data.split(';base64,')
filename = str(uuid.uuid4())
data = ContentFile(base64.b64decode(imgstr),
name=filename + '.jpg')
pictures = UpdateMessage()
pictures.message_for_id = msg_id
pictures.update_image = data
pictures.save()
im_data = UpdateMessage.objects.get(id=pictures.id)
ser_image = UpdateImages(pictures, many=False).data
send_msg_serial = MessageSerializer(send_msg, many=False).data
sh_image = UpdateMessage.objects.filter(
message_for=send_msg_serial['id'])
sh_image_serial = UpdateImages(sh_image, many=True)
send_msg_serial['shared_images'] = sh_image_serial.data
devices = FCMDevice.objects.get(user=ser.data['id'])
devices.send_message(title="Message",
body=message,
data={
"sender_id": str(sender.id),
"reciever_id": str(reciever.id)
})
return Response(send_msg_serial, status=status.HTTP_201_CREATED)
class BidSerializer(serializers.ModelSerializer):
fabs_user = UserDetailSerializer(many=False)
class Meta:
model = Bid
fields = '__all__'
def post(self, request):
fcm = request.data.get("fcm_token")
if fcm is None:
return Response({
"Message": "Please provide a fcm token",
"error": True
})
email = None
phone = None
if 'email' in request.data:
if request.data['email'] != "":
email = request.data['email']
else:
pass
if 'phone' in request.data:
if request.data['phone'] != "":
phone = request.data['phone']
else:
pass
if email is None:
if phone is None:
return Response({
"Message": "Please enter email or phone no",
"error": True
})
# if email is not None:
user = CustomAuthentication().authenticate(
email=email, phone=phone, password=request.data.get("password"))
# else:
# user = CustomAuthentication().authenticate(email=email,phone=phone,password=request.data.get("password"))
if user is not None:
ser = UserDetailSerializer(user)
fb = User.objects.get(id=user.id)
fb.fcm_token = fcm
fb.save()
try:
devices = FCMDevice.objects.get(user=ser.data['id'])
except FCMDevice.DoesNotExist:
devices = None
if devices is None:
device = FCMDevice()
device.user = user
device.registration_id = fcm
device.type = "Android"
device.name = "Can be anything"
device.save()
else:
devices.registration_id = fcm
devices.save()
role = ser.data['role']
try:
token = Token.objects.get(user_id=user.id)
except:
token = Token.objects.create(user=user)
return Response({"token": token.key, "role": role, "error": False})
else:
data = {
"error": True,
"msg": "User does not exist or password is wrong"
}
return Response(data, status=status.HTTP_401_UNAUTHORIZED)