def product_search(request):
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
query_string = ''
found_entries = None
if ('q' in request.GET) and request.GET['q'].strip():
query_string = request.GET['q']
entry_query = get_query(query_string, ['productName'])
try:
# Search based on average rating
found_entries = Products.objects.filter(entry_query).order_by('-productAvgRating')
except Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoProductsFound, ''))
entries = []
for results in found_entries :
entries.append(results.productName)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, entries))
def view_details(request):
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
userId = request.session.get('userId').id
messageId = request.GET.get('messageId', False)
if not messageId:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidMessageId, {'messageId': messageId}))
try:
messageId = int(messageId)
except valueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidMessageId, {'messageId': messageId}))
# we already have head message, only has to retrive response
messages = Bargain.models.MessageBoxThreads.objects.filter(Q(messageId=messageId) & (Q(toId=userId) | Q(fromId=userId))).order_by('timestamp').reverse()
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, { 'messages': Helpers.jsonizeDjangoObject(messages)}))
def view_summary(request):
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
userId = request.session.get('userId').id
messages = Bargain.models.MessageBox.objects.filter(userId=userId).order_by('recentResponseTimestamp').reverse()
skip = request.GET.get('skip', False)
if not skip:
skip = 0
else:
try:
skip = int(skip)
except ValueError:
skip = 0
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, {'messages' : Helpers.jsonizeDjangoObject(messages[skip: skip + Helpers.Constants.numMesssagesToReturn])}))
def close(request):
if request.method != 'POST':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotPostRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
messageId = request.POST.get('messageId', False)
try:
message = Bargain.models.MessageBox.objects.get(id=messageId)
except ObjectDoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidMessageId, ''))
user = request.session.get('userId')
if message.userId != user.id:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidMessageId, {'notOwner' : messageId }))
message.isActive = False
message.save()
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, {'deletedMessageId': messageId}))
def logout(request):
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
Helpers.delete_user_session(request)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, 'logged out'))
def product_specs(request):
# Validate if its a GET request
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
# Allow only if the user session is active.
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
productId = request.GET.get('productId')
# Validate the product ID
if not productId or not productId.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
try:
product = Products.objects.get(id = productId)
except Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
try :
brand = ProductBrands.objects.get(id = product.productBrandId_id)
except ProductBrands.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidBrandId, { "BrandId": product.productBrandId_id } ))
# Populate Product Name and Brand Name since they are available at this point
allDetailsDict = dict()
allDetailsDict['Product Name'] = product.productName
allDetailsDict['Brand Name'] = brand.brandName
# Filter to fetch multiple objects as opposed to get
try :
specs = ProductSpecs.objects.filter(productId_id=productId)
except ProductSpecs.DoesNotExist :
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoSpecsFound, ''))
# Iterate all Key Value pairs for this product and display the specs
for spec in specs :
allDetailsDict[spec.key] = str(spec.value)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, allDetailsDict))
def rate_product(request):
if request.method != 'POST':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotPostRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
productId = request.POST.get('productId', False)
if not productId or not productId.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
ratingVal = request.POST.get('ratingVal', False)
if not ratingVal or not ratingVal.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidRatingValue, ratingVal))
ratingVal = int(ratingVal)
productId = int(productId)
if ratingVal < 0 or ratingVal > 5:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidRatingValue, ratingVal))
try:
product = Products.objects.get(id = productId)
except Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
# session is validated, safe to take userId from session
ProductRatings.objects.create(productId = product, userId = request.session['userId'], ratingVal = ratingVal)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, ''))
def review_product(request):
if request.method != 'POST':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotPostRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
productId = request.POST.get('productId', False)
if not productId or not productId.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
reviewVal = request.POST.get('reviewVal', False)
if not reviewVal:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidRatingValue, reviewVal))
productId = int(productId)
# validate review, avoid overflow
reviewVal = reviewVal[:1024]
try:
product = Product.models.Products.objects.get(id = productId)
except Product.models.Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
# session is validate, safe to take userId from session
Product.models.ProductReview.objects.create(productId = product, userId = request.session['userId'], reviewVal = reviewVal)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, ''))
def product_reviews(request):
# Validate if its a GET request
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
# Allow only if the user session is active.
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
productId = request.GET.get('productId')
# Validate the product ID
if not productId or not productId.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
topNReviews = []
startFound = request.GET.get('from')
endFound = request.GET.get('to')
# Check if from/to parameters are set in GET request, else return 10 recent reviews by default
if not startFound and not endFound :
try:
topNReviews = ProductReviews.objects.filter(productId_id=productId)[:Settings.DEFAULT_LISTING_COUNT]
except ProductReviews.DoesNotExist :
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoReviewsFound, ''))
if not startFound and endFound :
try:
end = int(endFound)
topNProducts = ProductReviews.objects.filter(productId_id=productId)[:end]
except ProductReviews.DoesNotExist :
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoReviewsFound, ''))
sendReviews = []
if startFound :
start = int(startFound)
if not endFound :
try:
topNReviews = ProductReviews.objects.filter(productId_id=productId)[start : start + Settings.DEFAULT_LISTING_COUNT]
except ProductReviews.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoReviewsFound, ''))
else :
# Both from and to are present
end = int(endFound)
try:
topNReviews = ProductReviews.objects.filter(productId_id=productId)[start : end]
except ProductReviews.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoReviewsFound, ''))
for r in topNReviews :
sendReviews.append(r.reviewVal)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, sendReviews))
def product_list(request):
if request.method != 'GET':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotGetRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
categoryId = request.GET.get('categoryId')
# Validate the category ID
if not categoryId or not categoryId.isdigit():
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidCategoryID, categoryId))
startFound = request.GET.get('from')
endFound = request.GET.get('to')
orderBy = ''
# Can be extended to any kind of filtering/sorting based on Product Model attributes
availableFilters = ['brandFilter', 'priceFilter']
availableOrderings = ['popularity', 'reviewCount']
# TODO : Use Q() objects to efficiently handle multiple filters and sortby.
# for filter in availableFilters :
# if filter in request.GET.keys() :
topNProducts = []
# Check if from/to parameters are set in GET request, else return 10 popular products by default
if not startFound and not endFound :
try:
topNProducts = Products.objects.filter(productCategoryId_id=categoryId)[:Settings.DEFAULT_LISTING_COUNT]
except Products.DoesNotExist :
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoProductsFound, categoryId))
if not startFound and endFound :
try:
end = int(endFound)
topNProducts = Products.objects.filter(productCategoryId_id=categoryId)[:end]
except Products.DoesNotExist :
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoProductsFound, categoryId))
if startFound :
start = int(startFound)
if not endFound :
try:
topNProducts = Products.objects.filter(productCategoryId_id=categoryId)[start : start + Settings.DEFAULT_LISTING_COUNT]
except Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoProductsFound, categoryId))
else :
# Both from and to are present
end = int(endFound)
try:
topNProducts = Products.objects.filter(productCategoryId_id=categoryId)[start : end]
except Products.DoesNotExist:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NoProductsFound, ''))
sendNProducts = []
for item in topNProducts :
sendNProducts.append([item.productName, item.productMinPrice, item.productMaxPrice, item.productAvgRating] )
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, sendNProducts))
def send(request):
if request.method != 'POST':
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.NotPostRequest, ''))
if not Helpers.validate_user_session(request):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidUserSession, ''))
selectionType = request.POST.get('selectionType', False)
if selectionType is False:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidSelectionType, selectionType))
try:
selectionType = int(selectionType)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidSelectionType, selectionType))
productId = None
brandId = None
categoryId = None
# we should get either one of these
if selectionType == Helpers.Constants.SelectionType.Product:
productId = request.POST.get('productId', False)
if productId is False:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
try:
productId = int(productId)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidProductId, productId))
elif selectionType == Helpers.Constants.SelectionType.Brand:
brandId = request.POST.get('brandId', False)
if brandId is False:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidBrandId, brandId))
try:
brandId = int(brandId)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidBrandId, brandId))
elif selectionType == Helpers.Constants.SelectionType.Category:
categoryId = request.POST.get('categoryId', False)
if categoryId is False:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidCategoryID, categoryId))
try:
categoryId = int(categoryId)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidCategoryID, categoryId))
else:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidSelectionType, selectionType))
if productId is None and brandId is None and categoryId is None:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidSelectionType, selectionType))
interestedInSimilar = request.POST.get('interestedInSimilar', False) != False
latitude = request.POST.get('latitude', False)
longitude = request.POST.get('longitude', False)
# http://stackoverflow.com/questions/6536232/validate-latitude-and-longitude
if not latitude:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLatitude, latitude))
try:
latitude = float(latitude)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLatitude, latitude))
if latitude < -90 or latitude > 90:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLatitude, latitude))
if not longitude:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLongitude, longitude))
try:
longitude = float(longitude)
except ValueError:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLongitude, longitude))
if longitude < -180 or longitude > 180:
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidLongitude, longitude))
message = request.POST.get('message', False)
if not message or not Helpers.validateMessage(message):
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.InvalidBargainMessage, message))
# TODO - search radius
tiles = Helpers.overlapping_tiles(latitude, longitude)
Helpers.logger.debug('overlapping tiles {0}'.format('\t'.join(tiles)))
# we user selected product, we will send notification to potential
# all sellers who sells this product, this brand and this category
# in ranking, we use whether user is interested in similar product or
# not to truncate
if productId:
row = Product.models.Products.objects.get(id=productId)
brandId = row.brandId_id
row = Product.models.ProductBrands.objects.get(id=brandId)
categoryId = row.categoryId_id
elif brandId:
row = Product.models.ProductBrands.objects.get(id=brandId)
categoryId = row.categoryId_id
Helpers.logger.debug('productId {} brandId {} categoryId {}'.format(productId, brandId, categoryId))
routes = []
if productId:
routes.extend([(t, productId, Helpers.Constants.SelectionType.Product) for t in tiles])
if brandId:
routes.extend([(t, brandId, Helpers.Constants.SelectionType.Brand) for t in tiles])
if categoryId:
routes.extend([(t, categoryId, Helpers.Constants.SelectionType.Category) for t in tiles])
Helpers.logger.debug('Routes {}'.format('\t'.join([str(t) for t in routes])))
sellers = []
sellerIds = {}
for r in routes:
rows = Bargain.models.MessageRouter.objects.filter(tileId = r[0], productSelectionId = r[1], productSelectionType = r[2])
for s in rows:
if s.sellerId in sellerIds:
continue
sellerIds[s.sellerId] = True
sellers.append(s)
Helpers.logger.debug('Sellers {}'.format('\t'.join([str(s.sellerId) for i in sellers])))
user = request.session.get('userId')
# do some ranking
sellers = Helpers.rankeSellers(sellers)
# create message
messageObj = Bargain.models.MessageBox.objects.create(userId=user.id, headMessage=message, userAppId=user.userAppId)
shortMessage = Helpers.shortenMessage(message)
for seller in sellers:
# add message for seller
# create threads
Bargain.models.MessageBoxThreads.objects.create(messageId = messageObj, fromId = user.id, toId = seller.sellerId, message=message)
Bargain.models.NotificationsQueue.objects.create(appId=seller.sellerAppId, shortMessage=shortMessage)
return HttpResponse(Helpers.create_json_output(Helpers.StatusCodes.Success, {'numOfSeller': len(sellers)}))
