def get(self, request, pk, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
username = ""
first_name = ""
last_name = ""
user_rating = 0
user_data = []
if user != None:
try:
updateUserRating(pk)
profile = Profile.objects.get(user=pk)
profile_user = User.objects.get(pk=pk)
username = profile_user.username
first_name = profile.first_name
last_name = profile.last_name
user_rating = profile.user_rating
email = profile_user.email
user_data.append(username)
user_data.append(first_name)
user_data.append(last_name)
user_data.append(user_rating)
user_data.append(email)
return Response(user_data)
except Profile.DoesNotExist:
return Response({'message': 'This user does not exists.'},
status=status.HTTP_400_BAD_REQUEST)
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def get(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
listings = []
if user != None:
buyings = Buying.objects.filter(user=user)
sellings = Selling.objects.filter(user=user)
if buyings:
serializer = BuyingSerializer(buyings,
many=True,
context={'request': request})
listings.append(serializer.data)
if sellings:
serializer = SellingSerializer(sellings,
many=True,
context={'request': request})
listings.append(serializer.data)
if not listings:
return Response({'message': 'You have no listings.'},
headers={'token': user.token})
return Response(listings, headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
# Needs 'user' from the profile data
# which is an integer. Pass it as form data
# as 'rated_user'. Also needs a float, 'rating_value'.
if user != None:
rating_user = user
rated_user = User.objects.get(
uid=int(request.POST.get('rated_user')))
rating_value = float(request.POST.get('rating_value'))
rating = None
try:
rating = Rating.objects.get(rating_user=rating_user,
rated_user=rated_user)
rating.rating_value = rating_value
rating.save()
except Rating.DoesNotExist:
rating = Rating.objects.create(rating_user=rating_user,
rated_user=rated_user,
rating_value=rating_value)
if rating != None:
updateUserRating(rated_user)
profile = Profile.objects.get(user=rated_user)
serializer = ProfileSerializer(profile,
context={'request': request})
return Response(serializer.data, headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def get(self, request, pk, format=None):
token = request.META.get('HTTP_TOKEN')
if token != "":
user = authenticate(token)
if user != None:
if user.user_admin == True:
try:
queryset = Buying.objects.get(pk=pk)
serializer = BuyingSerializer(
queryset, context={'request': request})
return Response(serializer.data,
headers={'token': user.token})
except Buying.DoesNotExist:
return Response("That listing does not exist.",
status=status.HTTP_400_BAD_REQUEST)
else:
try:
queryset = Buying.objects.get(pk=pk, user=user)
serializer = BuyingSerializer(
queryset, context={'request': request})
return Response(serializer.data,
headers={'token': user.token})
except Buying.DoesNotExist:
return Response("That listing does not exist.",
status=status.HTTP_400_BAD_REQUEST)
return Response("Please login to start browsing.",
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
if user != None:
updateUserRating(user)
profile = Profile.objects.get(user=user)
serializer = ProfileSerializer(profile,
context={'request': request})
return Response(serializer.data, headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
if user != None:
listing_type = request.POST.get('listing_type')
listing_uid = int(request.POST.get('listing_uid'))
updateRecent(user, listing_type, listing_uid)
return Response(
{'message': 'Listing has been added to recent history.'},
headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def delete(self, request, pk, format=None):
token = request.META.get('HTTP_TOKEN')
if token != "":
user = authenticate(token)
if user != None:
if user.user_admin == True:
listing = Selling.objects.get(pk=pk)
listing.delete()
return Response("Successfully removed listing.", status=status.HTTP_204_NO_CONTENT, headers={'token':user.token})
else:
listing = Selling.objects.get(pk=pk, user=user)
listing.delete()
return Response("Successfully removed listing.", status=status.HTTP_204_NO_CONTENT, headers={'token':user.token})
return Response("Please login to start browsing.", status=status.HTTP_400_BAD_REQUEST)
def get(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
if user != None:
if user.user_admin:
users = User.objects.all()
if users:
serializer = UserSerializer(users, many=True, context={'request':request})
return Response(serializer.data)
else:
serializer = UserSerializer(user, context={'request':request})
return Response(serializer.data, headers={'token':user.token})
return Response({'message' : 'Please log in to browse.'}, status=status.HTTP_401_UNAUTHORIZED)
def get(self, request, format=None):
token = self.request.META.get('HTTP_TOKEN')
print(token)
if token != "":
user = authenticate(token)
if user != None:
if user.user_admin == True:
queryset = Selling.objects.all()
serializer = SellingSerializer(queryset, many=True, context={'request':request})
return Response(serializer.data)
else:
queryset = Selling.objects.all().filter(user=user)
serializer = SellingSerializer(queryset, many=True, context={'request':request})
return Response(serializer.data)
return Response({'message' : 'Please log in to browse.'}, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
if token != "":
user = authenticate(token)
if user != None:
req_user = user
if request.POST.get('user_id') != None:
try:
req_user = User.objects.get(pk=int(request.POST.get('user_id')))
except:
return Response({'message' : "Requested user doesn't exist."})
# Each thing that has request.POST.get() needs to be from a form.
# Try and enforce float format i.e 0.0 for float fields.
listing_title = request.POST.get('listing_title')
listing_type = 'selling'
item_price = float(request.POST.get('item_price'))
item_type = request.POST.get('item_type')
item_sex = request.POST.get('item_sex')
item_brand = request.POST.get('item_brand')
item_model = request.POST.get('item_model')
item_colour = request.POST.get('item_colour')
item_condition = request.POST.get('item_condition')
item_material = request.POST.get('item_material')
item_size = float(request.POST.get('item_size'))
item_notes =request.POST.get('item_notes')
item_image = None
if request.FILES.get('item_image'):
item_image = request.FILES.get('item_image')
if user.user_admin == True:
selling = Selling.objects.create(user=req_user, item_price=item_price, listing_type=listing_type,
listing_title=listing_title, item_sex=item_sex, item_brand=item_brand,
item_type=item_type, item_model=item_model, item_colour=item_colour, item_condition=item_condition,
item_material=item_material, item_size=item_size, item_notes=item_notes, image_url=item_image)
return Response({'message' : "Successfully created item for {req_user.username}."}, headers={'token':user.token})
else:
selling = Selling.objects.create(user=user, item_price=item_price,
listing_title=listing_title, item_sex=item_sex, item_brand=item_brand, listing_type=listing_type,
item_type=item_type, item_model=item_model, item_colour=item_colour, item_condition=item_condition,
item_material=item_material, item_size=item_size, item_notes=item_notes, image_url=item_image)
return Response({'message' : 'Successfully created item!', 'selling_id' : selling.uid}, headers={'token':user.token})
return Response({'message' : 'Please log in to browse.'}, status=status.HTTP_401_UNAUTHORIZED)
return Response({'message' : 'Please log in to browse.'}, status=status.HTTP_401_UNAUTHORIZED)
def get(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
user = authenticate(token)
if user != None:
recent = Recent.objects.get(user=user)
buying_string = recent.recent_buyings
selling_string = recent.recent_sellings
print(buying_string)
print(selling_string)
if buying_string == "" and selling_string == "":
return Response(
{'message': 'There are no recently visited listings.'})
buying_list = stringToList(buying_string)
selling_list = stringToList(selling_string)
print(buying_list)
print(selling_list)
recent_listings = []
missing_listings = []
if buying_list:
for uid in buying_list:
try:
listing = Buying.objects.get(pk=uid)
serializer = BuyingSerializer(
listing, context={'request': request})
recent_listings.append(serializer.data)
except Buying.DoesNotExist:
missing_listings.append(uid)
if not missing_listings:
for uid in missing_listings:
buying_list.remove(uid)
missing_listings = []
if selling_list:
for uid in selling_list:
try:
listing = Selling.objects.get(pk=uid)
serializer = SellingSerializer(
listing, context={'request': request})
recent_listings.append(serializer.data)
except Selling.DoesNotExist:
missing_listings.append(uid)
if not missing_listings:
for uid in missing_listings:
selling_list.remove(uid)
if not buying_list:
recent.recent_buyings = ""
else:
recent.recent_buyings = listToString(buying_list)
if not selling_list:
recent.recent_sellings = ""
else:
recent.recent_sellings = listToString(selling_list)
recent.save()
return Response(recent_listings, headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
def get(self, request, pk, format=None):
pkSpec = None
dbSpec = None
token = request.META.get('HTTP_TOKEN');
user = authenticate(token)
if user != None:
if user.user_admin == True:
try:
pkSpec = Selling.objects.get(pk=pk)
except Selling.DoesNotExist:
return Response({"message" : "Listing does not exists."}, status=status.HTTP_400_BAD_REQUEST)
else:
try:
pkSpec = Selling.objects.get(pk=pk, user=user)
except Listing.DoesNotExist:
return Response({"message" : "Listing does not exists."}, status=status.HTTP_400_BAD_REQUEST)
else:
return Response({"message" : "Please login to start browsing."}, status=status.HTTP_401_UNAUTHORIZED)
dbSpecs = Buying.objects.exclude(user=pkSpec.user)
if not dbSpecs:
return Response({"message" : "There are no listings to compare to at this time."}, status=status.HTTP_400_BAD_REQUEST, headers={'token':user.token})
strictList = []
matchingVals = []
for dbSpec in dbSpecs:
if dbSpec.min_price <= pkSpec.item_price and dbSpec.max_price >= pkSpec.item_price:
validFields = 8
typePc = matchType(pkSpec.item_type, dbSpec.item_type, strictList)
sexPc = matchSex(pkSpec.item_sex, dbSpec.item_sex, strictList)
brandPc = matchBrand(pkSpec.item_brand, dbSpec.item_brand, strictList)
modelPc = 0
if brandPc == 100 or brandPc == -1:
modelPc = matchModel(pkSpec.item_model, dbSpec.item_model, strictList)
colourPc = matchColour(pkSpec.item_colour, dbSpec.item_colour, strictList)
conditionPc = matchCondition(pkSpec.item_condition, dbSpec.item_condition, strictList)
materialPc = matchMaterial(pkSpec.item_material, dbSpec.item_material, strictList)
sizePc = matchSize(pkSpec.item_size, dbSpec.item_size, strictList)
totalPc = 0.0
valueList = [typePc, sexPc, brandPc, modelPc, colourPc, conditionPc, materialPc, sizePc]
for value in valueList:
if value == -2:
dbSpec.item_matching = -2
break
if value != -1:
totalPc = totalPc + value
else:
validFields = validFields - 1
if dbSpec.item_matching != -2:
if validFields == 0 :
dbSpec.item_matching = 100.0
else:
dbSpec.item_matching = int(totalPc/validFields)
if dbSpec.item_matching > 100.0:
dbSpec.item_matching = 100.0
serializer = BuyingSerializer(dbSpec, context={'request':request})
matchingVals.append(serializer.data)
if not matchingVals:
return Response({"message" : "There are no matching listings at this time."}, headers={'token':user.token})
return Response(matchingVals)
def post(self, request, format=None):
token = request.META.get('HTTP_TOKEN')
if token != "":
user = authenticate(token)
if user != None:
if request.POST.get('user_id') != None:
try:
req_user = User.objects.get(
pk=int(request.POST.get('user_id')))
except:
return Response(
{'message': "Requested user doesn't exist."})
else:
req_user = ''
listing_type = request.POST.get('listing_type')
listing_title = request.POST.get('listing_title')
item_type = request.POST.get('item_type')
type_priority = request.POST.get('type_priority')
type_strict = request.POST.get('type_strict')
item_sex = request.POST.get('item_sex')
sex_priority = request.POST.get('sex_priority')
sex_strict = request.POST.get('sex_strict')
item_brand = request.POST.get('item_brand')
brand_priority = request.POST.get('brand_priority')
brand_strict = request.POST.get('brand_strict')
item_model = request.POST.get('item_model')
model_priority = request.POST.get('model_priority')
model_strict = request.POST.get('model_strict')
item_colour = request.POST.get('item_colour')
colour_priority = request.POST.get('colour_priority')
colour_strict = request.POST.get('colour_strict')
item_condition = request.POST.get('item_condition')
condition_priority = request.POST.get('condition_priority')
condition_strict = request.POST.get('condition_strict')
item_material = request.POST.get('item_material')
material_priority = request.POST.get('material_priority')
material_strict = request.POST.get('material_strict')
item_size = request.POST.get('item_size')
size_priority = request.POST.get('size_priority')
size_strict = request.POST.get('size_strict')
item_notes = request.POST.get('item_notes')
#admin_fields = {'req_user' : req_user, 'listing_type' : listing_type, 'listing_title' : listing_title, 'item_type' : item_type, 'type_priority' : type_priority, 'type_strict' : type_strict, 'item_sex' : item_sex,
#'sex_priority' : sex_priority, 'sex_strict' : sex_strict, 'item_brand' : item_brand, 'brand_priority' : brand_priority, 'brand_strict' : brand_strict, 'item_model' : item_model, 'model_priority' : model_priority, 'model_strict' : model_strict,
#'item_colour' : item_colour, 'colour_priority' : colour_priority, 'colour_strict' : colour_strict, 'item_material' : item_material, '' : material_priority, '' : material_strict, '' : item_size,
#'size_priority' : size_priority, 'size_strict, item_notes' : size_strict, 'item_notes' : item_notes}
if user.user_admin == True:
listing = Listing.objects.create(
user=req_user,
listing_type=listing_type,
listing_title=listing_title,
item_type=item_type,
type_priority=type_priority,
type_strict=type_strict,
item_sex=item_sex,
sex_priority=sex_priority,
sex_strict=sex_strict,
item_brand=item_brand,
brand_priority=brand_priority,
brand_strict=brand_strict,
item_model=item_model,
model_priority=model_priority,
model_strict=model_strict,
item_colour=item_colour,
colour_priority=colour_priority,
colour_strict=colour_strict,
item_condition=item_condition,
condition_priority=condition_priority,
condition_strict=condition_strict,
item_material=item_material,
material_priority=material_priority,
material_strict=material_strict,
item_size=item_size,
size_priority=size_priority,
size_strict=size_strict,
item_notes=item_notes)
return Response(
{
'message':
"Successfully created item for {req_user.username}."
},
headers={'token': user.token})
else:
listing = Listing.objects.create(
user=user,
listing_type=listing_type,
listing_title=listing_title,
item_type=item_type,
type_priority=type_priority,
type_strict=type_strict,
item_sex=item_sex,
sex_priority=sex_priority,
sex_strict=sex_strict,
item_brand=item_brand,
brand_priority=brand_priority,
brand_strict=brand_strict,
item_model=item_model,
model_priority=model_priority,
model_strict=model_strict,
item_colour=item_colour,
colour_priority=colour_priority,
colour_strict=colour_strict,
item_condition=item_condition,
condition_priority=condition_priority,
condition_strict=condition_strict,
item_material=item_material,
material_priority=material_priority,
material_strict=material_strict,
item_size=item_size,
size_priority=size_priority,
size_strict=size_strict,
item_notes=item_notes)
return Response(
{
'message': 'Successfully created item!',
'listing_uid': listing.uid
},
headers={'token': user.token})
return Response({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)
return Respones({'message': 'Please log in to browse.'},
status=status.HTTP_401_UNAUTHORIZED)