def get_queryset(self):
two_week_interval = int(self.request.GET.get('week', 0)) * 14
cursor = connection.cursor()
cursor.execute('SELECT DISTINCT(e.start::date) FROM "events_event" AS e INNER JOIN "events_recording" AS rec'
' ON e.id=rec.event_id WHERE date_part(\'hour\', e.start) > 12 ORDER BY start DESC LIMIT 14 OFFSET %s', [two_week_interval])
dates = [d[0] for d in cursor.fetchall()]
date_range_start = datetime.combine(dates[-1], std_time(10, 0))
self.date_start = date_range_start
date_range_end = dates[0] + timedelta(days=1)
date_range_end = datetime.combine(date_range_end, std_time(4, 0))
events = Event.objects.exclude(recordings=None).filter(start__gte=date_range_start, start__lte=date_range_end).order_by('start')
if not self.request.user.is_staff:
events = events.exclude(state=Event.STATUS.Draft)
events = events.annotate(product_count=Count('products')).extra(select={
'video_count': "SELECT COUNT(*) FROM events_recording, multimedia_mediafile WHERE "
"events_recording.event_id = events_event. ID AND "
"events_recording.media_file_id = multimedia_mediafile. ID AND "
" events_recording. STATE = 'Published' AND multimedia_mediafile.media_type='video'"
" GROUP BY events_event.id",
'audio_count': "SELECT COUNT(*) FROM events_recording, multimedia_mediafile WHERE "
"events_recording.event_id = events_event. ID AND "
"events_recording.media_file_id = multimedia_mediafile. ID AND "
" events_recording. STATE = 'Published' AND multimedia_mediafile.media_type='audio'"
" GROUP BY events_event.id",
})
dates = {}
for k, g in groupby(events, lambda e: e.listing_date()):
dates[k] = list(g)
sorted_dates = OrderedDict(sorted(dates.items(), key=lambda d: d[0])).items()
return sorted_dates
def validate_date(self, value):
"""
validate the date field
- the date must not have the duplicate for one host
- Host cant register in date that host is service
- Host cant register date in the past
"""
host = Host.objects.get(account=self.context["request"].user)
if value < date.today():
raise serializers.ValidationError("Do you have a time machine?")
if HostAvailableDate.objects.filter(date=value, host=host).exists():
raise serializers.ValidationError(
"This date has already been assigned for this host")
min_time = datetime.min.time()
in_progess_service = Services.objects.filter(
host=host,
service_start_time__lte=make_aware(
datetime.combine(value, min_time)),
service_end_time__gte=make_aware(datetime.combine(value,
min_time)),
main_status__in=["in_progress", "wait_for_progress", "payment"],
)
if in_progess_service.exists():
raise serializers.ValidationError(
"This date in in your service date")
return value
def today(self):
from django.utils import timezone
from django.utils.timezone import datetime, timedelta
today = timezone.now().date()
tomorrow = today + timedelta(1)
today_start = datetime.combine(today, timezone.now().time())
today_end = datetime.combine(tomorrow, timezone.now().time())
today_start = timezone.make_aware(today_start,
timezone.get_current_timezone())
today_end = timezone.make_aware(today_end,
timezone.get_current_timezone())
return self.filter(time__lte=today_end, time__gte=today_start)
def send_report_from_subscriptions():
User = get_user_model()
date_till = datetime.combine(date.today(),
datetime.min.time()).replace(tzinfo=pytz.utc)
date_from = date_till - timedelta(days=1)
for user in User.objects.filter(state='active'):
user.send_subscriptions_report(date_from, date_till)
return {}
def aware_timedelta_days(to_move: datetime,
timedelta_days: timedelta) -> datetime:
# This is to check for correct timezone/DST setting, see why we separate date and time here:
# https://gist.github.com/codeinthehole/1ac10da7874033406f25f86df07b88ff
to_move_date = localdate(to_move) + timedelta_days
to_move_time = localtime(to_move).time()
return make_aware(datetime.combine(to_move_date, to_move_time))
def count(users, hour, day):
count = 0
start_time = datetime.time(second=0, hour=hour, minute=0)
end_time = datetime.time(hour=hour + 2, minute=0, second=0)
start = dt.combine(day, start_time)
end = dt.combine(day, end_time)
print start
for user in users:
tasks_start = Task.objects.filter(user=user,
start_time__range=(start, end))
tasks_end = \
Task.objects.exclude(user=user,
start_time__range=(start, end)).filter(user=user,
end_time__range=(start, end))
print tasks_end
count += tasks_start.count() + tasks_end.count()
return count
def get_current_scheduling_block(self) -> (datetime, datetime):
tz = self.get_timezone()
rn = tz.normalize(now())
start = max(rn, tz.localize(datetime.combine(rn.date(), self.start_day_at)))
end = tz.localize(datetime.combine(rn.date(), self.end_day_at))
if rn.time() >= self.end_day_at:
# The end time has passed; time to schedule tomorrow
start = tz.localize(
datetime.combine(rn.date(), self.start_day_at)
) + timedelta(days=1)
end = tz.localize(datetime.combine(rn.date(), self.end_day_at)) + timedelta(
days=1
)
if not str(start.isoweekday()) in self.days_of_week.split():
return None
return (start, end)
class TaskWeekAPIView(APIView):
""" api for task in a week"""
first_day = timezone.make_aware(
dt.combine(datetime.date.today(), datetime.time()),
timezone.get_current_timezone())
second_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=1),
datetime.time()), timezone.get_current_timezone())
third_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=2),
datetime.time()), timezone.get_current_timezone())
fourth_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=3),
datetime.time()), timezone.get_current_timezone())
fifth_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=4),
datetime.time()), timezone.get_current_timezone())
sixth_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=5),
datetime.time()), timezone.get_current_timezone())
seventh_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=6),
datetime.time()), timezone.get_current_timezone())
eighth_day = timezone.make_aware(
dt.combine(datetime.date.today() + datetime.timedelta(days=7),
datetime.time()), timezone.get_current_timezone())
def get_queryset(self, day1, day2):
user = self.request.user
queryset = Task.objects.filter(user=user,
start_time__range=(day1, day2))
return queryset
def get_serializer(self, day1, day2):
queryset = self.get_queryset(day1=day1, day2=day2)
serializer = TaskListSerializer(queryset,
context={'request': self.request},
many=True)
return serializer.data
def get(self, request, *args, **kwargs):
week_dict = {
'first_day': self.get_serializer(self.first_day, self.second_day),
'second_day': self.get_serializer(self.second_day, self.third_day),
'third_day': self.get_serializer(self.third_day, self.fourth_day),
'fourth_day': self.get_serializer(self.fourth_day, self.fifth_day),
'fifth_day': self.get_serializer(self.fifth_day, self.sixth_day),
'sixth_day': self.get_serializer(self.sixth_day, self.seventh_day),
'seventh_day': self.get_serializer(self.seventh_day,
self.eighth_day)
}
return Response(week_dict, status=HTTP_200_OK)
def get_context_data(self, **kwargs):
context = super(
AgendaContactoDetailView, self).get_context_data(**kwargs)
agente_profile = self.request.user.get_agente_profile()
fechas_agendas = AgendaContacto.objects.proximas(agente_profile).values_list(
'fecha', 'hora')
fechas_agendas = [
make_aware(datetime.combine(x[0], x[1])).isoformat() for x in fechas_agendas]
context['fechas_agendas_json'] = json.dumps(fechas_agendas)
return context
def get_queryset(self):
two_week_interval = int(self.request.GET.get('week', 0)) * 14
cursor = connection.cursor()
cursor.execute(
'SELECT DISTINCT(e.start::date) FROM "events_event" AS e INNER JOIN "events_recording" AS rec'
' ON e.id=rec.event_id WHERE date_part(\'hour\', e.start) > 12 ORDER BY start DESC LIMIT 14 OFFSET %s',
[two_week_interval])
dates = [d[0] for d in cursor.fetchall()]
date_range_start = datetime.combine(dates[-1], std_time(10, 0))
self.date_start = date_range_start
date_range_end = dates[0] + timedelta(days=1)
date_range_end = datetime.combine(date_range_end, std_time(4, 0))
events = Event.objects.exclude(recordings=None).filter(
start__gte=date_range_start,
start__lte=date_range_end).order_by('start')
if not self.request.user.is_staff:
events = events.exclude(state=Event.STATUS.Draft)
events = events.annotate(product_count=Count('products')).extra(
select={
'video_count':
"SELECT COUNT(*) FROM events_recording, multimedia_mediafile WHERE "
"events_recording.event_id = events_event. ID AND "
"events_recording.media_file_id = multimedia_mediafile. ID AND "
" events_recording. STATE = 'Published' AND multimedia_mediafile.media_type='video'"
" GROUP BY events_event.id",
'audio_count':
"SELECT COUNT(*) FROM events_recording, multimedia_mediafile WHERE "
"events_recording.event_id = events_event. ID AND "
"events_recording.media_file_id = multimedia_mediafile. ID AND "
" events_recording. STATE = 'Published' AND multimedia_mediafile.media_type='audio'"
" GROUP BY events_event.id",
})
dates = {}
for k, g in groupby(events, lambda e: e.listing_date()):
dates[k] = list(g)
sorted_dates = OrderedDict(sorted(dates.items(),
key=lambda d: d[0])).items()
return sorted_dates
def to_step_start(time, offset=0):
"""Calculate the exact time (midnight) of the previous timestep as
defined by the project settings. The optional offset parameter
increments or decrements the provided number of weeks
"""
return datetime.combine(
time.date() - timedelta(days=(
(time.weekday() - DAYS.index(settings.DISTRIBUTION_DAY)) %
len(DAYS)) - offset * len(DAYS)),
datetime.min.time(),
tzinfo=time.tzinfo,
)
def create_slot_times(self):
try:
days = get_week_map_by_weekday(
get_range_days(self.start_date, self.end_date))
except Exception as e:
raise e
if self.booking_type.dailyslottimepattern_set.count() == 0:
raise ValueError("{title} has no related DailySlotTimePattern "
"objects".format(title=self.booking_type.title))
count = 0
for pattern in self.booking_type.dailyslottimepattern_set.all():
for day in days[str(pattern.day)]:
cache_start_datetime = make_aware(
datetime.combine(day, pattern.start_time),
get_current_timezone())
end_datetime = make_aware(
datetime.combine(day, pattern.end_time),
get_current_timezone())
while (((end_datetime - cache_start_datetime).seconds / 60)
>= pattern.booking_type.slot_length):
start_slot = cache_start_datetime
end_slot = cache_start_datetime + timedelta(
minutes=pattern.booking_type.slot_length)
try:
slot, created = (
self.slottime_set.get_or_create(
booking_type=pattern.booking_type,
start=start_slot,
end=end_slot,
user=self.user))
if created:
count += 1
except ValidationError:
pass
cache_start_datetime = end_slot
return count,
def add_business_days(days, from_datetime=datetime.now()):
"""Increment the passed from_date by the passed number of business days
(excluding weekends and holidays)"""
try:
from_datetime.date()
except AttributeError:
from_datetime = datetime.combine(from_datetime, datetime.min.time())
tx_holidays = holidays.US(state='TX')
while days > 0:
from_datetime += timedelta(days=1)
if from_datetime.weekday() >= 5 or from_datetime.date() in tx_holidays:
continue
days -= 1
return from_datetime
def calculate_price(self):
dog_feeding_time_object = DogFeedingTime.objects.filter(dog=self.dog)
service_delta = (localtime(self.service_end_time).date() -
localtime(self.service_start_time).date())
meal_weight = self.service_meal_weight
meal_price_per_gram = self.service_meal_type.meal_price_per_gram
all_date_within_interval = [
localtime(self.service_start_time).date() + timedelta(days=i)
for i in range(service_delta.days + 1)
]
meal_per_service = 0
for date in all_date_within_interval:
for feedingtime in dog_feeding_time_object:
date_feeding = datetime.combine(date, feedingtime.time)
if (localtime(self.service_start_time) <
make_aware(date_feeding) < localtime(
self.service_end_time)):
meal_per_service += 1
total_meal_price = meal_per_service * meal_price_per_gram * meal_weight / 100
days_for_deposit = len(all_date_within_interval)
total_price = (self.additional_service.deposit_price *
days_for_deposit) + total_meal_price
host_service_price = [
self.additional_service.price_dog_walk,
self.additional_service.price_get_dog,
self.additional_service.price_deliver_dog,
self.additional_service.price_bath_dog,
]
enable_service = [
self.is_dog_walk,
self.is_get_dog,
self.is_delivery_dog,
self.is_bath_dog,
]
print("enable_service")
print(enable_service)
for i in range(len(enable_service)):
if enable_service[i]:
total_price += host_service_price[i]
return total_price
def get_context_data(self, **kwargs):
context = super(ConsolaAgenteView, self).get_context_data(**kwargs)
campanas_preview_activas = []
usuario_agente = self.request.user
agente_profile = usuario_agente.get_agente_profile()
kamailio_service = KamailioService()
sip_usuario = kamailio_service.generar_sip_user(
agente_profile.sip_extension)
sip_password = kamailio_service.generar_sip_password(sip_usuario)
video_domain = ''
if 'WEBPHONE_VIDEO_DOMAIN' in settings.CONSTANCE_CONFIG:
video_domain = config_constance.WEBPHONE_VIDEO_DOMAIN
fechas_agendas = AgendaContacto.objects.proximas(
agente_profile).values_list('fecha', 'hora')
fechas_agendas = [
make_aware(datetime.combine(x[0], x[1])).isoformat()
for x in fechas_agendas
]
hoy = fecha_local(now())
registros = LlamadaLog.objects.obtener_llamadas_finalizadas_del_dia(
agente_profile.id, hoy)
campanas_preview_activas = \
agente_profile.has_campanas_preview_activas_miembro()
context['pausas'] = Pausa.objects.activas
context['registros'] = registros
context['tipos_salientes'] = LlamadaLog.TIPOS_LLAMADAS_SALIENTES
context['campanas_preview_activas'] = campanas_preview_activas
context['agente_profile'] = agente_profile
context['sip_usuario'] = sip_usuario
context['sip_password'] = sip_password
context['agentes'] = AgenteProfile.objects.obtener_activos().exclude(
id=agente_profile.id)
context['max_session_age'] = settings.SESSION_COOKIE_AGE
context['video_domain'] = video_domain
context['fechas_agendas_json'] = json.dumps(fechas_agendas)
context['listas_rapidas'] = ContactoListaRapida.objects.all()
return context
def manual_attendance(request):
if request.method == 'GET':
users = Device_user.objects.all()
context = {
'users': users
}
return redirect(request, 'manual-attendance', context)
if request.POST:
manual_entry = ApprovalTable()
entry_date = datetime.strptime(request.POST.get("date"), '%Y/%m/%d').date()
print(entry_date)
entry_time = datetime.strptime(request.POST.get("time"), '%H:%M:%S').time()
combined = datetime.combine(entry_date, entry_time)
combined = make_aware(combined)
manual_entry.datetime = combined
manual_entry.user_id = Device_user.objects.get(user_id=int(request.POST.get('user_id')))
manual_entry.reason = request.POST.get('reason')
manual_entry.save()
return redirect('/')
def set_aware_appointment_datetime_utc(self, user_timezone):
nieve_dt = datetime.combine(self.appointment_date, self.appointment_time)
appointment_datetime_utc = make_aware(nieve_dt, timezone=pytz.timezone(user_timezone))
self.appointment_datetime_utc = appointment_datetime_utc
def to_datetime(self):
return datetime.combine(self.chrono_date.date, self.chrono_time.time)
def delete(self, request, *args, **kwargs):
instance = self.get_object()
if instance.client != self.request.user and \
(instance.professional != self.request.user and instance.status != PENDING):
return Response(status=status.HTTP_403_FORBIDDEN)
if self.request.user.profile.type == PROFESSIONAL:
if instance.status == PENDING:
new_status = PENDING
else:
new_status = REJECT
else:
new_status = CANCEL
services_datetime = datetime.combine(
instance.date, instance.time).replace(tzinfo=None)
if instance.status == ACCEPT and new_status == REJECT:
if services_datetime < now().replace(tzinfo=None):
return Response(
{
'error':
_('Services can\'t be cancel. Service date has passed.'
)
},
status=status.HTTP_400_BAD_REQUEST)
else:
instance.status = new_status
elif instance.status == ACCEPT and new_status == CANCEL:
cancel_amount = instance.calc_cancelability_cost()
if cancel_amount > 0:
try:
services = instance.services.all()
services_message = ''
for service in services:
services_message += str(service.name) + ', '
description = _(
'Service cancel. Order id: %(id)s. Services: %(services)s'
) % {
'id': instance.id,
'services': services_message
}
instance.charge(amount=cancel_amount,
description=description)
except Exception as e:
return Response({'non_field_errors': str(e)},
status=status.HTTP_400_BAD_REQUEST)
instance.status = new_status
elif instance.status in [COMPLETE, REJECT, CANCEL]:
return Response(
{
'error':
_('Services can\'t be cancel. Service status is %(status)s.'
) % {
'status': instance.status
}
},
status=status.HTTP_400_BAD_REQUEST)
else: # status == PENDING
if self.request.user.profile.type == PROFESSIONAL:
HireServiceRefuse.objects.create(user=self.request.user,
service=instance)
instance.status = new_status
instance.save()
return Response(status=status.HTTP_204_NO_CONTENT)