def delete(self, request, format=None, *args, **kwargs):
# pId = 0
# if 'product' not in request.POST:
# body_unicode = request.body.decode('utf-8')
# body_data = json.loads(body_unicode)
# if 'product' in body_data:
# pId = body_data['product']
# else:
cId = request.POST.get('cart', 0)
cartItem = CartItem.objects.filter(id=cId)
if not cartItem.exists():
return CustomJSONRenderer().render404('cart', '')
else:
try:
idCart = cartItem.first().cart.id
cartItem.first().delete()
CartItem().update_price(idCart)
except Exception as e:
return CustomJSONRenderer().render500(str(e), '')
cart = Cart.objects.filter(user=request.user)
return CustomJSONRenderer().render(
{
'count':
cart.count(),
'result':
CartSerializer(
cart, many=True, context={
'request': request
}).data
},
status=200)
def get(
self,
request,
slug,
format=None,
):
product = Product.objects.filter(slug=slug)
if not product.exists():
return CustomJSONRenderer().render404('product', '')
print(str(vars(request.session)))
if 'uuid_failure' in request.session:
return CustomJSONRenderer().render(
{'message': 'گزارش توسط شما قبلا ارسال شده است'}, status=400)
if not request.user.is_anonymous:
user = request.user
else:
user = None
request.session['uuid_failure'] = str(
uuid.uuid1(random.randint(0, 281474976710655)))
uuid_failure = request.session['uuid_failure']
Failure.objects.create(product=product.first(),
user=user,
uuid=uuid_failure)
product.update(failure=F('failure') + 1)
return CustomJSONRenderer().render({'success': True}, 200)
def get(self, request, phone='', format=None, *args, **kwargs):
validate_phone(phone)
smsUser = SmsUser.objects.filter(phone=phone)
if not smsUser:
return CustomJSONRenderer().render404('Sms User', '')
smsUser = smsUser.first()
if smsUser.active_at and smsUser.status == 1:
return CustomJSONRenderer().render(
{'message': 'شماره شما قبلا در سیستم فعال شده است.'},
status=400)
now = datetime.now()
time_app = smsUser.send_at + timedelta(minutes=5)
if now.replace(tzinfo=None) > time_app.replace(tzinfo=None):
code_verify = random.randint(1, 3000) * 10
send_verification_sms(request.user,
request,
mobile=phone,
verify_code=code_verify)
SmsUser.objects.filter(pk=smsUser.pk).update(
code_verify=code_verify,
send_at=datetime.now(),
active_at=None)
return CustomJSONRenderer().render({'success': True})
else:
return CustomJSONRenderer().render(
{
'message':
'لطفا بعد از 5 دقیقه دیگر تلاش مجدد برای ارسال پیامک نمایید.'
},
status=400)
def put(self, request, format=None, *args, **kwags):
itemId = request.POST.get('itemId', 0)
itemCount = request.POST.get('itemCount', 1)
itemFound = CartItem.objects.filter(id=itemId)
if not itemFound:
return CustomJSONRenderer().render404('Cart Item', None)
itemFoundFirst = itemFound.first()
itemFoundFirst.count = itemCount
try:
itemFoundFirst.save()
CartItem().update_price(itemFoundFirst.cart.id)
cart = Cart.objects.filter(user=request.user)
return CustomJSONRenderer().render({
'count':
cart.count(),
'result':
CartSerializer(cart, many=True, context={
'request': request
}).data
})
except Exception as e:
return CustomJSONRenderer().render({
'success': False,
'e': str(e)
},
status=500)
def get(self, request):
company_slug = request.GET.get('company', None)
if company_slug:
try:
company = Company.objects.get(slug=company_slug)
score_data = self.get_score_data(company)
return CustomJSONRenderer().renderData(score_data)
except:
return CustomJSONRenderer().render404('company', '')
return CustomJSONRenderer().render404('company', '')
def get(self, request, format=None, *args, **kwargs):
about = About.objects.filter(status=1).first()
if about:
return CustomJSONRenderer().renderData(
AboutSerializer(about,
many=False,
context={
'request': request
}).data)
else:
return CustomJSONRenderer().renderData([])
def get(
self,
request,
format=None,
):
category_frontend_name = ""
categoryId = request.GET.get('category', None)
categorySlug = request.GET.get('category_slug', None)
category = None
if categoryId is not None:
category = Category.objects.filter(id=convert_to_int(categoryId))
elif categorySlug is not None:
category = Category.objects.filter(slug=categorySlug)
if category is not None:
category_name = [i for i in category.values_list("name")]
print("category name:")
print(category_name)
if len(category_name) > 0:
category_frontend_name = category_name[0][0]
products = self.get_queryset(request)
if products is None:
return CustomJSONRenderer().render404('product', '')
companySlug = request.GET.get('company_slug', None)
dataCompany = None
if companySlug:
company = Company.objects.filter(slug=companySlug)
if company.count() > 0:
dataCompany = company.first()
data = ProductSerializer(
products,
many=True,
pop=['explanation_short', 'file', 'gallery', 'like'],
context={
'request': request
}).data
return CustomJSONRenderer().renderData(
OrderedDict([('count', self.page.paginator.count),
('code_count', self.code_count),
('offer_count', self.offer_count),
('next', self.get_next_link()),
('previous', self.get_previous_link()),
('results', data),
('dataCompany',
CompanySerializer(dataCompany,
many=False,
context={
'request': request
},
pop=['available']).data
if dataCompany else None),
('category', category_frontend_name)]))
def get(
self,
request,
slug,
format=None,
):
product = Product.objects.filter(slug=slug)
if not product.exists():
return CustomJSONRenderer().render400()
return CustomJSONRenderer().renderData(
ProductSerializer(product.first(),
context={
'request': request
},
many=False).data)
def post(self, request, format=None, *args, **kwargs):
productId = request.POST.get('product', 0)
if not Product.objects.filter(pk=productId).exists():
return CustomJSONRenderer().render404('Like', '')
# if 'like_session' in request.session:
# return CustomJSONRenderer().render({
# 'message': 'You Have Already Like This Post.'
# }, status=400)
# session = str(uuid.uuid1(random.randint(0, 281474976710655)))
mutable = request.POST._mutable
request.POST._mutable = True
# user = None
# if request.user.is_authenticated:
# user = request.user.pk
request.data.update(user=request.user.pk)
request.data.update(product=productId)
request.data.update(like=1)
# request.data.update(session=request.session)
request.POST._mutable = mutable
# if Like.objects.filter(user__id=request.POST.get('user')).filter(
# product__id=request.POST.get('product')).exists():
# return CustomJSONRenderer().render({
# 'message': 'Liked Before!'
# })
# like = 1
# if int(request.POST.get('like')) not in like:
# return CustomJSONRenderer().render400()
# request.session['like_session'] = session
Product.objects.filter(id=productId).update(click=F('click') + 1)
return self.create(request, *args, **kwargs)
def get(
self,
request,
format=None,
):
print(str(City.objects.count()))
dt = CitySerializer(City.objects.all(), many=True)
return CustomJSONRenderer().renderData(dt.data)
def post(self, request, format=None, *args, **kwargs):
mutable = request.POST._mutable
request.POST._mutable = True
code_verify = random.randint(1, 3000) * 10
request.data.update(status=2)
request.data.update(user=request.user.pk if request.user
and not request.user.is_anonymous else None)
request.data.update(phone=request.POST.get('phone', None))
request.data.update(code_verify=code_verify)
request.POST._mutable = mutable
print('str data sms post', str(request.data))
validate_phone(request.POST.get('phone', ''))
smsUser = SmsUser.objects.filter(phone=request.POST.get('phone'))
if smsUser.filter(status=1):
return CustomJSONRenderer().render(
{'phone': 'شماره شما قبلا ثبت گردیده است'}, status=400)
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
if smsUser.filter(status=2).count() == 0:
self.perform_create(serializer)
else:
sms_user = smsUser.filter(status=2).first()
code_verify = sms_user.code_verify
now = datetime.now()
time_app = sms_user.send_at + timedelta(minutes=5)
if now.replace(tzinfo=None) < time_app.replace(tzinfo=None):
return CustomJSONRenderer().render(
{
'message':
'لطفا بعد از 5 دقیقه دیگر تلاش مجدد برای ارسال پیامک نمایید.'
},
status=400)
send_verification_sms(request.user,
request,
mobile=request.POST.get('phone'),
verify_code=code_verify)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def get(self, request, format=None, *args, **kwargs):
cart = Cart.objects.filter(user=request.user).filter(status=1)
print(str(cart.query))
return CustomJSONRenderer().render({
'count':
cart.count(),
'result':
CartSerializer(cart, many=True, context={
'request': request
}).data
})
def get(self, request, slug=None, format=None):
search = request.GET.get('search', None)
if slug:
slug = str(slug).replace('/', '')
products = self.get_queryset(request, slug)
if products is None:
return CustomJSONRenderer().render404('product', '')
companySlug = request.GET.get('company_slug', None)
dataCompany = None
if companySlug:
company = Company.objects.filter(slug=companySlug)
if company.count() > 0:
dataCompany = company.first()
return CustomJSONRenderer().renderData(
OrderedDict([('count', self.page.paginator.count),
('next', self.get_next_link()),
('previous', self.get_previous_link()),
('results',
ProductSerializer(products,
context={
'request': request
},
many=True).data),
('dataCompany',
CompanySerializer(dataCompany,
many=False,
context={
'request': request
},
pop=['available']).data
if dataCompany else None)]))
# return CustomJSONRenderer().renderData(
# ProductSerializer(products , context={'request': request} , many=True).data)
else:
print('None slug LabelViews ')
PLable = None
if search is not None:
PLable = ProductLabel.objects.filter(Q(name__contains=search))
return CustomJSONRenderer().renderData(
ProductLabelSerializer(PLable, many=True,
pop=['available']).data)
def get(self, request):
query = request.GET.get('q', None)
if query is None:
raise ValidationError('q required')
half_space = ''
query = query.replace(half_space, ' ')
keywords = query.split(' ')
companies = Company.objects.annotate(
catname=Replace('name', Value(' '), Value(''))).annotate(
catname=Replace('catname', Value(half_space), Value(
''))).filter(
reduce(operator.and_, (Q(english_name__icontains=x)
for x in keywords))
| reduce(operator.and_, (Q(catname__icontains=x)
for x in keywords)))
categories = Category.objects.annotate(
catname=Replace('name', Value(' '), Value(''))).annotate(
catname=Replace('catname', Value(half_space), Value(
''))).filter(
reduce(operator.and_, (Q(english_name__icontains=x)
for x in keywords))
| reduce(operator.and_, (Q(catname__icontains=x)
for x in keywords)))
labels = ProductLabel.objects.annotate(
catname=Replace('name', Value(' '), Value(''))).annotate(
catname=Replace('catname', Value(half_space), Value(
''))).filter(
reduce(operator.and_,
(Q(catname__icontains=x) for x in keywords)))
return CustomJSONRenderer().render({
'categories':
CategoryMenuSerializer(
categories,
pop=['all_chatrbazi', 'open_chatrbazi', 'company'],
many=True,
context={
'request': request
}).data,
'companies':
CompanyDetailSerializer(companies,
many=True,
pop=['description', 'product_company'],
context={
'request': request
}).data,
'tags':
ProductLabelSerializer(labels,
many=True,
context={
'request': request
}).data,
})
def get(self, request, format=None):
search = request.GET.get('search', None)
if search is not None:
Companies = Company.objects.filter(
Q(name__contains=search)).distinct()
else:
Companies = None
return CustomJSONRenderer().renderData(
CompanySerializer(Companies,
many=True,
context={
'request': request
}).data)
def get(self, request, id=None, format=None, *args, **kwargs):
print('str id cart in uri factor', str(id))
if id is None:
return CustomJSONRenderer().render404('cart', '')
try:
cart = Cart.objects.filter(user=request.user).filter(status=3).get(
id=id)
except Exception as e:
print('str e in factor ', str(e))
return CustomJSONRenderer().render404('cart', '')
if cart.status == 3:
return CustomJSONRenderer().renderData(
CartSerializer(cart, many=False, context={
'request': request
}).data)
else:
return CustomJSONRenderer().render(
{
'message': u'محصول هم چنان در وضعیت معلق قرار دارد.',
},
status=403)
def get(
self,
request,
format=None,
):
bannerData = Banner.objects.filter(available=True).filter(
Q(expiration_date__gt=datetime.now())
| Q(expiration_date__isnull=True)).order_by('-location')[:10]
data = BannerSerializer(bannerData,
many=True,
context={
'request': request
}).data
return CustomJSONRenderer().renderData(data)
def get(
self,
request,
format=None,
):
companies = self.get_queryset(request)
if companies is None:
return CustomJSONRenderer().render404('company', '')
data = CompanySerializer(companies,
many=True,
pop=[
'available', 'description', 'image',
'link', 'all_available_codes',
'english_name'
],
context={
'request': request
}).data
return CustomJSONRenderer().renderData(
OrderedDict([
('results', data),
]))
def get(
self,
request,
format=None,
):
userData = self.get_queryset(request)
data = UserProductSerializer(userData,
many=True,
context={
'request': request
}).data
return CustomJSONRenderer().renderData(
OrderedDict([
('count', self.page.paginator.count),
('next', self.get_next_link()),
('previous', self.get_previous_link()),
('results', data),
]))
def get(
self,
request,
format=None,
):
new = int(request.GET.get('new', 3))
categoryData = Category.objects.filter(available=True).order_by(
'order', '-id')
categoryDataSerializer = CategoryMenuSerializer(categoryData,
pop=[
'all_chatrbazi',
'open_chatrbazi',
'company',
'english_name',
'available'
],
many=True,
context={
'request': request
}).data
# TODO Cache Data Category
# return CustomJSONRenderer().renderData(categoryDataSerializer)
sumChatrbazi = Product.objects.filter(
Q(expiration_date__gt=datetime.now())
| Q(expiration_date__isnull=True)).aggregate(Sum('chatrbazi'))
# newCompanies = Company.objects.order_by('-id')[:new]
# companySerializerData = CompanySerializer(newCompanies, many=True, pop=['description', 'all_available_codes', ],
# context={'request': request}).data
# print('sql sum all chatrbaazi: ' , str(sumChatrbazi.query))
# print('data sum all chatrbaazi', str(sumChatrbazi))
# if sumChatrbazi.count() > 0:
# sumChatrbazi = sumChatrbazi[0]['sum']
# else:
# sumChatrbazi = 0
return CustomJSONRenderer().render({
'categories':
categoryDataSerializer,
'all_chatrbazi':
sumChatrbazi['chatrbazi__sum'],
# 'new_companies': companySerializerData,
})
def post(self, request):
serializer = self.serializer_class(data=request.data)
serializer.is_valid(raise_exception=True)
data = {}
query = serializer.validated_data
c_id = query.get('id', None)
for q in query:
if q == 'id' or query[q] is None:
continue
size = query[q].get('size', None)
order = query[q].get('order', [])
if order and type(order) == str:
order = [order]
if order and type(order) != list:
raise ValidationError(q + ': order is not a string or list')
if size and isinstance(size, str):
if size.isnumeric():
size = int(size)
else:
size = None
result = self.get_result(request, q, size, order, c_id)
data[q] = result
return CustomJSONRenderer().renderData(data)
def get(self, request):
rank_min = 0.0
query = request.GET.get('q', None)
half_space = ''
query = query.replace(half_space, ' ')
vector = SearchVector('name') + SearchVector('english_name')
# vector = SearchVector('name','english_name')
vector2 = SearchVector('name')
search_query = SearchQuery(query, search_type='phrase')
# categories = Category.objects.annotate(rank=SearchRank(vector, search_query)).filter(
# rank__gt=rank_min).order_by('-rank')
categories = Category.objects.annotate(similarity=TrigramSimilarity('name', query)).filter(
similarity__gt=rank_min).order_by('-similarity')
companies = Company.objects.annotate(rank=SearchRank(vector, search_query)).filter(rank__gt=rank_min).order_by(
'-rank')
labels = ProductLabel.objects.annotate(rank=SearchRank(vector2, search_query)).filter(
rank__gt=rank_min).order_by('-rank')
return CustomJSONRenderer().render({
'categories': CategoryMenuSerializer(categories, pop=['all_chatrbazi', 'open_chatrbazi', 'company'],
many=True, context={'request': request}).data,
'companies': CompanyDetailSerializer(companies, many=True, pop=['description', 'product_company'],
context={'request': request}).data,
'tags': ProductLabelSerializer(labels, many=True, context={'request': request}).data,
})
def put(self, request, phone=None, format=None, *args, **kwargs):
if phone is None:
return CustomJSONRenderer().render400()
validate_phone(phone)
code_verify = request.POST.get('code_verify', None)
if code_verify is None:
return CustomJSONRenderer().render({'code': 'required'},
status=400)
smsUser = SmsUser.objects.filter(phone=phone).filter(status=2)
if smsUser:
smsUser = smsUser.first()
if smsUser.active_at and smsUser.status == 1:
return CustomJSONRenderer().render(
{'message': 'شماره همراه قبلا فعال شده است'}, status=401)
if smsUser.code_verify == code_verify:
SmsUser.objects.filter(pk=smsUser.pk).update(
active_at=datetime.now(), status=1)
return CustomJSONRenderer().render({'success': True},
status=200)
else:
return CustomJSONRenderer().render(
{'message': 'کد تاییدیه درست نمی باشد.'}, status=400)
else:
return CustomJSONRenderer().render404('sms', '')
def post(self, request, format=None, *args, **kwargs):
# body_unicode = request.body.decode('utf-8')
# body_data = json.loads(body_unicode)
pId = request.POST.get('product', 0)
# check exists Product
product = Product.objects.filter(id=pId)
if not product.exists():
return CustomJSONRenderer().render404('product', '')
product = product.first()
if product.is_free or product.price == 0:
return Response(
{'message': 'Product Is Free, can not add to cart'},
status=400)
mutable = request.POST._mutable
request.POST._mutable = True
# if request.user:
# request.data.update('user', 1)
# else:
# request.data.update('user', None)
print('user', str(request.user))
request.data.update(user=request.user.pk)
request.data.update(price=product.price)
request.data.update(total_price=product.price)
request.POST._mutable = mutable
cart = Cart.objects.filter(user=request.user).filter(status=1)
if cart.count() == 0:
cart = self.create(request, *args, **kwargs)
else:
cart = CartSerializer(cart.first(),
many=False,
context={'request': request})
print(str(cart.data['id']))
try:
cItem = CartItem.objects.filter(cart__id=cart.data['id'])
if cItem.filter(product__id=product.id).count() > 0:
cItem = cItem.first()
cItem.count = cItem.count + 1
cItem.total_price = cItem.total_price + cItem.product.price
cItem.save()
else:
cartCreate = CartItem.objects.create(
product=product,
price=product.price,
total_price=product.price,
cart=Cart.objects.get(pk=int(cart.data['id'])),
count=1)
except Exception as e:
raise e
# Cart.objects.filter(id=cart.data['id']).delete()
print('error when create item', str(e))
return Response(
{'message': 'Problem When Add product To Cart Try Again.'})
# Create Item Product
# cart = Cart.objects.get(pk=cart.data['id'])
CartItem().update_price(Cart.objects.get(pk=int(cart.data['id'])).id)
cart = Cart.objects.filter(user=request.user)
return CustomJSONRenderer().render(
{
'count':
cart.count(),
'result':
CartSerializer(cart, many=True, context={
'request': request
}).data
},
status=201)
def get(self, request, format=None):
setting = ShopSetting.objects.filter(enable=True)
return CustomJSONRenderer().renderData(
ShopSettingSerializer(setting.first(), many=False).data)
def get(self, request, id=None, format=None, *args, **kwargs):
if id is None:
cart = Cart.objects.filter(user=request.user).filter(
status=1).filter(updated_at__gte=datetime.now() -
timedelta(hours=24))
else:
cart = Cart.objects.filter(pk=id).filter(user=request.user).filter(
status=1)
# check not empty cart
if cart.count() == 0:
return CustomJSONRenderer().render(
{
'message': 'cart is empty',
'success': False
}, status=400)
cart = cart.first()
if cart.total_price == 0:
# Product is free ~ BUG :)
return CustomJSONRenderer().render(
{
'message': 'Problem The System Cart',
'success': False
},
status=400)
cartItems_date = CartItem.objects.filter(cart__id=cart.pk)
# @TODO append postalcode for just product (type=1)
if cartItems_date.filter(
product__type=1
) and not request.user.address or not request.user.postal_code:
return CustomJSONRenderer().render(
{
'message':
'لطفا ابتدا در قسمت حساب کاربری نسبت به تکمیل اطلاعات کاربری اقدام نمایید',
'success': False
},
status=400)
if settings.CART_DEBUG:
# Debug enable for cart
"""""
:: save product into user product
:: change status cart in 3
:: mince count product
:: check count product
""" ""
for cartItem in cartItems_date:
product = Product.objects.filter(id=cartItem.product.id)
if product.first().count == 0:
# deleted item product from cart item
CartItem.objects.filter(id=cartItem.id).delete()
return CustomJSONRenderer().render(
{
'message':
'Product {} Not Exists'.format(cartItem.product),
'success':
False,
'reload':
True
},
status=400)
for cartItem in cartItems_date:
UserProduct.objects.create(user=request.user,
product=cartItem.product)
product = Product.objects.filter(
id=cartItem.product.id).update(count=F('count') - 1)
Cart.objects.filter(pk=cart.pk).update(status=3)
send_factor(request, cart) # send factor email
return CustomJSONRenderer().render({
'redirect_uri':
settings.URI_FRONT + 'cart/factor/{}/'.format(cart.pk),
'success':
True,
})
else:
pass
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
company = Company.objects.get(slug=request.data['company'])
return CustomJSONRenderer().renderData(self.get_score_data(company))
def post(self, request, format=None, *args, **kwargs):
email = request.POST.get('email',None)
if email:
if EmailRegister.objects.filter(email=email):
return CustomJSONRenderer().render('')
return self.create(request, *args, **kwargs)
