def post(self, request):
try:
serialized_data = self.serializer_class(data=request.data)
if serialized_data.is_valid(raise_exception=True):
username = serialized_data.data['username']
password = serialized_data.data['password']
try:
user = User.objects.get(username=username)
except User.DoesNotExist as e:
raise util_exception.CustomException(
detail=ugettext('User credentials are incorrect.'),
code=404)
if user.check_password(password):
payload = jwt_payload_handler(user) # todo: Is deprecated
jwt_token = utils.jwt_response_payload_handler(
jwt_encode_handler(payload))
return responses.SuccessResponse(jwt_token).send()
else:
raise util_exception.CustomException(
detail=ugettext('User credentials are incorrect.'),
code=404)
except util_exception.CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
except exceptions.ValidationError as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self, request):
try:
serialized_data = self.serializer_class(data=request.data)
if serialized_data.is_valid(raise_exception=True):
username = serialized_data.data['username']
password = serialized_data.data['password']
try:
user = User.objects.get(username=username)
except User.DoesNotExist as e:
user = None
if user:
raise util_exception.CustomException(detail=ugettext(
'User with this credentials is registered before.'),
code=400)
user = transactions.register_user(username, password)
payload = jwt_payload_handler(user) # todo: Is deprecated
jwt_token = utils.jwt_response_payload_handler(
jwt_encode_handler(payload))
return responses.SuccessResponse(jwt_token, status=201).send()
except util_exception.CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
except exceptions.ValidationError as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self, request, *args, **kwargs):
try:
serialize_data = self.get_serializer(data=request.data)
if serialize_data.is_valid(raise_exception=True):
self.perform_create(serialize_data)
return responses.SuccessResponse(serialize_data.data, status=201).send()
except IntegrityError as e:
return responses.ErrorResponse(message=ugettext('DB Integrity Error in creation.'),
dev_error=str(e), status=409).send()
except (CustomException, ValidationError) as e:
return responses.ErrorResponse(message=e.detail, status=e.status_code).send()
def put(self, request, id=None):
try:
instance = self.get_instance(request, id)
serialized_data = self.get_serializer(instance, data=request.data)
if serialized_data.is_valid(raise_exception=True):
self.perform_update(serialized_data)
return responses.SuccessResponse(serialized_data.data).send()
except self.model.DoesNotExist as e:
return responses.ErrorResponse(message=ugettext('Does not exist.'),
status=400).send()
except (exceptions.CustomException, ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self):
"""
Login user
username min 5, max 50
password min 5, max 50
:return:
"""
try:
data = LoginRegisterParser.parse_args()
user = User.query.get(username=data['username'])
if user is None:
raise CustomException(detail='User does not exist.')
else:
if user.check_password(data['password']):
data = {'token': user.encode_auth_token()}
return responses.SuccessResponse(data).send()
else:
raise CustomException(
detail='username or password is incorrect.')
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self):
"""
Register user
username min 5, max 50
password min 5, max 50
:return:
"""
try:
data = LoginRegisterParser.parse_args()
user = User.query.get(username=data['username'])
if user is None:
user = User(username=data['username'])
user.set_password(data['password'])
user.create()
data = {'token': user.encode_auth_token()}
return responses.SuccessResponse(data, status=201).send()
else:
raise CustomException(detail='A user with this data exist.')
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self):
"""
Create Ad
title min 3, max 100
body min 3, max 100
category {'id': id of category}
media [{'path': 'path of media'}] max 5
:return:
"""
try:
data = AdParser.parse_args()
data['category'] = Category.query.get(data['category']['id'])
if not data['category']:
raise CustomException(detail='Category does not exist.')
media = data.pop('media')
data['user'] = g.user
ad_item = Ad(**data).create()
if media:
for item in media:
ad_item.media_set.append(Media(path=item['path']))
ad_item.save()
return responses.SuccessResponse(marshal(ad_item, AdSchema),
status=201).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self):
"""
List of Ads
with pagination index default 0, size default 20
use search param query on title and body
use category id of category filter on that category
/?search=title&category=1
:return:
"""
try:
arg = dict(request.args)
index, size = handle_pagination(arg)
ads = Ad.query.filter_by(is_deleted=False)
if arg.get('category'):
ads = ads.filter_by(category_id=arg['category'])
if arg.get('search'):
ads = ads.filter((Ad.title.contains(arg['search'])) | (
Ad.body.contains(arg['search']))).distinct()
ads = ads.all()
total = len(ads)
return responses.SuccessResponse(marshal_list(
ads[index:size], AdListSchema),
index=index,
total=total).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self, request):
try:
serialized_data = self.serializer_class(data=request.data)
if serialized_data.is_valid(raise_exception=True):
email = serialized_data.data['email']
password = serialized_data.data['password']
user_list = User.objects.filter(email=email,
email_confirmed=True)
if user_list:
raise authnz_exceptions.CustomException(
detail=ugettext('You registered before.'))
permissions.check_send_email_permission(email)
try: # check for previous used email
user = User.objects.get(email=email, email_confirmed=False)
except User.DoesNotExist as e:
user = None
if user: # registered before but not confirmed
user = user.update_password(password)
else:
user = User.register_user(email, password)
user.send_email_confirm(request)
return responses.SuccessResponse({}, status=201).send()
except (authnz_exceptions.CustomException,
exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def put(self, id):
"""
Update ad details by id
title min 3, max 100
body min 3, max 100
category {'id': id of category}
media [{'path': 'path of media', 'id': 'id of gallery'}] max 5 id is optional for checking previous created
:param id:
:return:
"""
try:
data = AdParser.parse_args()
ad_item = Ad.query.get(id)
if ad_item is None or ad_item.is_deleted:
raise CustomException(detail='Ad does not exist.')
ad_item.has_permission()
ad_item.update(data)
return responses.SuccessResponse(marshal(ad_item, AdSchema)).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def delete(self, request, id):
try:
feed = self.model.objects.get(id=id, is_deleted=False)
feed.favorites.remove(request.user)
return responses.SuccessResponse(status=204).send()
except (exceptions.CustomException, self.model.DoesNotExist) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def delete(self, request, id):
try:
rss = self.model.objects.get(id=id, is_active=True)
rss.followers.remove(request.user)
return responses.SuccessResponse(status=204).send()
except (exceptions.CustomException, self.model.DoesNotExist) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def decorated_function(*args, **kwargs):
try:
user = handle_jwt_decode(request)
except exceptions.CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
g.user = user
return f(*args, **kwargs)
def get(self, request):
try:
if request.user.is_active:
jwt_token = utils.jwt_response_payload_handler(
request.user.generate_token())
return responses.SuccessResponse(jwt_token).send()
else:
raise authnz_exceptions.CustomException(
detail=ugettext('This user is inactive, contact us.'))
except authnz_exceptions.CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, request, uidb64, token):
try:
try:
uid = urlsafe_base64_decode(uidb64).decode()
user = User.objects.get(pk=uid)
except (TypeError, ValueError, OverflowError, User.DoesNotExist):
user = None
if user is not None and email_activation_token.check_token(
user, token):
user.confirm_email()
return render(request, 'authnz/mail_confirmed.html')
else:
return render(request,
'authnz/mail_confirm_invalid.html',
status=400)
except exceptions.ValidationError as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
except Exception as e:
return responses.ErrorResponse(message=str(e)).send()
def get(self, request, id=None, *args, **kwargs):
try:
if id is None and self.model == User:
instance = request.user
elif hasattr(self.model, 'is_deleted'):
instance = self.model.objects.get(id=id, is_deleted=False)
else:
instance = self.model.objects.get(id=id)
serialize_data = self.get_serializer(instance)
return responses.SuccessResponse(serialize_data.data).send()
except self.model.DoesNotExist as e:
return responses.ErrorResponse(message='Instance does not Found.',
status=404).send()
def post(self, request):
try:
admin_data = {
'email': '*****@*****.**',
'password': '******',
}
user = User.register_user(admin_data['email'],
admin_data['password'])
user.is_staff = True
user.is_superuser = True
user.confirm_email()
varzesh3_data = {
'title': 'Varzesh3',
'link': 'https://www.varzesh3.com/rss/all',
}
isna_data = {
'title': 'Isna',
'link': 'https://www.isna.ir/rss',
}
varzesh3_rss = Rss(**varzesh3_data)
varzesh3_rss.save()
tasks.check_new_rss.apply_async(args=(varzesh3_rss.id, ),
retry=False)
isna_rss = Rss(**isna_data)
isna_rss.save()
tasks.check_new_rss.apply_async(args=(isna_rss.id, ), retry=False)
return responses.SuccessResponse({}, status=201).send()
except IntegrityError as e:
return responses.ErrorResponse(message=str(e), status=400).send()
except (authnz_exceptions.CustomException,
exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, id):
"""
Get ad details by id
:param id:
:return:
"""
try:
ad_item = Ad.query.get(id)
if ad_item is None or ad_item.is_deleted:
raise CustomException(detail='Ad does not exist.')
return responses.SuccessResponse(marshal(ad_item, AdSchema)).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, request):
try:
index, size, args = utils.pagination_util(request)
filters = {'followers': request.user}
if args.get('title'):
filters['title__icontains'] = args['title']
rss_list = self.model.objects.filter(**filters)
total = rss_list.count()
data = self.get_serializer(rss_list[index:size], many=True).data
return responses.SuccessResponse(data, index=index,
total=total).send()
except (exceptions.CustomException,
drf_exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, request, id):
try:
rss = self.model.objects.get(id=id, is_active=True)
fs = FollowRss.objects.filter(rss=rss, user=request.user)
if fs:
count = Feed.objects.filter(
rss=rss, published__gte=fs[0].last_seen).count()
data = {'unread': count if count else 0}
return responses.SuccessResponse(data).send()
else:
raise exceptions.CustomException(
detail=ugettext('You did not follow this Rss.'))
except (exceptions.CustomException, drf_exceptions.ValidationError,
Rss.DoesNotExist) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self):
"""
Create Category
name string min_length 3, max_length 50
:return:
"""
try:
data = CategoryParser.parse_args()
category = Category(**data).create()
return responses.SuccessResponse(marshal(category, CategorySchema),
status=201).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, request, id):
try:
index, size, args = utils.pagination_util(request)
comment_list = Comment.objects.filter(feed__id=id,
feed__is_deleted=False,
is_deleted=False)
if args.get('order_by') and args['order_by'] == 'OLDEST':
comment_list = comment_list.order_by('created')
total = comment_list.count()
data = self.get_serializer(comment_list[index:size],
many=True).data
return responses.SuccessResponse(data, index=index,
total=total).send()
except (exceptions.CustomException,
drf_exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def delete(self, request, id):
try:
if hasattr(self.model, 'is_deleted'):
instance = self.model.objects.get(id=id, is_deleted=False)
else:
instance = self.model.objects.get(id=id)
permissions.check_delete_permission(request, instance)
if hasattr(self.model, 'is_deleted'):
instance.is_deleted = True
instance.save()
else:
instance.delete()
data = {}
return responses.SuccessResponse(data, status=204).send()
except (self.model.DoesNotExist, exceptions.CustomException) as e:
return responses.ErrorResponse(
message=ugettext('Instance does not exist.'),
status=404).send()
def get(self, request):
try:
index, size, args = utils.pagination_util(request)
filters = {'favorites': request.user}
feed_list = self.model.objects.filter(**filters)
if args.get('search'):
feed_list = feed_list.filter(
Q(title__icontains=args['search'])
| Q(description__icontains=args['search'])).distinct()
if args.get('order_by') and args['order_by'] == 'OLDEST':
feed_list = feed_list.order_by('published')
total = feed_list.count()
data = self.get_serializer(feed_list[index:size], many=True).data
return responses.SuccessResponse(data, index=index,
total=total).send()
except (exceptions.CustomException,
drf_exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def delete(self, id):
"""
Delete ad
Soft delete
:param id:
:return:
"""
try:
ad_item = Ad.query.get(id)
if ad_item is None or ad_item.is_deleted:
raise CustomException(detail='Ad does not exist.')
ad_item.has_permission()
ad_item.delete()
return responses.SuccessResponse(status=204).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self):
"""
List of categories
with pagination index default 0, size default 20
:return:
"""
try:
arg = dict(request.args)
index, size = handle_pagination(arg)
categories = Category.query.all()
total = len(categories)
return responses.SuccessResponse(marshal_list(
categories[index:size], CategorySchema),
index=index,
total=total).send()
except CustomException as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self, request):
try:
serialized_data = self.serializer_class(data=request.data)
if serialized_data.is_valid(raise_exception=True):
email = serialized_data.data['email']
password = serialized_data.data['password']
try:
user = User.objects.get(email=email)
except User.DoesNotExist as e:
raise authnz_exceptions.CustomException(
detail=ugettext('You did not registered before.'))
if user.email_confirmed and user.is_active and user.check_password(
password):
user.save_last_login()
jwt_token = utils.jwt_response_payload_handler(
user.generate_token())
return responses.SuccessResponse(jwt_token).send()
elif not user.email_confirmed:
try:
permissions.check_send_email_permission(email)
except authnz_exceptions.CustomException as e:
raise authnz_exceptions.CustomException(
detail=ugettext(
'You did not confirm your email and you'
' reached max email sent, try later.'))
user.send_email_confirm(request)
raise authnz_exceptions.CustomException(
detail=ugettext('You did not confirm your email,'
' We sent you a confirmation email'))
elif not user.is_active:
raise authnz_exceptions.CustomException(
detail=ugettext('Your account is not active,'
' please contact support.'))
else:
raise authnz_exceptions.CustomException(
detail=ugettext('Wrong login credentials.'))
except (authnz_exceptions.CustomException,
exceptions.ValidationError) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def get(self, request, id):
try:
index, size, args = utils.pagination_util(request)
rss = Rss.objects.get(id=id, is_active=True)
# Update last seen this rss
FollowRss.objects.filter(
rss=rss, user=request.user).update(last_seen=utils.now_time())
filters = {'rss': rss}
if args.get('title'):
filters['title__icontains'] = args['title']
feed_list = self.model.objects.filter(**filters)
if args.get('order_by') and args['order_by'] == 'OLDEST':
feed_list = feed_list.order_by('published')
total = feed_list.count()
data = self.get_serializer(feed_list[index:size], many=True).data
return responses.SuccessResponse(data, index=index,
total=total).send()
except (exceptions.CustomException, drf_exceptions.ValidationError,
Rss.DoesNotExist) as e:
return responses.ErrorResponse(message=e.detail,
status=e.status_code).send()
def post(self, request, *args, **kwargs):
serialize_data = self.get_serializer(data=request.data)
if serialize_data.is_valid():
file = serialize_data.validated_data['file']
xl = pd.ExcelFile(file)
df = xl.parse(xl.sheet_names[0])
for index, row in df.iterrows():
if isinstance(row['date'], str):
date = datetime.strptime(row['date'], '%d/%m/%Y')
else:
date = row['date']
if date.year < 1900:
date = jdatetime.date(day=date.day,
month=date.month,
year=date.year).togregorian()
name = row['name']
price = row['price']
total = row['total']
try:
car = Car.objects.get(name=name)
except Car.DoesNotExist as e:
car = Car(name=name)
car.save()
car_stock = CarStock(car=car,
price=price,
total=total,
date=date)
car_stock.save()
data = {}
return responses.SuccessResponse(data, status=200).send()
else:
dev_error = serialize_data.errors
message = 'Failed to upload {}'.format(
serialize_data.data['file'].name)
return responses.ErrorResponse(message=message,
dev_error=dev_error,
status=400).send()
