def create(self, request, *args, **kwargs) -> Response:
eat_habits_formatted = create_missing_eat_habits(request)
if eat_habits_formatted and len(eat_habits_formatted) > 0:
request.data['eat_habit'] = eat_habits_formatted
registration: event_models.Registration = self.participant_initialization(
request)
if request.data.get('age'):
request.data['birthday'] = timezone.now() - relativedelta(
years=int(request.data.get('age')))
request.data['registration'] = registration.id
if request.data.get('first_name') is None and request.data.get(
'last_name') is None:
max_num = self.get_queryset().count()
request.data['first_name'] = 'Teilnehmer'
request.data['last_name'] = max_num + 1
if request.data.get('booking_option') is None:
request.data[
'booking_option'] = registration.event.bookingoption_set.first(
).id
if registration.event.registration_deadline < timezone.now():
request.data[
'needs_confirmation'] = event_choices.ParticipantActionConfirmation.AddCompletyNew
return super().create(request, *args, **kwargs)
def by_days_range(self, days_ago=12, number_of_days=3):
if number_of_days > days_ago:
number_of_days = days_ago
start_date = timezone.now() - timedelta(days=days_ago)
end_date = timezone.now() - timedelta(days=days_ago - number_of_days)
return self.by_range(start_date, end_date=end_date)
def update(self, request, *args, **kwargs) -> Response:
print(request.data)
eat_habits_formatted = create_missing_eat_habits(request)
if eat_habits_formatted and len(eat_habits_formatted) > 0:
request.data['eat_habit'] = eat_habits_formatted
registration: event_models.Registration = self.participant_initialization(
request)
participant: event_models.RegistrationParticipant = self.get_object()
if participant.deactivated:
if request.data.get(
'activate'
) and registration.event.registration_deadline >= timezone.now():
request.data['deactivated'] = False
request.data[
'needs_confirmation'] = event_choices.ParticipantActionConfirmation.Nothing
elif registration.event.last_possible_update >= timezone.now():
request.data['deactivated'] = False
request.data[
'needs_confirmation'] = event_choices.ParticipantActionConfirmation.AddFromExisting
request.data['generated'] = False
return super().update(request, *args, **kwargs)
def estado(self):
if self.revocada:
return "Revocada"
elif self.fecha_inicio and self.fecha_inicio > timezone.now():
return "No activa"
elif self.fecha_expiracion and self.fecha_expiracion < timezone.now():
return "Expirada"
return "Activa"
def by_weeks_range(self, weeks_ago=3, number_of_weeks=2):
if number_of_weeks > weeks_ago:
number_of_weeks = weeks_ago
day_ago_start = weeks_ago * 7
day_ago_end = day_ago_start - (number_of_weeks * 7)
start_date = timezone.now() - timedelta(days=day_ago_start)
end_date = timezone.now() - timedelta(days=day_ago_end)
return self.by_range(start_date, end_date=end_date)
def test_remaining_job_queue(self):
s = RemainingJobs.objects.create(lower_date_bound=timezone.now() -
timedelta(hours=2),
upper_date_bound=timezone.now(),
reason_for_failure="nope")
x = RemainingJobs.objects.create(lower_date_bound=timezone.now() -
timedelta(hours=1),
upper_date_bound=timezone.now(),
reason_for_failure="nope")
assert RemainingJobs.get_oldest_job(
) == s, "should be oldest job in the queue"
def destroy(self, request, *args, **kwargs) -> Response:
registration: event_models.Registration = self.get_object()
participants_count = event_models.RegistrationParticipant.objects.filter(
registration=registration.id).count()
if participants_count == 0:
return super().destroy(request, *args, **kwargs)
if registration.event.last_possible_update < timezone.now():
raise event_api_exceptions.TooLate
elif registration.event.registration_deadline < timezone.now():
raise event_api_exceptions.TooManyParticipants
return super().destroy(request, *args, **kwargs)
def create_post(N):
fake = Faker()
for _ in range(N):
id = random.randint(1, 4)
title = fake.name()
status = random.choice(['published', 'draft'])
Post.objects.create(
title=title + " Post!!!",
author=User.objects.get(id=id),
slug="-".join(title.lower().split()),
body=fake.text(),
created=timezone.now(),
updated=timezone.now(),
)
def test_section_user_does_not_own_section(self):
"""
Test when a user attempts to access a section that they don't own.
"""
# create sample report with user 2
report = Report.objects.create(user_id=self.test_user_2,
title="Report Title",
date_created=timezone.now(),
reference_number="1234")
report.save()
# create sample section
section_0 = Section.objects.create(
report_id=report,
auto_submit=False,
required=False,
completed=False,
title='Section Zero',
html_description='<p>Description zero</p>',
number=0)
section_0.save()
# try to put with user 1
factory = APIRequestFactory()
put_section_request = factory.put('/api/v1/section/1',
{'key': 'value'})
force_authenticate(put_section_request, user=self.test_user_1)
result = section(put_section_request, 1)
self.assertEqual(result.status_code, 401)
def get_queryset(self):
geoJsonWareps = dict()
geoJsonStormWareps = {
"type": "FeatureCollection",
"metadata": {
"generated": "",
"url": "namc.com.ua",
"title": "Ukraine Actuals Storm Wareps",
},
"features": []
}
geoJsonAviaWareps = {
"type": "FeatureCollection",
"metadata": {
"generated": "",
"url": "namc.com.ua",
"title": "Ukraine Actuals Avia Wareps",
},
"features": []
}
queryset = WAREP.objects.select_related('station').filter(valid_end__gte=timezone.now()).order_by('-valid_end')
for warep in queryset:
jsonWarep = self.generateGeoJson(warep)
if warep.message.find('STORM') > -1:
geoJsonStormWareps['features'].append(jsonWarep)
elif warep.message.find('AVIA') > -1:
geoJsonAviaWareps['features'].append(jsonWarep)
geoJsonWareps = {'storm': json.dumps(geoJsonStormWareps), 'avia': json.dumps(geoJsonAviaWareps)}
return geoJsonWareps
def checkin(request):
assert isinstance(request, HttpRequest)
entryList=Entry.objects.all().filter(timeout=None)
count=entryList.count()
#utc_dt = datetime.now(timezone.utc)
#date = utc_dt.astimezone()
date=timezone.now()
daydate=d.today()
if request.method=="POST":
form=NameForm(request.POST)
if form.is_valid():
name,sk=form.cleaned_data['your_name'],form.cleaned_data['secret_key']
exist=Entry.objects.filter(name=name,secretkey=sk)
if exist.count()>0:
return render(request,"checkin.html",
{'entryList':entryList if count>0 else None,
'form':NameForm(),'date':daydate,
'status':'Already exist' })
entry=Entry(name=form.cleaned_data['your_name'] ,secretkey=form.cleaned_data['secret_key'],date=date,timein=date)
entry.save()
return HttpResponseRedirect(reverse('checkin'))
else:
form=NameForm()
return render(request,"checkin.html",{'entryList':entryList if count>0 else None,'form':form,'date':daydate,'status':"" })
def get_queryset(self):
return [
f.from_user
for f in Friend.objects.select_related("from_user").filter(
to_user=self.request.user,
from_user__lobby_expiration__gt=timezone.now()).all()
]
def getDoctor_PatientEstimatedTime(patient, doctor):
timepp = doctor.timepp
timefpp = doctor.timefpp
q_details = registration_models.appointmentQueue.objects.filter(
doctor_required=doctor, actual_time=None)
patientAhead = 0
followUpPatientAhead = 0
currentPatientInTime = None
for pats in q_details:
if (pats.patient == patient):
currentPatientInTime = pats.time_in
break
time_now = timezone.now()
for pats in q_details:
if (currentPatientInTime > pats.time_in and pats.patient != patient):
if (pats.is_follow_up == True):
followUpPatientAhead = followUpPatientAhead + 1
else:
patientAhead = patientAhead + 1
estimatedTime = timepp * (patientAhead) + timefpp * (followUpPatientAhead)
return {
"patientAhead": (patientAhead + followUpPatientAhead),
"estimatedTime": estimatedTime
}
def post(self, request):
serializer = LobbyExpirationSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=rest_framework.status.HTTP_400_BAD_REQUEST)
new_lobby_expiration = serializer.validated_data["lobby_expiration"]
with transaction.atomic():
# lazy ff request expiration
if min(request.user.lobby_expiration,
new_lobby_expiration) < timezone.now():
print(
f"Deleting expired requests to and from {request.user}..."
) # TODO: Replace with better logging.
FFRequest.objects.filter(
status=FFRequestStatusEnum.PENDING.value,
sender=request.user).update(
status=FFRequestStatusEnum.EXPIRED.value)
FFRequest.objects.filter(
status=FFRequestStatusEnum.PENDING.value,
receiver=request.user).update(
status=FFRequestStatusEnum.EXPIRED.value)
# print("Updating lobby expiration for a user from", repr(
# request.user.lobby_expiration), "to", repr(new_lobby_expiration))
request.user.lobby_expiration = new_lobby_expiration
request.user.save()
return HttpResponse(status=200)
def get_time_difference(value):
value = value.astimezone(get_localzone())
now = timezone.now().astimezone(get_localzone())
try:
return now - value
except:
return value
def clean(self):
cleaned_data = super(EventForm, self).clean()
title = cleaned_data.get('title')
description = cleaned_data.get('description')
location = cleaned_data.get('location')
start_time = cleaned_data.get('start_time')
end_time = cleaned_data.get('end_time')
# DateTime Sorting Validation
current_date_time = timezone.localtime(
timezone.now()).replace(microsecond=0)
time_diff = start_time - current_date_time
if time_diff.total_seconds() < 7200:
raise forms.ValidationError(
'The minimum event time is 2 hours after system time')
elif start_time > end_time:
raise forms.ValidationError(
'Start time cannot be greater than End Time')
elif start_time == end_time:
raise forms.ValidationError(
'Start time cannot be equal to End Time')
elif title == "a":
raise forms.ValidationError('Title error')
def get_queryset(self):
queryset = super().get_queryset()
days_count = self.request.query_params.get('day', 0)
if days_count > 0:
start_date = timezone.now() - timedelta(days=days_count)
queryset = queryset.filter(created_at__gte=start_date)
return queryset
def participant_initialization(self, request) -> event_models.Registration:
input_serializer = registration_serializers.RegistrationParticipantPutSerializer(
data=request.data)
input_serializer.is_valid(raise_exception=True)
registration_id = self.kwargs.get("registration_pk", None)
registration: event_models.Registration = get_object_or_404(
event_models.Registration, id=registration_id)
if registration.event.registration_start > timezone.now():
raise event_api_exceptions.TooEarly
elif self.action != 'destroy' and registration.event.last_possible_update < timezone.now(
):
raise event_api_exceptions.TooLate
return registration
def _get_oauth2_session(social_account):
refresh_token_url = FirefoxAccountsOAuth2Adapter.access_token_url
social_token = social_account.socialtoken_set.first()
def _token_updater(new_token):
social_token.token = new_token['access_token']
social_token.token_secret = new_token['refresh_token']
social_token.expires_at = (
timezone.now() + timedelta(seconds=int(new_token['expires_in'])))
social_token.save()
client_id = social_token.app.client_id
client_secret = social_token.app.secret
extra = {
'client_id': client_id,
'client_secret': client_secret,
}
expires_in = (social_token.expires_at - timezone.now()).total_seconds()
token = {
'access_token': social_token.token,
'refresh_token': social_token.token_secret,
'token_type': 'Bearer',
'expires_in': expires_in
}
client = OAuth2Session(client_id,
token=token,
auto_refresh_url=refresh_token_url,
auto_refresh_kwargs=extra,
token_updater=_token_updater)
return client
def get_context_data(self, **kwargs):
context = super(ServiceDetailView, self).get_context_data(**kwargs)
date = self.request.GET.get('date')
if date:
try:
date = datetime.strptime(date, '%Y-%m-%d').date()
except ValueError:
date = None
if not date:
date = timezone.now().date()
context['timetables'] = timetable_from_service(self.object, date)
if context.get('timetables'):
for table in context['timetables']:
table.groupings = [grouping for grouping in table.groupings if grouping.rows and grouping.rows[0].times]
for grouping in table.groupings:
grouping.rows = [row for row in grouping.rows if any(row.times)]
stops_id = []
for row in grouping.rows:
stops_id.append(row.part.stop.atco_code)
stops_dict = {stop.pk: stop for stop in Stop.objects.filter(atco_code__in=stops_id)}
for row in grouping.rows:
row.part.stop.stop = stops_dict.get(row.part.stop.atco_code)
return context
def date_diff2(self):
hoje = timezone.now()
tempocorrido = (hoje - self.datainicio).days
tempocorrido = tempocorrido / 7
if tempocorrido < 1:
tempocorrido = 1
return round(tempocorrido)
def test_section_report_already_submitted(self):
"""
Test what happens when a report has already been submitted(finalized).
"""
# create sample report already submitted
report = Report.objects.create(user_id=self.test_user_1,
title="Report Title",
date_created=timezone.now(),
reference_number="1234",
submitted=True)
report.save()
# create sample section
section_0 = Section.objects.create(
report_id=report,
auto_submit=False,
required=False,
completed=False,
title='Section Zero',
html_description='<p>Description zero</p>',
number=0)
section_0.save()
# try to put
factory = APIRequestFactory()
put_section_request = factory.put('/api/v1/section/1',
{'key': 'value'})
force_authenticate(put_section_request, user=self.test_user_1)
result = section(put_section_request, 1)
self.assertEqual(result.status_code, 409)
def menu_list(request):
# displays the listing of all Menus that havent reach their expiration date
all_menus = Menu.objects.all().prefetch_related('items')
query = Q(expiration_date__gte=timezone.now()) | Q(
expiration_date__isnull=True)
menus = all_menus.filter(query).order_by('-expiration_date')
return render(request, 'menu/list_all_current_menus.html',
{'menus': menus})
def filter_suspension(request):
user_profile = UserProfile.objects.all()
# suspend_user = [] # list of suspended users
suspend_user = list(
User.objects.filter(profile__suspension_time__gte=timezone.now()))
suspended_children = list(
Child.objects.filter(suspension_time__gte=timezone.now()))
# for user in user_profile:
# if user.suspension_time >= timezone.now():
# suspend_user.append(user)
# suspend_user.sort(
# key=lambda r: r.suspension_time) # filter by time left and keeping track of the time user has been suspended.
context = {
'suspend_user': suspend_user,
'suspended_children': suspended_children
}
return render(request, 'Preschool_Play/filter-suspension.html', context)
def create_expense(title, amount, days):
"""
Factory method to create an expense with a datetime.
"""
time = timezone.now() - datetime.timedelta(days=days)
return Expense.objects.create(title=title,
amount=amount,
transaction_date=time)
def create_schedule_flight():
for f in Flight.objects.all():
t_delta = timedelta(hours=randint(-70, 70), minutes=randint(0, 60))
ScheduleFlight.objects.create(
time_of_departure=timezone.now() + t_delta,
status=choice(
[val for val, label in SCHEDULE_FLIGHT_STATUS_CHOICES]),
flight=f)
def test_was_published_recently_with_old_question(self):
"""
was_published_recently() returns False for questions whose pub_date
is older than 1 day.
"""
time = timezone.now() - datetime.timedelta(days=1, seconds=1)
old_question = Question(pub_date=time)
self.assertIs(old_question.was_published_recently(), False)
def destroy(self, request, *args, **kwargs) -> Response:
registration: event_models.Registration = self.participant_initialization(
request)
if registration.event.last_possible_update < timezone.now():
request.data['deactivated'] = True
request.data[
'needs_confirmation'] = event_choices.ParticipantActionConfirmation.Nothing
return super().update(request, *args, **kwargs)
elif registration.event.registration_deadline < timezone.now():
request.data['deactivated'] = True
if not request.data.get('avoid_manual_check'):
request.data[
'needs_confirmation'] = event_choices.ParticipantActionConfirmation.Delete
return super().update(request, *args, **kwargs)
return super().destroy(request, *args, **kwargs)
def cliente_list(request):
user = request.user
if user.has_perm('app.administrador'):
clientes = Cliente.objects.filter(
published_date__lte=timezone.now()).order_by('published_date')
return render(request, 'app/listar_clientes.html', {'clientes': clientes})
else:
return render(request, 'app/menu.html')
def create(self, request, *args, **kwargs) -> Response:
registration: event_models.Registration = self.participant_group_initialization(
request)
number: int = request.data.get('number', 0)
existing_participants: QuerySet = event_models.RegistrationParticipant.objects.filter(
registration=registration.id)
active_participants: QuerySet = existing_participants.filter(
deactivated=False)
inactive_participants: QuerySet = existing_participants.filter(
deactivated=True)
active_participant_count: int = active_participants.count()
inactive_participant_count: int = inactive_participants.count()
total_participant_count: int = active_participant_count + inactive_participant_count
activate = min(inactive_participant_count, number)
create: int = max(number - total_participant_count, 0)
confirm_needed: bool = registration.event.registration_deadline < timezone.now(
)
if activate > 0:
if confirm_needed:
confirm = event_choices.ParticipantActionConfirmation.AddFromExisting
else:
confirm = event_choices.ParticipantActionConfirmation.Nothing
event_models.RegistrationParticipant.objects \
.filter(pk__in=inactive_participants.order_by('created_at').values_list('pk', flat=True)[:activate]) \
.update(deactivated=False, needs_confirmation=confirm)
if create > 0:
new_participants = []
if confirm_needed:
confirm = event_choices.ParticipantActionConfirmation.AddCompletyNew
else:
confirm = event_choices.ParticipantActionConfirmation.Nothing
booking: event_models.BookingOption = registration.event.bookingoption_set.first(
).id
for i in range(total_participant_count + 1, number + 1):
participant = event_models.RegistrationParticipant(
first_name='Teilnehmer',
last_name=i,
registration=registration,
generated=True,
needs_confirmation=confirm,
booking_option=booking)
new_participants.append(participant)
event_models.RegistrationParticipant.objects.bulk_create(
new_participants)
return Response({
'activated': activate,
'created': create
},
status=status.HTTP_201_CREATED)
def test_detail_rater_return_new_rating(self):
test_user = User.objects.create_user('test', '*****@*****.**', 'pass')
test_user.save()
time = timezone.now()
rating = Rating(rater=1, movie=3, rating=5, timestamp=time)
rating.save()
response = self.client.get(reverse('detail_rater', args=[rater.id]))
self.assertContains(response, 'Testing')
def interesado_create(request):
if request.method == 'POST':
form = InteresadosForm(request.POST)
if form.is_valid():
interesados = Interesados (
nombres = form.cleaned_data['nombre'],
apellidoPaterno = form.cleaned_data['apellido'],
email = form.cleaned_data['email'],
telefono = form.cleaned_data['telefono'],
extension = form.cleaned_data['extension'],
celular = form.cleaned_data['celular'],
fecha = timezone.now())
interesados.save()
return render_to_response('micSitCeg/gracias.html', {}, content_type="text/html")
else:
#form =InteresadosForm()
#return render_to_response('micSitCeg/index.html', {}, content_type="text/html")
return redirect('/micrositios/')
else:
return redirect('/micrositios/nopost')
def check(self):
from datetime import datetime, timezone
from django.utils import timezone
from timetable.utils import utc_to_local
now = utc_to_local(timezone.now())
actives_games = Game.objects.all().filter(is_completed = False)
for game in actives_games:
last_step = Step.objects.filter(game = game).latest('id')
print(now, last_step.date)
step_time = last_step.date
time_delta = now - step_time
print(time_delta)
print(time_delta.seconds)
delta_hours = math.floor(time_delta.seconds / 3600)
print(delta_hours)
if (delta_hours >= 1):
for i in range(0, delta_hours):
print('шаг #', i)
self.step(game)
def stato_riserva(riserva):
ATTUALE = 'Attuale'
PASSATA = 'Passata'
# Se la riserva non è iniziata ne passata allora non mostriamo niente fino alla sua attivazione
NON_ATTIVA = ''
oggi = timezone.now()
# La riserva no ha una fine è in stato indeterminato
if not riserva.fine:
return ATTUALE
# se il giorno odierno e compreso tra inizio e fine delle riserve, questa è attuale
if riserva.inizio <= oggi <= riserva.fine:
return ATTUALE
# se il giorno odierno è maggiore della fine riserva, questa è passata
elif oggi > riserva.fine:
return PASSATA
# se il giorno di inizio della riserva è maggiore del giorno odierno, questa non è ancora attiva
elif riserva.inizio > oggi:
return NON_ATTIVA
def test_was_published_recently_with_recent_question(self):
time = timezone.now() - datetime.timedelta(hours=1)
recent_question = Question(pub_date=time)
self.assertEqual(recent_question.was_published_recently(), True)
def contact(request):
if request.user.groups.filter(name='Students'):
if request.method == 'POST':
form = ContactForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
request = Request.objects.create_request(request.certificate_id , request.user.mysiteprofile.group, request.user.last_name, request.user.first_name, request.user.mysiteprofile.father_name, cd, timezone.now())
request.save()
return HttpResponseRedirect('/practiceapp/thanks/')
#return render_to_response('practiceapp/contact_form.html', {'form': form})
else:
form = ContactForm(
)
return render_to_response('practiceapp/contact_form.html', {'form': form})
else:
return render(request, 'registration/login.html')
def age(self):
return (timezone.now() - self.creation_date).days
def valido(self):
from django.utils import timezone
return timezone.now() <= (self.creazione + timedelta(hours=self.valido_ore))
def create_question(question_text, days):
time = timezone.now() + datetime.timedelta(days=days)
return Question.objects.create(question_text=question_text, pub_date=time)
def create_request(self, certificate, group, name, surname, father_name, amount):
request = self.create(certificate=certificate, group=group, name=name, surname=surname, father_name=father_name, amount=amount, pub_date= timezone.now())
return request
def test_was_published_recently_with_old_question(self):
time = timezone.now() - datetime.timedelta(days=30)
old_question = Question(pub_date=time)
self.assertEqual(old_question.was_published_recently(), False)
def was_published(self):
#before unittest
#return self.pub_date >= timezone.now() - datetime.timedelta(days=1)
return timezone.now() - datetime.timedelta(days=1) <= self.pub_date <= timezone.now()
def test_was_recently_published_future_rating(self):
time = timezone.now() + datetime.timedelta(days=10)
rating = Rating(rater=2, movie=44, rating=5, timestamp=time)
self.assertFalse(rating.was_published_recently(), "Rating not recent")
