def reset_password(self, request, pk):
"""
api to change forgot password
''
"""
forgot_pass_token = pk
response_data = success_response()
if request.method == 'GET':
user_object = auth_model.objects.filter(
is_deleted=False,
forgot_pass_verify_code=forgot_pass_token).first()
if user_object:
data = {'valid': True, 'user_id': user_object.pk}
response_data = success_response(data=data)
else:
error = {'valid': False}
response_data = error_response(error)
elif request.method == 'POST':
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_object = auth_model.objects.filter(
is_deleted=False,
pk=serializer_data.data.get('user_id'),
forgot_pass_verify_code=forgot_pass_token).first()
if user_object:
new_password = request.data.get('new_password')
user_object.set_password(new_password)
user_object.forgot_pass_verify_code = None # TODO
user_object.save()
data = dict()
message = api_message['success_password_changed']
response_data = success_response(data=data,
message=message)
else:
error = {
'token':
'Forgot password token is not valid, try again'
}
response_data = error_response(error)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def dropdown(self, request):
"""
Get Dropdown List for model objects.
"""
dropdown_list = list()
if self.dropdown_fields:
queryset = self.get_queryset()
objects = queryset.filter(
is_deleted=False, is_active=True).order_by(
*self.sort_by).values(*self.dropdown_fields)
print("objects", objects)
# print("==> ", dict(objects))
for obj in objects:
data_info = dict()
for ele in self.dropdown_fields:
data_info[ele] = obj[ele]
dropdown_list.append(data_info)
data = dropdown_list
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def post(self, request):
"""
Update Configurations
"""
request_data = request.data
serializer_class = self.get_serializer_class()
for config_data in request_data:
code = config_data.get('code')
c_obj = self.model.objects.filter(code=code).first()
if c_obj:
serializer = serializer_class(c_obj, data=config_data)
else:
serializer = serializer_class(data=config_data)
if serializer.is_valid():
serializer.save()
response_data = success_response()
return Response(response_data, status=response_data["code"])
def post(self, request, role_id):
"""
for Update profile data
"""
serializer_data = self.serializer_class(data=request.data)
if serializer_data.is_valid():
permission_ids = serializer_data.data.get('permission_ids', list())
print("\n ==> permission_ids: ", permission_ids)
models.RolePermission.objects.filter(role_id=role_id).delete()
for perm_id in permission_ids:
data_obj = dict()
data_obj['role_id'] = role_id
data_obj['permission_id'] = perm_id
data_obj['created_by'] = request.user.pk
data_obj['updated_by'] = request.user.pk
models.RolePermission.objects.create(**data_obj)
data = permission_ids
response_data = success_response(data=data)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def list(self, request):
"""
@:param ==>
search : for searching |
page : for page no |
size : for page size
"""
queryset = self.get_queryset()
query_condition = Q(is_deleted=False)
if self.search_fields:
query_condition = query_condition & self.get_search_query(request)
if self.filter_fields:
query_condition = query_condition & self.get_filter_query(request)
if self.apply_pagination:
response_data_dict = self.get_pagination_data(
request, query_condition)
else:
objects = queryset.filter(query_condition).order_by(*self.sort_by)
response_data_dict = self.get_object_list(objects)
data = response_data_dict
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def change_password(self, request):
"""
api to change user password
''
"""
user = request.user
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
old_password = request.data.get('old_password')
if user.check_password(old_password):
new_password = request.data.get('new_password')
user.set_password(new_password)
user.save()
success = True
data = []
response_data = success_response(data=data)
else:
success = False
error = {'old_password': "******"}
response_data = error_response(error)
else:
success = False
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def get(self, request, pk):
"""
for Retrieve product data
"""
obj = models.Product.objects.filter(pk=pk, is_deleted=False, is_active=True).first()
if obj:
data_info = dict()
data_info['id'] = obj.pk
data_info['title'] = obj.title
data_info['image'] = obj.get_image_url()
data_info['glace'] = obj.glace
data_info['description'] = obj.description
data_info['extra_note'] = obj.extra_note
data_info['importing'] = obj.get_importing()
data_info['category'] = obj.get_category()
data_info['subcategory'] = obj.get_subcategory()
data_info['is_favorite'] = obj.is_favorite
data_info['type'] = obj.get_type()
data_info['sizes'] = obj.get_size()
data_info['price'] = obj.price
response_data = success_response(data=data_info)
else:
response_data = error_response(code=404)
return Response(response_data, status=response_data["code"])
def get(self, request):
objs = Configuration.objects.filter(is_deleted=False)
data_info = dict()
for obj in objs:
data_info[obj.code] = obj.value
response_data = success_response(data_info)
return Response(response_data, status=response_data["code"])
def get(self, request):
"""
for Retrieve profile data
"""
get_user = request.user
data = get_profile_data(get_user)
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def logout(self, request):
"""
user logout api
''
"""
token = Token.objects.get(user=request.user)
token.delete()
# data = list()
message = api_message['success_logout']
response_data = success_response()
return Response(response_data, status=response_data["code"])
def login(self, request):
"""
user login api
"""
print("\n=====> Login Data:", request.data)
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_email = serializer_data.data.get('email')
user_password = serializer_data.data.get('password')
get_user = auth_model.objects.filter(is_deleted=False,
email=user_email).first()
if get_user:
if get_user.is_active:
if get_user.check_password(user_password):
token = Token.objects.get_or_create(
user=get_user)[0] # TokenAuthentication
# get_user.is_online = True
get_user.save()
data = get_login_user_dict(request, get_user, token)
message = api_message['login_success']
response_data = success_response(data=data,
message=message)
else:
# Here email is exist but password is wrong so success is True but code is 400
error = {'password': api_message['wrong_password']}
response_data = error_response(error)
else:
error = {'email': api_message['account_deactivated']}
response_data = error_response(error)
else:
error = {'email': api_message['email_not_exist']}
response_data = error_response(error)
else:
print("serializer_data:", serializer_data.errors)
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def get(self, request, role_id):
"""
for Retrieve profile data
"""
selected_permission_list = list(
models.RolePermission.objects.filter(
role_id=role_id,
is_deleted=False).values_list('permission_id'))
selected_permission_list = [e[0] for e in selected_permission_list]
from .models import AppModel
perm_objects = models.Permission.objects.filter(
is_deleted=False).order_by('model_id', 'order_no')
model_ids = list(set([e.model_id for e in perm_objects]))
model_objs = models.AppModel.objects.filter(pk__in=model_ids)
model_name_dict = {e.pk: e.name for e in model_objs}
response_dict = dict()
for obj in perm_objects:
model_name = model_name_dict.get(obj.model_id)
if not response_dict.get(model_name):
response_dict[model_name] = list()
data = dict()
data['id'] = obj.pk
data['name'] = obj.name
data['code'] = obj.code
data['model_id'] = obj.model_id
data[
'selected'] = True if obj.pk in selected_permission_list else False
response_dict[model_name].append(data)
result_list = list()
for key, value in response_dict.items():
res_obj = dict()
res_obj['key'] = key
res_obj['value'] = value
result_list.append(res_obj)
data = dict()
data['selected_permission_list'] = selected_permission_list
data[
'available_permission_list'] = result_list #get_profile_data(get_user)
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def destroy(self, request, pk):
"""
Delete object by pk.
"""
instance = self.get_object(pk)
if instance:
self.perform_destroy(instance, request)
response_data = success_response()
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def view(self, request, pk):
"""
Retrieve object by Id for view.
"""
get_instance = self.get_object(pk)
if get_instance:
data = self.get_object_view_data(get_instance)
response_data = success_response(data=data)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def get(self, request):
config_objs = self.model.objects.all()
config_data = list()
for obj in config_objs:
data_info = dict()
data_info['name'] = obj.name.replace("_", " ")
data_info['code'] = obj.code
data_info['value'] = obj.value
config_data.append(data_info)
response_data = success_response(data=config_data)
return Response(response_data, status=response_data["code"])
def get(self, request):
"""
for Retrieve product data
"""
objs = models.Type.objects.filter(is_deleted=False, is_active=True)
data_list = list()
for obj in objs:
data_info = dict()
data_info['id'] = obj.pk
data_info['title'] = obj.title
data_list.append(data_info)
response_data = success_response(data=data_list)
return Response(response_data, status=response_data["code"])
def get(self, request, key):
cms_obj = models.Cms.objects.filter(is_deleted=False,
is_active=True,
key=key).first()
if cms_obj:
data_info = dict()
data_info['key'] = cms_obj.key
data_info['title'] = cms_obj.title
data_info['content'] = cms_obj.content
response_data = success_response(data_info)
else:
response_data = error_response()
return Response(response_data, status=response_data["code"])
def form_dropdowm_list(self, request):
"""
get dropdown list for add product form
"""
from django.db.models import Q
result_data = dict()
q_condition = Q(is_deleted=False, is_active=True)
category_list = models.Category.objects.filter(
q_condition).values_list('id', 'title')
category_list = [{
'id': obj[0],
'title': obj[1]
} for obj in category_list]
subcategory_list = models.SubCategory.objects.filter(
q_condition).values_list('id', 'title', 'category_id')
subcategory_list = [{
'id': obj[0],
'title': obj[1],
'category_id': obj[2]
} for obj in subcategory_list]
importing_list = models.Importing.objects.filter(
q_condition).values_list('id', 'title')
importing_list = [{
'id': obj[0],
'title': obj[1]
} for obj in importing_list]
type_list = models.Type.objects.filter(q_condition).values_list(
'id', 'title')
type_list = [{'id': obj[0], 'title': obj[1]} for obj in type_list]
size_list = models.Size.objects.filter(q_condition).values_list(
'id', 'title')
size_list = [{'id': obj[0], 'title': obj[1]} for obj in size_list]
result_data['category'] = category_list
result_data['subcategory'] = subcategory_list
result_data['importing'] = importing_list
result_data['type'] = type_list
result_data['size'] = size_list
response_data = success_response(data=result_data)
return Response(response_data, status=response_data["code"])
def favorite(self, request, pk):
"""
favorite/Unfavorite product by id.
"""
serializer_class = self.get_serializer_class()
serializer = serializer_class(data=request.data)
if serializer.is_valid():
self.model.objects.filter(pk=pk).update(
is_favorite=serializer.data.get('is_favorite'))
response_data = success_response()
else:
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def partial_update(self, request, pk):
"""
Change active status (active/inactive) of object by Id.
"""
instance = self.get_object(pk)
if instance:
instance.is_active = False if instance.is_active else True
instance.updated_by = request.user.id
instance.save()
data = {'is_active': instance.is_active}
response_data = success_response(data=data)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def get(self, request):
"""
Retrieve dashboard data
"""
from . import helpers
data = dict()
data['task'] = helpers.get_dashboard_task_data()
data['order'] = helpers.get_dashboard_order_data()
data['customor'] = helpers.get_dashboard_customor_data()
data['salesman'] = helpers.get_dashboard_salesman_data()
data['revenue'] = helpers.get_dashboard_revenue_data()
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def get(self, request):
"""
for Retrieve Banner data
"""
objs = models.SiteImage.objects.filter(is_deleted=False, is_active=True, image_type='banner')
data_list = list()
for obj in objs:
data_info = dict()
data_info['id'] = obj.pk
data_info['title'] = obj.title
data_info['image'] = obj.get_image_url()
data_list.append(data_info)
response_data = success_response(data=data_list)
return Response(response_data, status=response_data["code"])
def check_user_token(self, request):
"""
api to check user token
''
"""
token = request.META.get('HTTP_AUTHORIZATION').split(' ')[1]
user = request.user
token_obj = Token.objects.filter(key=token, user_id=user.id).first()
if token_obj:
success = True
data = get_login_user_dict(request, user, token_obj)
response_data = success_response(data=data)
else:
success = False
error = {'token': api_message['login_again']}
response_data = error_response(error=error)
return Response(response_data, status=response_data.get("code"))
def get(self, request):
queryset = self.get_queryset()
query_condition = Q(is_deleted=False, is_active=True)
if self.search_fields:
query_condition = query_condition & self.get_search_query(request)
if self.filter_fields:
query_condition = query_condition & self.get_filter_query(request)
response_data_dict = self.get_pagination_data(request, query_condition)
data = response_data_dict
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
def post(self, request):
"""
for Update profile data
"""
serializer_data = self.serializer_class(request.user,
data=request.data)
if serializer_data.is_valid():
user_obj = serializer_data.save()
user_obj.updated_by = request.user.pk
user_obj.save()
data = get_profile_data(user_obj)
response_data = success_response(data=data)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def create(self, request):
"""
Create a new object.
"""
if settings.DEBUG:
p_print("POST ==>: request.data", request.data)
extra_context = self.update_serializer_context(request)
serializer_class = self.get_serializer_class()
serializer = serializer_class(data=request.data, context=extra_context)
if serializer.is_valid():
self.perform_create(serializer, request)
data = []
response_data = success_response(data=data)
else:
if settings.DEBUG:
print("\nSerializer Errors: ", serializer.errors, "\n")
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
def forgot_password(self, request):
"""
api to change forgot password
''
"""
serializer_class = self.get_serializer_class()
serializer_data = serializer_class(data=request.data)
if serializer_data.is_valid():
user_object = auth_model.objects.filter(
is_deleted=False,
email=serializer_data.data.get('email')).first()
if not user_object:
error = {'email': 'The contact email is not registered'}
response_data = error_response(error)
elif not user_object.is_active:
error = {
'email':
'The contact email is not active or verified, Please contact admin'
}
response_data = error_response(error)
else:
password_reset_email(request, user_object)
data = dict()
message = "Reset password link has been sent your registered email id, Please check your mail"
response_data = success_response(data=data, message=message)
else:
error = get_serializer_errors(serializer_data.errors)
response_data = error_response(error)
return Response(response_data, status=response_data.get("code"))
def update(self, request, pk):
"""
Update object by Id.
"""
if settings.DEBUG:
print("\n============ PUT ==>: request.data =============\n")
print("DEBUG: ", settings.DEBUG)
print("\nrequest.data: ", request.data)
print("\n=================================================\n")
get_instance = self.get_object(pk)
extra_context = self.update_serializer_context(request)
if get_instance:
serializer_class = self.get_serializer_class()
serializer = serializer_class(get_instance,
data=request.data,
context=extra_context)
if serializer.is_valid():
self.perform_update(serializer, request)
data = []
response_data = success_response(data=data)
else:
if settings.DEBUG:
print("\nSerializer Errors: ", serializer.errors, "\n")
error = get_serializer_errors(serializer.errors)
response_data = error_response(error)
else:
error = {'id': response_text[603]}
response_data = error_response(error)
return Response(response_data, status=response_data["code"])
return Response(response_data, status=response_data["code"])
def get(self, request):
"""
for Retrieve profile data
"""
from .models import AppModule, AppModel, Permission
app_models = {
'product': [
'size', 'category', 'subcategory', 'importing', 'type',
'product'
],
'task': ['task'],
'user': ['salesman', 'customer'],
'role_permission': ['role'],
'order': ['order'],
'company': ['configuration'],
'faq': ['faq'],
'cms': ['cms'],
'site_image': ['site_image']
}
action_list = [
{
'name': 'list',
'code': 'list',
},
{
'name': 'view',
'code': 'view',
},
{
'name': 'add',
'code': 'add',
},
{
'name': 'edit',
'code': 'edit',
},
{
'name': 'delete',
'code': 'delete',
},
{
'name': 'change status',
'code': 'change_status',
},
]
for key in app_models.keys():
obj = AppModule.objects.filter(name=key).first()
if not obj:
obj = AppModule()
obj.name = key
obj.save()
c = 0
for key, value_list in app_models.items():
for value in value_list:
module = AppModule.objects.filter(name=key).first()
if module:
model_obj = AppModel.objects.filter(module_id=module.pk,
name=value).first()
if not model_obj:
model_obj = AppModel()
model_obj.name = value
model_obj.module_id = module.pk
model_obj.save()
i = 0
for action in action_list:
i = i + 1
perm_obj = Permission.objects.filter(
code=action['code'],
model_id=model_obj.pk).first()
if not perm_obj:
perm_obj = Permission()
perm_obj.name = action['name']
perm_obj.code = action['code']
perm_obj.model = model_obj
perm_obj.order_no = i
perm_obj.save()
c = c + 1
data = dict()
data['permission_added'] = c
response_data = success_response(data=data)
return Response(response_data, status=response_data["code"])
