def post(self, request, format=None):
serializer = QuestionSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(
response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def post(self, request, format=None):
title = get_data_param(request, 'title', None)
questionnaire = Questionnaire.get_if_exists_by_title(title)
serializer = QuestionnaireSerializer(questionnaire, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(
response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def post(self, request, format=None):
name = get_data_param(request, 'name', None)
city_id = get_data_param(request, 'city_id', None)
request.data["city"] = city_id
branch = Branch.get_if_exists(name)
serializer = BranchSerializer(branch, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def post(self, request, format=None):
name = get_data_param(request, 'name', None)
region_id = get_data_param(request, 'region_id', None)
request.data["region"] = region_id
# city = City.get_if_exists(name) As MC need multiple entries with same name
serializer = CitySerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(
response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def post(self, request, format=None):
name = get_data_param(request, 'name', None)
area_id = get_data_param(request, 'area_id', None)
request.data["area"] = area_id
region = Region.get_if_exists(name)
serializer = RegionSerializer(region, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(
response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def post(self, request, format=None):
if "user" in request.data:
user_data = request.data["user"]
user = get_related_user(user_data)
else:
user = None
feedback_params = request.data
feedback_params['user'] = user.id if user else None
serializer = FeedbackSerializer(data=request.data)
if serializer.is_valid():
feedback = serializer.save()
if feedback:
if "options" in request.data:
options_list = request.data["options"]
for option_id in options_list:
FeedbackOption(feedback=feedback,
option_id=option_id).save()
feedback.mark_feedback_status()
feedback.keyword_analysis()
feedback.mark_segment()
q = RedisQueue('feedback_redis_queue')
q.put(str(get_live_record()))
# q.put("ping")
if feedback.is_negative() and feedback.not_empty():
feedback.mark_for_report()
feedback_json = {
"is_bad": feedback.is_bad(),
"branch_name": feedback.branch.name,
"branch_id": feedback.branch.id,
"city_name": feedback.branch.city.name,
"customer_name": feedback.customer_name(),
"customer_phone": feedback.customer_phone(),
"customer_email": feedback.customer_email(),
"problems": feedback.problems(),
"comment": feedback.comment,
"server_link": settings.server_url,
}
# send_negative_feedback_email(feedback_json)
send_negative_feedback_email.delay(feedback_json)
return Response(response_json(True, None, None))
return Response(
response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
def get(self, request, user, format=None):
role = get_param(request, 'role', None)
id = get_param(request, 'id', None)
director_id = get_param(request, 'director_id', None)
assistant_director_id = get_param(request, 'assistant_director_id', None)
operational_manager_id = get_param(request, 'operational_manager_id', None)
operational_consultant_id = get_param(request, 'operational_consultant_id', None)
branch_manager_id = get_param(request, 'branch_manager_id', None)
if id:
data = UserInfo.get_person_dict(int(role), id)
elif director_id:
data = UserInfo.get_children_dict(UserRolesEnum.ASSISTANT_DIRECTOR, UserRolesEnum.DIRECTOR, director_id)
elif assistant_director_id:
data = UserInfo.get_children_dict(UserRolesEnum.OPERATIONAL_MANAGER, UserRolesEnum.ASSISTANT_DIRECTOR, assistant_director_id)
elif operational_manager_id:
data = UserInfo.get_children_dict(UserRolesEnum.OPERATIONAL_CONSULTANT, UserRolesEnum.OPERATIONAL_MANAGER, operational_manager_id)
elif operational_consultant_id:
data = UserInfo.get_children_dict(UserRolesEnum.BRANCH_MANAGER, UserRolesEnum.OPERATIONAL_CONSULTANT, operational_consultant_id)
elif branch_manager_id:
data = UserInfo.get_children_dict(UserRolesEnum.GRO, UserRolesEnum.BRANCH_MANAGER, branch_manager_id)
else:
data = UserInfo.get_people_dict(int(role))
return Response(response_json(True, data, None))
def get(self, request, format=None):
region_id = request.query_params.get('region', None)
if region_id:
cities = City.objects.filter(region__exact=region_id)
else:
cities = City.objects.all()
serializer = CitySerializer(cities, many=True)
return Response(response_json(True, serializer.data, None))
def get(self, request, format=None):
branch_id = get_param(request, 'branch_id', None)
questionnaire = Questionnaire.objects.filter(isActive=True,
branch=branch_id).first()
data = None
if questionnaire:
data = questionnaire.to_dict()
return Response(response_json(True, data, None))
def get(self, request, format=None):
genre_type = get_param(request, 'genre_type', None)
if genre_type:
questions = Question.objects.filter(genreType=genre_type)
else:
questions = Question.objects.all()
data = [question.to_dict() for question in questions]
return Response(response_json(True, data, None))
def delete(self, request, user, format=None):
try:
id = get_default_param(request, 'id', None)
user = User.objects.get(pk=id)
if user:
user_info = user.info.first()
if user_info:
if user_info.is_active:
user_info.is_active = False
else:
user_info.is_active = True
user_info.save()
return Response(response_json(True, user_info.to_dict(), None))
return Response(response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
except User.DoesNotExist as e:
return Response(response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
def get(self, request, user, format=None):
try:
now = datetime.now()
region_id, city_id, branch_id = get_user_data(user)
date_to_str = get_param(request, 'date_to', str(now.date()))
date_from_str = get_param(request, 'date_from',
str((now - timedelta(days=1)).date()))
data = {
"benchmark_analysis":
self._get_benchmark_counts(date_from_str, date_to_str),
"segmentation_rating":
self._get_segments(date_from_str, date_to_str, region_id,
city_id, branch_id),
"overall_rating":
self._get_overall_feedback(date_from_str, date_to_str,
region_id, city_id, branch_id),
"patch_analysis":
self._get_patch_analysis(date_from_str, date_to_str, region_id,
city_id, branch_id),
"complaint_view":
self._get_complaint_view(date_from_str, date_to_str, region_id,
city_id, branch_id),
"concerns":
self._get_top_concerns(),
"opportunity_analysis":
self._get_opportunity_analysis(date_from_str, date_to_str,
region_id, city_id, branch_id),
"age_group_analysis":
self._get_customer_analysis(date_from_str, date_to_str,
region_id, city_id, branch_id),
"recommendation_analysis":
self._get_recommendation_analysis(date_from_str, date_to_str,
region_id, city_id,
branch_id)
}
return Response(response_json(True, data, None))
except Exception as e:
return Response(
response_json(False, None,
constants.TEXT_OPERATION_UNSUCCESSFUL))
def get(self, request, user, format=None):
try:
id = get_param(request, 'id', None)
user = User.objects.get(pk=id)
if user:
user_info = user.info.first()
if user_info:
if user_info.role == UserRolesEnum.BRANCH_MANAGER or user_info.role == UserRolesEnum.GRO:
user_info.branch_id = None
user_info.save()
elif user_info.role == UserRolesEnum.OPERATIONAL_CONSULTANT:
user_info.region_id = None
user_info.save()
return Response(response_json(True, user_info.to_dict(), None))
return Response(response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
except User.DoesNotExist as e:
return Response(response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
def put(self, request, format=None):
id = get_data_param(request, 'id', None)
try:
question = Question.objects.get(pk=id)
serializer = QuestionSerializer(question, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(response_json(True, serializer.data, None))
return Response(
response_json(False, None,
constants.TEXT_OPERATION_UNSUCCESSFUL))
except Question.DoesNotExist as e:
return Response(
response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
except Exception as e:
return Response(
response_json(False, None,
constants.TEXT_OPERATION_UNSUCCESSFUL))
def get(self, request, format=None):
region_id = request.query_params.get('region', None)
city_id = request.query_params.get('city', None)
if region_id:
branches = Branch.objects.filter(city__region__exact=region_id)
elif city_id:
branches = Branch.objects.filter(city__exact=city_id)
else:
branches = Branch.objects.all()
serializer = BranchSerializer(branches, many=True)
return Response(response_json(True, serializer.data, None))
def get(self, request, user, format=None):
region_id, city_id, branch_id = get_user_data(user)
if branch_id:
branches = Branch.objects.filter(id=branch_id)
elif region_id:
branches = Branch.objects.filter(city__region__exact=region_id)
else:
branches = Branch.objects.all()
serializer = BranchSerializer(branches, many=True)
return Response(response_json(True, serializer.data, None))
def get(self, request, user, format=None):
region_id, city_id, branch_id = get_user_data(user)
if branch_id:
questionnaires = Questionnaire.objects.filter(
branch=branch_id).order_by("-created_at")
elif region_id:
questionnaires = Questionnaire.objects.filter(
branch__city__region__exact=region_id).order_by("-created_at")
else:
questionnaires = Questionnaire.objects.all().order_by(
"-created_at")
serializer = QuestionnaireSerializer(questionnaires, many=True)
return Response(response_json(True, serializer.data, None))
def put(self, request, user, format=None):
try:
id = get_data_param(request, 'id', None)
new_password = get_data_param(request, 'new_password', None)
email = get_data_param(request, 'email', None)
phone_no = get_data_param(request, 'phone_no', None)
first_name = get_data_param(request, 'first_name', None)
last_name = get_data_param(request, 'last_name', None)
branch_id = get_data_param(request, 'branch_id', None)
region_id = get_data_param(request, 'region_id', None)
branch = Branch.objects.get(pk=branch_id) if branch_id else None
region = Region.objects.get(pk=region_id) if region_id else None
if branch and branch.is_associated():
return Response(response_json(False, None, "Branch is already Associated"))
elif region and region.is_associated():
return Response(response_json(False, None, "Region is already Associated"))
user = User.objects.get(pk=id)
if user:
user.email = email if email else user.email
if new_password:
user.set_password(new_password)
user.first_name = first_name if first_name else user.first_name
user.last_name = last_name if last_name else user.last_name
user.save()
user_info = user.info.first()
if user_info:
user_info.branch_id = branch.id if branch else user_info.branch_id
user_info.region_id = region.id if region else user_info.region_id
user_info.phone_no = phone_no if phone_no else user_info.phone_no
user_info.save()
return Response(response_json(True, user_info.to_dict(), None))
except User.DoesNotExist as e:
return Response(response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
except Branch.DoesNotExist as e:
return Response(response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
except Region.DoesNotExist as e:
return Response(response_json(False, None, constants.TEXT_DOES_NOT_EXISTS))
def get(self, request, format=None):
options = Option.objects.all()
serializer = OptionSerializer(options, many=True)
return Response(response_json(True, serializer.data, None))
def get(self, request, format=None):
branch_id = get_param(request, 'branch_id', None)
users = UserInfo.objects.filter(branch=branch_id, is_active=True)
data = [user.to_dict() for user in users]
return Response(response_json(True, data, None))
def post(self, request, format=None):
try:
role = get_data_param(request, 'role', None)
username = get_data_param(request, 'username', None)
first_name = get_data_param(request, 'first_name', None)
last_name = get_data_param(request, 'last_name', None)
password = get_data_param(request, 'password', None)
email = get_data_param(request, 'email', None)
phone_no = get_data_param(request, 'phone_no', None)
branch_id = get_data_param(request, 'branch_id', None)
region_id = get_data_param(request, 'region_id', None)
parent_id = get_data_param(request, 'parent_id', None)
if role:
branch = Branch.objects.get(pk=branch_id) if branch_id else None
parent_user = User.objects.get(pk=parent_id) if parent_id else None
parent = parent_user.info.first() if parent_user else None
region = Region.objects.get(pk=region_id) if region_id else None
if branch and parent:
if role == UserRolesEnum.GRO:
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no, role=UserRolesEnum.GRO,
branch=branch, parent=parent)
return Response(response_json(True, user_info.to_dict(), None))
elif role == UserRolesEnum.BRANCH_MANAGER:
if not branch.is_associated():
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no, role=UserRolesEnum.BRANCH_MANAGER,
branch=branch, parent=parent)
return Response(response_json(True, user_info.to_dict(), None))
else:
return Response(response_json(False, None, "Branch already Associated"))
elif region and parent:
if role == UserRolesEnum.OPERATIONAL_CONSULTANT:
if not region.is_associated():
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no, role=UserRolesEnum.OPERATIONAL_CONSULTANT,
region=region, parent=parent)
return Response(response_json(True, user_info.to_dict(), None))
else:
return Response(response_json(False, None, "Region already Associated"))
elif parent:
if role == UserRolesEnum.OPERATIONAL_MANAGER:
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no,
role=UserRolesEnum.OPERATIONAL_MANAGER, parent=parent)
return Response(response_json(True, user_info.to_dict(), None))
elif role == UserRolesEnum.ASSISTANT_DIRECTOR:
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no,
role=UserRolesEnum.ASSISTANT_DIRECTOR, parent=parent)
return Response(response_json(True, user_info.to_dict(), None))
else:
if role == UserRolesEnum.DIRECTOR:
user = create_user(username, first_name, last_name, email, password)
user_info = UserInfo.objects.create(user=user, phone_no=phone_no, role=UserRolesEnum.DIRECTOR)
return Response(response_json(True, user_info.to_dict(), None))
return Response(response_json(False, None, constants.TEXT_OPERATION_UNSUCCESSFUL))
except IntegrityError as e:
return Response(response_json(False, None, "Username " + constants.TEXT_ALREADY_EXISTS))
def get(self, request, format=None):
promotions = Promotion.objects.all().order_by("-created_at")
serializer = PromotionSerializer(promotions, many=True)
return Response(response_json(True, serializer.data, None))
def get(self, request, format=None):
promotion = Promotion.objects.filter(isActive=True).first()
data = None
if promotion:
data = promotion.to_dict()
return Response(response_json(True, data, None))
def get(self, request, format=None):
feedback = Feedback.objects.all()
serializer = FeedbackSerializer(feedback, many=True)
return Response(response_json(True, serializer.data, None))
