def date_directory_path(instance, filename):
if instance.date:
now = instance.date
else:
now = datetime.now()
year = now.strftime("%Y")
month = now.strftime("%m")
day = now.strftime("%d")
return 'uploads/{0}/{1}/{2}/{3}'.format(year, month, day, filename)
def issue_print(request):
issue_list = Issue.objects.filter(date_completed__isnull=True).filter(
deleted=False).order_by('vehicle__vehicle_name')
response = HttpResponse(content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename="printout.pdf"'
now = datetime.datetime.now()
p = canvas.Canvas(response, bottomup=0, pagesize=letter)
vertValue = 40
p.drawString(30, vertValue, "Vehicle")
p.drawString(85, vertValue, "Priority")
p.drawString(130, vertValue, "Reason")
p.drawString(220, vertValue, "Problem")
#add date that the report was generated
p.drawString(420, vertValue, now.strftime("Report Generated %m/%d/%Y"))
vertValue = 70
page_entry = 1
page_number = 1
for issue in issue_list:
if (page_entry == 36):
p.drawString(550, vertValue, "page {0}".format(page_number))
page_entry = 1
page_number += 1
p.showPage()
vertValue = 40
p.drawString(30, vertValue, "Vehicle")
p.drawString(85, vertValue, "Priority")
p.drawString(130, vertValue, "Reason")
p.drawString(220, vertValue, "Problem")
#add date that the report was generated
p.drawString(420, vertValue,
now.strftime("Report Generated %m/%d/%Y"))
vertValue = 70
p.drawString(30, vertValue, issue.vehicle.vehicle_name)
p.drawString(85, vertValue, issue.severity)
p.drawString(130, vertValue, issue.reason)
p.drawString(220, vertValue, issue.description)
vertValue = vertValue + 20
page_entry += 1
p.drawString(550, 770, "page {0}".format(page_number))
p.showPage()
p.save()
return response
def get(self, request, exam_id):
user_id = request.headers.get('userid')
try:
user_obj = CustomUser.objects.get(id=user_id)
except CustomUser.DoesNotExist:
return Response({"status": "404","message": messages.DOES_NOT_EXIST}, status=status.HTTP_404_NOT_FOUND)
try:
exam_obj = Exam.objects.get(id=exam_id)
print("exam_obj",exam_obj,exam_id)
except Exam.DoesNotExist:
return Response({"status": "404","message": messages.DOES_NOT_EXIST}, status=status.HTTP_404_NOT_FOUND)
permission_object = Permission.objects.get(name="Exam Managment")
permission_list = [permission.id for permission in user_obj.permission.all()]
is_permission = True if permission_object.id in permission_list else False
if is_permission:
from datetime import datetime
now = datetime.now()
now1 = datetime.now()
now = now.strftime("%d/%m/%Y %H:%M:%S")
now1 = now1.strftime("%Y-%m-%d %H:%M:%S")
myDate = datetime.strptime(now,"%d/%m/%Y %H:%M:%S")
# myDate = localtime(now)
startDate = exam_obj.schedule_date_time
startDate = localtime(startDate)
startDate = startDate.strftime("%d/%m/%Y %H:%M:%S")
startDate = datetime.strptime(startDate,"%d/%m/%Y %H:%M:%S")
endDate = exam_obj.end_date_time
endDate = localtime(endDate)
endDate = endDate.strftime("%d/%m/%Y %H:%M:%S")
endDate = datetime.strptime(endDate,"%d/%m/%Y %H:%M:%S")
print("myDate",myDate)
print("start",startDate)
print("end",endDate)
if myDate < startDate:
print("befor start")
return Response({"status":"400","message": "You can not start exam before date or time!"}, status=status.HTTP_400_BAD_REQUEST)
elif myDate > endDate: # 16 > 15
print("after start")
return Response({"status":"400","message": "You can not start exam after date or time!"}, status=status.HTTP_400_BAD_REQUEST)
elif myDate < endDate:
if myDate > startDate or myDate == startDate:
print("start exam")
difference = endDate - startDate
print("difference", difference)
total_seconds = difference.total_seconds()
print("total_seconds",total_seconds)
exam_obj.total_seconds = total_seconds
exam_obj.save()
return Response({"status":"200","message": "Best of luck!! <br> please do not refresh page.","data":{"startTime":now1,'admin_id':exam_obj.created_by,'student_id':user_obj.id,'exam_id':exam_obj.id}}, status=status.HTTP_200_OK)
else:
print("something wrong")
return Response({"status":"400","message": messages.SOMETHING_WRONG}, status=status.HTTP_400_BAD_REQUEST)
return Response({"status": "401","message": messages.UNAUTHORIZED}, status=status.HTTP_401_UNAUTHORIZED)
def test_get_file_path_50(instance, filename):
ext = filename.split('.')[-1]
from django.utils.timezone import now
now = now()
now_date = now.strftime('%Y-%m-%d-%H-%M-%S')
filename = "50_%s_%s.%s" % (now_date, uuid.uuid4(), ext)
return os.path.join('photo/%s/testphoto' % filename)
def get_file_path_solo_celeb_photo_50(instance, filename):
ext = filename.split('.')[-1]
id = instance.solo.uuid
from django.utils.timezone import now
now = now()
now_date = now.strftime('%Y-%m-%d-%H-%M-%S')
filename = "50_%s_%s.%s" % (now_date, uuid.uuid4(), ext)
return os.path.join('photo/solo/%s' % id, filename)
def add_to_processing(self, order_id):
now = datetime.now()
current = json.loads(self.orderprocessing)
cart = json.loads(self.cart)
current[str(order_id)] = {'time': now.strftime('%Y-%m-%d %H:%M:%S'),
'amount': self.current_cart_value,
'cart': cart},
self.orderprocessing = json.dumps(current, indent=2)
self.save()
def get_file_path(instance, filename):
ext = filename.split('.')[-1]
usernum = instance.user.username
from django.utils.timezone import now
now = now()
now_date = now.strftime('%Y-%m-%d-%H-%M-%S')
filename = "300_%s_%s.%s" % (now_date, uuid.uuid4(), ext)
return os.path.join('photo/%s/userphoto' % usernum, filename)
def get_file_path_post_chat_photo(instance, filename):
ext = filename.split('.')[-1]
usernum = instance.post_chat.post.user.username
from django.utils.timezone import now
now = now()
now_date = now.strftime('%Y-%m-%d-%H-%M-%S')
filename = "_%s_%s.%s" % (now_date, uuid.uuid4(), ext)
return os.path.join('photo/%s/post_chat_photo/%s' % (usernum, instance.post_chat.post.pk), filename)
def is_valid(self):
now = datetime.now()
current_time = now.strftime("%H:%M:%S")
if self.debut_heure_arrivee.strftime(
"%H:%M:%S") < current_time and self.fin_heure_arrivee.strftime(
"%H:%M:%S") > current_time:
return True
else:
return False
def post(self, request):
user_id = request.headers.get('userid')
try:
user_obj = CustomUser.objects.get(id=user_id)
except CustomUser.DoesNotExist:
return Response({"status": "404","message": messages.DOES_NOT_EXIST}, status=status.HTTP_404_NOT_FOUND)
permission_object = Permission.objects.get(name="Exam Managment")
permission_list = [permission.id for permission in user_obj.permission.all()]
is_permission = True if permission_object.id in permission_list else False
if is_permission:
from datetime import datetime
now = datetime.now()
print("end time",now)
try:
ip = get('https://api.ipify.org').text
except Exception as e: #ConnectionError
print("error",e)
return Response({"status":"500","message":"Check your internet connectivity."},status=status.HTTP_500_INTERNAL_SERVER_ERROR)
print("data----",request.data)
# now1 = localtime(now)
now1 = now.strftime("%d/%m/%Y %H:%M:%S")
print("now1 strftime",now1)
now1 = datetime.strptime(now1,"%d/%m/%Y %H:%M:%S")
# now1 = datetime.fromisoformat(str(now))
print("now1",now1)
# startTime = datetime.strptime(request.data['test_date_time'],"%Y-%m-%dT%H:%M:%S.%f%z")
startTime = request.data['test_date_time']
# startTime = datetime.fromisoformat(request.data['test_date_time'])
# startTime = request.data['test_date_time'].strftime("%d/%m/%Y %H:%M:%S")
# startTime = startTime.strftime("%d/%m/%Y %H:%M:%S")
startTime = datetime.strptime(startTime,"%Y-%m-%d %H:%M:%S")
print("startTime",startTime)
diffrence = now1 - startTime
print('diff----',diffrence)
serializer = ResultExamSerilizer(data=request.data)
if serializer.is_valid():
print('valid')
serializer.save()
print('seri done')
result_obj = StudentResult.objects.all().last()
print('result',result_obj)
print("IP",ip)
result_obj.ip_address = ip
result_obj.taken_time = str(diffrence)
result_obj.is_active = True
result_obj.save()
return Response({"status":"201","message": messages.CREATED, "data": serializer.data},status=status.HTTP_201_CREATED)
return Response({"status":"400","message":serializer.errors},status=status.HTTP_400_BAD_REQUEST)
return Response({"status": "401","message": messages.UNAUTHORIZED}, status=status.HTTP_401_UNAUTHORIZED)
def get_file_path_50(instance, filename):
ext = filename.split('.')[-1]
# 파일의 확장자를 빼낸다.
usernum = instance.user.username
# 그 인스턴스의 유저고유 ID number 를 가져온다.
from django.utils.timezone import now
now = now()
# 현재시간을 가져온다.
now_date = now.strftime('%Y-%m-%d-%H-%M-%S')
# 현재시간을 스트링포맷으로 잡아준다.
import uuid
import os
filename = "%s_%s_%s.%s" % ("50", now_date, uuid.uuid4().hex, ext)
# uuid 는 랜덤 스트링 뽑아낼 때 씀
return os.path.join('photo/%s/userphoto' % usernum, filename)
def shows(request, movie, city, day, hall):
now = datetime.now()
current_time = now.strftime("%H:%M")
if city == "any":
theatres = Theatre.objects.all()
else:
cityName = City.objects.get(name=city)
theatres = Theatre.objects.filter(city=cityName)
if hall == "any":
halls = Hall.objects.filter(theatre__id__in=theatres)
else:
halls = Hall.objects.filter(hall_type=hall, theatre__id__in=theatres)
datetime_obj = datetime.strptime(day, "%d %B, %Y")
date = datetime_obj.date()
movie_obj = Movie.objects.get(name=movie)
shows = Show.objects.filter(movie=movie_obj, hall__id__in=halls, date=date)
return JsonResponse([show.serialize() for show in shows], safe=False)
def add_to_purchased(self,order_id,amount):
now = datetime.now()
current = json.loads(self.orderpurchased)
orderprocessing = json.loads(self.orderprocessing)
ordersuccessful = orderprocessing[str(order_id)][0]['cart']
purchased_quizes = self.get_purchased_list
if ordersuccessful:
for key, value in ordersuccessful.items():
if int(key) not in purchased_quizes:
if len(self.purchased_list) > 0:
self.purchased_list += ','
self.purchased_list += str(key)
current[str(order_id)]= {'purchased_time': now.strftime('%Y-%m-%d %H:%M:%S'),
'amount_paid': str(amount),
'order':ordersuccessful,
}
self.orderpurchased = json.dumps(current, indent=2)
orderprocessing.pop(str(order_id),None)
self.orderprocessing = json.dumps( orderprocessing, indent=2)
self.remove_from_cart
self.save()
def get_week_by_now():
""" Retorna el número de setmana segons avui """
now = datetime.datetime.now()
return int(now.strftime("%V"))
class User(AbstractUser):
"""
Defines our custom user model.
"""
PRETTY_TIMEZONE_CHOICES = [("", _("--- Selecciona ---"))]
for tz in pytz.common_timezones:
now = datetime.now(pytz.timezone(tz))
PRETTY_TIMEZONE_CHOICES.append(
(tz, "%s (GMT %s)" % (tz, now.strftime("%z"))))
# Public profile information
featured = models.BooleanField(default=False)
bio = models.TextField(blank=True)
twitter_username = models.CharField(blank=True, max_length=50)
facebook_username = models.CharField(blank=True, max_length=50)
github_username = models.CharField(blank=True, max_length=50)
linkedin_url = models.URLField(blank=True)
website_url = models.URLField(blank=True)
gravatar_url = models.URLField(blank=True)
is_gravatar_verified = models.BooleanField(default=False)
city = models.CharField(blank=True, max_length=50)
state = models.CharField(blank=True, max_length=50)
# Meeting availability
day_of_week = DaysOfWeekField(blank=True, null=True, db_index=True)
start_time = models.TimeField(null=True, blank=True)
timezone = models.CharField(
max_length=255,
default=settings.HORAS_DEFAULT_TZ,
choices=PRETTY_TIMEZONE_CHOICES,
)
# Kept private until meeting
phone = models.CharField(blank=True, max_length=50)
skype = models.CharField(blank=True, max_length=50)
google = models.CharField(blank=True, max_length=50)
jitsi = models.CharField(blank=True, max_length=50)
address = models.TextField(blank=True)
tags = TaggableManager(blank=True)
date_updated = models.DateTimeField(auto_now=True)
def save(self, *args, **kwargs):
if not self.gravatar_url:
self.gravatar_url = get_gravatar_url(self.email)
# Check if meeting availability changed
if self.has_complete_profile():
original = User.objects.get(pk=self.pk)
checks = [
original.day_of_week != self.day_of_week,
original.start_time != self.start_time,
original.timezone != self.timezone,
]
# if any field changed then we must
# delete meetings and create a new one
if any(checks):
print("---> meeting preferences changed")
Meeting = apps.get_model("meetings", "Meeting")
available_meetings = Meeting.objects.filter(
state=Meeting.STATES.AVAILABLE.value, mentor=self)
for meeting in available_meetings:
meeting.flag_deleted()
meeting.save()
self.get_or_create_meeting()
super().save(*args, **kwargs)
def get_absolute_url(self):
return reverse_lazy("profile_detail", args=[self.username])
def get_url_with_domain(self):
domain = Site.objects.get_current().domain
return f"{settings.PROTOCOL}://{domain}{self.get_absolute_url()}"
def get_tiny_name(self):
return f"{self.first_name[0]}. {self.last_name}"
def has_complete_profile(self):
dates = all([
str(self.day_of_week),
str(self.start_time),
self.timezone,
self.city,
self.state,
self.bio,
self.first_name,
self.last_name,
])
contact = any(
[self.phone, self.skype, self.google, self.jitsi, self.address])
return all([dates, contact])
def has_social_links(self):
return any([
self.twitter_username,
self.github_username,
self.linkedin_url,
self.website_url,
])
def get_location(self):
if self.city and self.state:
return f"{self.city}, {self.state}"
elif self.city:
return self.city
elif self.state:
return self.state
def get_all_meeting_formats(self):
available_formats = (
(self.phone, "phone", _("Teléfono")),
(self.skype, "skype", _("Skype")),
(self.google, "google", _("Google")),
(self.jitsi, "jitsi", _("Jitsi")),
(
self.address,
"inperson",
_("En persona") + f" ({self.city}, {self.state})",
),
)
return available_formats
def get_meeting_format_information(self, key):
all_formats = self.get_all_meeting_formats()
for format in all_formats:
if key == format[1]:
return format[0]
return False
def get_meeting_format_name(self, key):
all_formats = self.get_all_meeting_formats()
for format in all_formats:
if key == format[1]:
return format[2]
return False
def get_meeting_formats(self):
all_formats = self.get_all_meeting_formats()
output = []
for format in all_formats:
if format[0]:
output.append((format[1], format[2]))
return output
def get_meeting_formats_string(self):
formats = self.get_meeting_formats()
output = []
for format in formats:
output.append(format[1])
return ", ".join(sorted(output))
def get_or_create_meeting(self):
if self.has_complete_profile() and self.is_active:
Meeting = apps.get_model("meetings", "Meeting")
user_tz = pytz.timezone(self.timezone)
date = next_weekday(now(), self.day_of_week)
next_slot_local = make_aware(
datetime.combine(date, self.start_time), user_tz)
default_tz = get_default_timezone()
next_slot = next_slot_local.astimezone(default_tz)
week = week_range(next_slot)
# Getto get_or_create
try:
meeting_slot = Meeting.objects.get(
Q(state=Meeting.STATES.AVAILABLE.value)
| Q(state=Meeting.STATES.RESERVED.value)
| Q(state=Meeting.STATES.CONFIRMED.value),
mentor=self,
datetime__range=week,
)
created = False
except Meeting.DoesNotExist:
meeting_slot = Meeting.objects.create(mentor=self,
datetime=next_slot)
created = True
# Notify user
if created:
print(f"-> Created meeting_slot:{meeting_slot}")
return meeting_slot, created
return None, False
def update_score(self, quiz,sitting):
"""
Pass in quiz object, amount to increase score
and max possible.
Does not return anything.
"""
quiz_test = Quiz.objects.filter(pk=quiz.id) \
.exists()
if any([item is False for item in [quiz_test
]]):
return "error quiz does not exist or invalid score"
percentage_scored = sitting.get_percent_correct
total_score = sitting.current_score
quiz.add_or_update_user_score(sitting.user,total_score)
result = sitting.result_message
max_mark = Question.objects.filter(quiz=quiz).aggregate(Sum('max_mark'))['max_mark__sum']
quiz_passing_percentage = quiz.passing_percentage
marks_deducted = 0
positive_marks = 0
question_correct = 0
for q in sitting.correct_questions.split(','):
if q:
question_correct += 1
correct_question = Question.objects.get(pk=q)
positive_marks += correct_question.max_mark
question_incorrect = 0
incorrect_answered_mark = 0
for q in sitting.incorrect_questions.split(','):
if q:
question_incorrect += 1
incorrect_question = Question.objects.get(pk=q)
incorrect_answered_mark += incorrect_question.max_mark
marks_deducted += incorrect_question.negative_marking
question_left = 0
marks_left = 0
for q in sitting.unanswered_list.split(','):
if q:
question_left += 1
left_question = Question.objects.get(pk=q)
marks_left += left_question.max_mark
current = json.loads(self.score)
now = datetime.now()
if quiz.exam_paper == "True":
quiz_category ="Exam Paper"
else:
quiz_category = "Practice Paper"
current[str(quiz.id)] = {'quiz_title': quiz.title,
'quiz_category': quiz_category,
'completed_on': now.strftime('%d-%m-%Y %H:%M'),
'no_of_question_correct': question_correct,
'no_of_question_incorrect': question_incorrect,
'no_of_question_left': question_left,
'correct_answered_marks': positive_marks,
'incorrect_answered_mark': incorrect_answered_mark,
'marks_left': marks_left,
'negative_marks': marks_deducted,
'net_score': total_score,
'max_mark_of_quiz': max_mark,
'percentage_scored': percentage_scored,
'quiz_passing_percentage': quiz_passing_percentage,
'result': result}
self.score = json.dumps(current, indent=2)
new = json.loads(self.all_quiz_records)
if not new.get('all_records'):
new['all_records'] = {'no_of_exams_appeared': 0,
'no_of_exams_passed': 0,
'no_of_practice_paper_appeared': 0,
'no_of_practice_paper_passed': 0
}
self.all_quiz_records = json.dumps(new, indent=2)
self.save()
