def list(self, request, *args, **kwargs):
user_type = get_user_type(request.user)
if user_type == 'student':
_query_set = get_queryset_for_student(request_data=request)
elif user_type == 'teacher':
_query_set = get_queryset_for_teacher(request_data=request)
else:
return Response([])
if _query_set is None:
return Response([])
announcement_ids = set(
list(_query_set.values_list("announcement_id", flat=True)))
_main_query = Q()
_main_query.add(Q(id__in=announcement_ids), Q.AND)
queryset = self.get_queryset().filter(_main_query).order_by(
'-created_at')
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
serializer = self.get_serializer(_query_set, many=True)
return Response(serializer.data)
def newest_product(self, res):
user_type = get_user_type(self.request.user)
if user_type == 'student':
products = self.queryset.filter(
gender__in=[self.request.user.baseuser.gender, 'both'],
published=True,
deleted=False,
for_student=True,
).order_by('-created_at')[:12]
elif user_type == 'teacher':
products = self.queryset.filter(
gender__in=[self.request.user.baseuser.gender, 'both'],
published=True,
deleted=False,
for_teacher=True).order_by('-created_at')[:12]
# products = self.queryset.filter(
# gender__in=[self.request.user.baseuser.gender, 'both'],
# published=True
# ).order_by()[:12]
_dict = {
"query_param": 'order=newest',
"title": "تازه ترین ها",
"products": self.get_serializer(products, many=True).data
}
res.append(_dict)
def list(self, request, *args, **kwargs):
params = request.query_params
end = params.get("end_date", "")
start = params.get("start_date", "")
user_type = get_user_type(request.user)
try:
start = datetime.datetime.strptime(start, '%Y-%m-%d')
end = datetime.datetime.strptime(end, '%Y-%m-%d')
except:
raise ValidationError(
{"message": "start date or end date not valid"},
code=status.HTTP_400_BAD_REQUEST)
response_data = []
user = request.user
self.get_occurrence(response_data, start, end, user)
self.get_occurrence_announcements(response_data, start, end, request)
if user_type == "student":
self.get_occurrence_activities(response_data, start, end, user)
return Response(response_data)
def check_code(request):
phone_number = request.POST.get('to_phone_number')
user_id = request.POST.get('to_phone_number')
activation_code = request.POST.get('activation_code')
phone_number = baghery_encode(phone_number)
if phone_number and activation_code:
is_valid, user, as_user_login = is_activation_code_valid(activation_code, phone_number, user_id)
if is_valid:
if not user:
return Response({
"success": False
}, status=status.HTTP_400_BAD_REQUEST)
base_user = BaseSerializer(user)
user_type = get_user_type(user)
user_data = base_user.data.copy()
user_data["type"] = user_type
user_data["level"] = get_user_level(user)
user_data["camp_id"], user_data["county_id"], user_data["province_id"] = get_user_location(user)
user_data["school_name"] = ""
token = generate_token(user)
if user_type == 'student':
student_data = StudentSerializer(user.student).data
user_data["school_name"] = student_data["school"]["name"]
user_data["school_id"] = student_data["school"]["id"]
user_data["province_id"] = user.student.school.province.id
try:
user_data["image"] = "/" + user.image.url
except:
user_data["image"] = ""
if not as_user_login: # اگر در حالت به عنوان یوزر وارد نشده بودیم تاریخ آخرین ورود ذخیره شود
user.last_login = datetime.datetime.now()
user.save()
return JsonResponse({
"user": user_data,
"token": token,
"success": True,
})
else:
return JsonResponse({
"success": False
}, status=status.HTTP_400_BAD_REQUEST)
else:
return JsonResponse({
"success": False
}, status=status.HTTP_400_BAD_REQUEST)
def get_occurrence_announcements(response_data, start, end, request):
user_type = get_user_type(request.user)
announcements = []
if user_type == 'student':
announcements = list(
get_queryset_for_student(request_data=request,
has_date=True,
start_date=start,
end_date=end))
elif user_type == 'teacher':
announcements = list(
get_queryset_for_teacher(request_data=request,
has_date=True,
start_date=start,
end_date=end))
for announcement in announcements:
response_data.append({
'id':
random.randint(9999, 99999),
'title':
announcement.announcement.title,
'start':
announcement.announcement.date,
'start_jalali':
to_jorjean(str(announcement.announcement.date)),
'end':
None,
'event_id':
random.randint(9999, 99999),
'color':
"#00bbd2",
'description':
announcement.announcement.description,
'rule':
None,
'end_recurring_period':
None,
'cancelled':
None,
'all_day':
True,
'editable':
False,
'type':
"announcement",
'id_href':
announcement.announcement_id,
})
def calculate_announcement_count(self, request):
""" تابع محاسبه تعداد اطلاعیه های خوانده نشده یک کاربر"""
# kahrizi
count = 0
try:
cache_key = 'announcement_count_{0}'.format(request.user.id)
announcement_view = AnnouncementSeenHistory.objects.filter(
user_id=request.user.id).count()
user_type = get_user_type(request.user)
if user_type == 'student':
announcement_not_view = get_queryset_for_student(
request_data=request).count()
elif user_type == 'teacher':
announcement_not_view = get_queryset_for_teacher(
request_data=request)
announcement_ids = set(
list(
announcement_not_view.values_list("announcement_id",
flat=True)))
announcement_not_view = self.get_queryset().filter(
id__in=announcement_ids).count()
else:
count = 0
return count
count = announcement_not_view - announcement_view
if count < 0:
count = 0
# logger_api.error("AnnouncementCount calculate_announcement_count Error", extra={
# "detail": {
# "error": "AnnouncementCount =" + str(count) + "User="******"AnnouncementCount calculate_announcement_count Error",
extra={"detail": {
"error": e,
}})
finally:
data = {"count": count, "date_calculate": datetime.datetime.now()}
cache.set(cache_key, data, CACHE_TIME_ANN_COUNT)
return count
def has_perm_login_app(request, user):
_dict = {
1: "student",
2: "teacher",
3: "advisor"
}
_dict_app = {
"student": 2,
"teacher": 3,
"advisor": 4,
}
app_code = request.POST.get("app_code", 'web') # check app name {1: "student", 2: "teacher", 3: "hamraz"}
user_type = get_user_type(user)
if app_code == "web" or _dict.get(int(app_code)) == user_type:
return True, _dict_app[user_type]
return False, _dict_app[user_type]
def list(self, request, *args, **kwargs):
user_type = get_user_type(request.user)
if user_type == 'teacher':
queryset = self.get_queryset().filter(
creator_id=request.user.id).order_by('-created_at')
page = self.paginate_queryset(queryset)
if page is not None:
serializer = self.get_serializer(page, many=True)
response = self.get_paginated_response(serializer.data)
return response
serializer = self.get_serializer(queryset, many=True)
return Response(serializer.data)
else:
return Response([])
def wrap(request, *args, **kwargs):
disable = False
message = ''
for item in AppDisableList.app_list_disable:
if item.id_part == part.value[0]:
if item.status_current:
message = item.message_disable
user_type = get_user_type(request.request._user)
user_level = get_user_level(request.request._user,
user_type)
disable = check_admin_acees(item, user_type,
user_level)
break
if disable:
raise PermissionLocked(detail=message)
return function(request, *args, **kwargs)
def slider(self, request):
"""
:param request:
:return: slider from product
"""
# queryset = ShopSlider.objects.all()
user_type = get_user_type(request.user)
if user_type == 'student':
queryset = ShopSlider.objects.filter(for_student=True)
elif user_type == 'teacher':
queryset = ShopSlider.objects.filter(for_teacher=True)
else:
queryset = []
queryset = queryset.filter(
Q(gender=request.user.baseuser.gender) | Q(gender="both"))
serializer = SliderSerializer(queryset, many=True)
return Response(serializer.data)
def get_query(self, dict_params):
orders = []
q_object = Q()
q_object.add(Q(gender__in=[self.request.user.baseuser.gender, 'both']),
Q.AND)
q_object.add(Q(published=True), Q.AND)
q_object.add(Q(deleted=False), Q.AND)
if 'order' in dict_params:
if dict_params["order"] == "newest":
orders.append('-created_at')
if dict_params["order"] == "price_high":
orders.append('-price')
if dict_params["order"] == "price_low":
orders.append('price')
if 'category' in dict_params:
q_object.add(Q(category_id=dict_params['category']), Q.AND)
if 'has_discount' in dict_params and dict_params['has_discount'] == 1:
q_object.add(Q(has_discount=dict_params['has_discount']), Q.AND)
if 'text' in dict_params:
q_object.add(Q(title__regex=dict_params['text']), Q.AND)
if 'price_start' in dict_params:
q_object.add(Q(price__gte=dict_params['price_start']), Q.AND)
if 'price_end' in dict_params:
q_object.add(Q(price__lte=dict_params['price_end']), Q.AND)
# برای فیلتر کردن محصولات دانش آموزان و مربی ها
user_type = get_user_type(self.request.user)
if user_type == 'student':
q_object.add(Q(for_student=True), Q.AND)
elif user_type == 'teacher':
q_object.add(Q(for_teacher=True), Q.AND)
return q_object, orders
def get_user(request):
user = request.user.baseuser
base_user = BaseSerializer(user)
user_type = get_user_type(user)
user_data = base_user.data.copy()
user_data["type"] = user_type
user_data["level"] = get_user_level(user)
user_data["camp_id"], user_data["county_id"], user_data["province_id"] = get_user_location(user)
user_data["school_name"] = ""
user_data["image"] = user_data["image"]
if user_type == 'student':
student_data = StudentSerializer(user.student).data
user_data["school_name"] = student_data["school"]["name"]
user_data["school_id"] = student_data["school"]["id"]
user_data["province_id"] = user.student.school.province.id
return JsonResponse(user_data)
def retrieve(self, request, *args, **kwargs):
"""
:param request:
:return: return product by gender
"""
self.serializer_class = SingleProductSerializer
instance = self.get_object()
serializer = self.get_serializer(instance)
product = serializer.data
product["groups"] = self.create_sample_form_field(product)
user_type = get_user_type(self.request.user)
if instance.deleted:
return Response(status=status.HTTP_404_NOT_FOUND)
if user_type == 'student':
if not instance.for_student:
return Response(status=status.HTTP_403_FORBIDDEN)
elif user_type == 'teacher':
if not instance.for_teacher:
return Response(status=status.HTTP_403_FORBIDDEN)
return Response(product)
def _user_type(obj):
return get_user_type(obj.creator)
def list(self, request, *args, **kwargs):
user_type = get_user_type(request.user)
list_tab = [{}]
if user_type == "student":
type_query = request.query_params.get("query_type", None)
if type_query == "top_school":
return self.get_top_school(request)
elif type_query == "citizen":
return self.get_citizen_school(request, user_type)
elif type_query == "provincial":
return self.get_provincial_school(request, user_type)
elif type_query == "same_point":
return self.get_same_point_school(request)
else:
student = Student.objects.filter(
id=request.user.id).select_related('school').get()
list_tab = copy.deepcopy(list_column_league_student)
# for item in list_tab:
# if item["query_type"] == "citizen" and student.school.point > MIN_POINT_CITIZEN:
# item["locked"] = False
# continue
#
# if item["query_type"] == "provincial" and student.school.point > MIN_POINT_PROVINCIAL:
# item["locked"] = False
# continue
response = {
"results": list_tab,
"rank": student.school.rank,
"point": student.school.point
}
return Response(response)
elif user_type == "teacher":
# متناسب با نقش در لیگ تب ها را نشان می دهیم
# if has_perm_both_gender(request.user):
# gender = "both"
# else:
# gender = request.user.baseuser.gender
role = request.GET.get('role', [])
gender = request.GET.get('gender', False)
camp_id, county_id, province_id = get_user_location_role(
request.user, role)
if role in ["county", "camp", "coach"]:
list_tab = copy.deepcopy(list_column_league_teacher)
elif role in ["province", "province_f", "province_m"]:
list_tab = copy.deepcopy(list_column_league_province)
elif role == "country":
list_tab = copy.deepcopy(list_column_league_country)
else:
list_tab = copy.deepcopy(list_column_league_country)
type_query = request.query_params.get("query_type", None)
if type_query == "top_school":
return self.get_top_school(request)
elif type_query == "citizen":
# return self.get_citizen_school(request, user_type)
return self.get_citizen_school_with_county_id(
county_id, gender)
elif type_query == "provincial":
return self.get_provincial_school_with_province_id(
province_id, gender)
else:
response = {"results": list_tab, "rank": 0, "point": 0}
return Response(response)
def list(self, request, *args, **kwargs):
res = []
user_type = get_user_type(request.user)
has_perm = has_perm_both_gender(request.user)
if has_perm:
gender_user = GENDER.get(
request.query_params.get('gender',
request.user.baseuser.gender),
request.user.baseuser.gender)
else:
gender_user = request.user.baseuser.gender
if user_type == "student":
self.newest_resanesh_festival(res, gender_user)
self.newest_revolution_school(res, gender_user)
self.newest_activity(res, gender_user)
self.most_point_activity(res, gender_user)
student = Student.objects.filter(
id=request.user.id).select_related('school')
if student.exists():
student = student.get()
province_id = student.school.province_id
self.newest_province_activity(res, province_id, gender_user)
county_id = student.school.county_id
self.newest_county_activity(res, county_id, gender_user)
camp_id = student.school.camp_id
self.newest_camp_activity(res, camp_id, gender_user)
elif user_type == "teacher":
self.newest_resanesh_festival(res, gender_user)
self.newest_revolution_school(res, gender_user)
self.newest_activity(res, gender_user)
self.most_point_activity(res, gender_user)
levels = get_user_level(request.user, "teacher")
camp_id, county_id, province_id = get_user_location(
request.user, levels)
if camp_id:
self.newest_camp_activity(res, camp_id, gender_user)
if county_id:
self.newest_county_activity(res, county_id, gender_user)
if province_id:
self.newest_province_activity(res, province_id, gender_user)
return Response({
"next": None,
"previous": None,
"count": len(res),
"results": res
})
