def get(self, request):
result = json.loads(requests.get("https://datausa.io/api/covid19/old/state").text)
bed_list = result['beds']
icu_list = result['icu']
print(len(bed_list))
print(len(icu_list))
for i in bed_list:
state_id = State.objects.get(name=i['Geography']).id
Bed(
state_id =state_id,
beds_per_thousand=i['Total'],
is_deleted =False,
created_at =Now(),
updated_at =Now()
).save()
for a in icu_list:
state_id = State.objects.get(name=a['Geography']).id
Icu(
state_id =state_id,
total =a['Total'],
total_per_capita=a['TotalPC'],
is_deleted =False,
created_at =Now(),
updated_at =Now()
).save()
return JsonResponse({'result': "hospital_crawling_success", 'beds': bed_list, 'icu': icu_list}, status=200)
class Meta:
verbose_name = 'Notebook'
verbose_name_plural = 'Notebooks'
unique_together = (
'word',
'learn_in_language',
)
constraints = (
# Entry date should be older than memorization date.
models.CheckConstraint(
name='entry_date_vs_memorization_date_check',
check=Q(entry_date__lte=F('memorization_date')),
),
# Check learn_in_language field not equal to word language.
models.CheckConstraint(name='same_language_check',
check=Func(
F('word_id'),
F('learn_in_language_id'),
function='is_different_language',
output_field=models.BooleanField(),
)),
# Entry date and memorization date can't be in the future.
models.CheckConstraint(name='protect_future_check',
check=Q(
entry_date__lt=Now(),
memorization_date__lt=Now(),
)))
def __init__(self):
super().__init__()
self.pickorder_length = None
self.missions = Mission.objects.filter(
productmission__sku__product__ean__isnull=False,
online_picklist__isnull=True,
is_online=True,
not_matchable__isnull=True,
ignore_pickorder__isnull=True)
self.missions = self.missions.annotate(delta=Case(
When(purchased_date__gte=Now(), then=F('purchased_date') - Now()),
When(purchased_date__lt=Now(), then=Now() - F('purchased_date')),
output_field=DurationField())).order_by("delta")
self.missions = self.missions.exclude(
Q(
Q(online_transport_service__name__iexact="dhl")
| Q(ignore_pickorder=True))
| Q(delta__gte=timedelta(days=20)) | Q(not_matchable=True))
self.picklist_data = None
self.pickorder = None
self.missions_products = None
self.stocks = None
self.used_stocks = {}
self.missions_pick_rows = None
self.packing_stations = PackingStation.objects.filter(
pickorder__isnull=True)
self.packing_station_current_user = None
self.refill_order = None
self.pickorder = None
self.limit_result = None
self.online_prefixes = OnlinePositionPrefix.objects.all()
def get_unexpired_coupon(self, *, coupon_code, product_id):
"""
Returns an an unexpired coupon with the coupon code for that product. Otherwise raise B2BCoupon.DoesNotExist.
Args:
coupon_code (str): The coupon code for the B2BCoupon
product_id (int): The primary key for the Product
Returns:
B2BCoupon:
The coupon instance. If no coupon is found a B2BCoupon.DoesNotExist error is raised
"""
coupon = (self.filter(
Q(coupon_code=coupon_code),
Q(enabled=True),
Q(product_id=None) | Q(product_id=product_id),
).filter(
Q(activation_date__isnull=True)
| Q(activation_date__lt=Now())).filter(
Q(expiration_date__isnull=True)
| Q(expiration_date__gt=Now())).get())
if coupon and not coupon.reusable:
coupon_redemption = B2BCouponRedemption.objects.filter(
coupon=coupon,
order__status__in=(B2BOrder.FULFILLED, B2BOrder.REFUNDED))
if coupon_redemption.exists():
raise B2BCoupon.DoesNotExist
return coupon
def parse_candidate_resume(resume_parse_id: str):
"""
Parse resume document and returns entities found from resume
:param resume_parse_id: id of current resume parse
:return: JSON of entities found
"""
# Celery task for resume parsing
resume = ResumeParse.objects.get(pk=resume_parse_id)
document = ResumeParse.objects.get(pk=resume_parse_id).document
# Get parser and parse resume. Time duration of parsing document
resume.time_start = Now()
logger.info('Parsing resume for candidate_id: {}'.format(
resume.candidate_id))
results = bert_parser.parse_file(document.url)
logger.info('Parsing resume completed for candidate_id: {}'.format(
resume.candidate_id))
resume.time_end = Now()
# Delete resume from tmp/ folder
ResumeParse.objects.get(pk=resume_parse_id).document.delete(save=True)
resume.save()
# Return output
return results
def get(self, request):
driver = webdriver.Chrome('/Users/tomleets/Downloads/chromedriver')
driver.get('https://datausa.io/coronavirus')
time.sleep(6)
html = driver.page_source
soup = BeautifulSoup(html, 'html.parser')
row_list = soup.find('table', {'class': 'state-table'}).find_all('tr')
for item in row_list:
state_name = item.find('td', {'class': 'Geography'})
trend_graph = item.find('td', {'class': 'Trend'})
gap_graph = item.find('td', {'class': 'Curve'})
if state_name is not None:
state_id = State.objects.get(name=state_name.text).id
Graph(
state_id =state_id,
trend_graph=str(trend_graph.find('svg')) + "<div>" + trend_graph.text + "</div>",
gap_graph =str(gap_graph.find('svg')),
is_deleted =False,
created_at =Now(),
updated_at =Now()
).save()
return JsonResponse({'result': "element_crawling_success"}, status=200)
def __init__(self, user_pk, foia_pks):
super(ExportCsv,
self).__init__(user_pk,
''.join(str(pk) for pk in foia_pks[:100]))
self.foias = (FOIARequest.objects.filter(
pk__in=foia_pks).select_related(
'composer__user',
'agency__jurisdiction__parent',
).only(
'composer__user__username',
'title',
'status',
'slug',
'agency__jurisdiction__name',
'agency__jurisdiction__slug',
'agency__jurisdiction__id',
'agency__jurisdiction__parent__name',
'agency__jurisdiction__parent__id',
'agency__name',
'agency__id',
'date_followup',
'date_estimate',
'embargo',
'composer__requested_docs',
).annotate(
days_since_submitted=ExtractDay(
Cast(Now() - F('composer__datetime_submitted'),
DurationField())),
days_since_updated=ExtractDay(
Cast(Now() - F('datetime_updated'), DurationField())),
project_names=StringAgg('projects__title', ',', distinct=True),
tag_names=StringAgg('tags__name', ',', distinct=True),
))
def test_now(self):
ar1 = Article.objects.create(
title='How to Django',
text=lorem_ipsum,
written=timezone.now(),
)
ar2 = Article.objects.create(
title='How to Time Travel',
text=lorem_ipsum,
written=timezone.now(),
)
num_updated = Article.objects.filter(
id=ar1.id, published=None).update(published=Now())
self.assertEqual(num_updated, 1)
num_updated = Article.objects.filter(
id=ar1.id, published=None).update(published=Now())
self.assertEqual(num_updated, 0)
ar1.refresh_from_db()
self.assertIsInstance(ar1.published, datetime)
ar2.published = Now() + timedelta(days=2)
ar2.save()
ar2.refresh_from_db()
self.assertIsInstance(ar2.published, datetime)
self.assertQuerysetEqual(Article.objects.filter(published__lte=Now()),
['How to Django'], lambda a: a.title)
self.assertQuerysetEqual(Article.objects.filter(published__gt=Now()),
['How to Time Travel'], lambda a: a.title)
class CompanyChartsViewSet(GenericViewSet, ListModelMixin):
queryset = Company.objects.annotate(__session_average=Subquery(
Session.objects.filter(company=OuterRef("id")).annotate(
value=ExpressionWrapper(Avg("answered_questions__value") *
F("set__weight"),
output_field=DecimalField(
max_digits=3,
decimal_places=2,
))).values("value"))).annotate(
date=Case(
When(sessions__until__lte=Now(),
then=F("sessions__until")),
default=Now()),
data=ExpressionWrapper(
Sum("__session_average") *
F("sessions__theme__weight"),
output_field=DecimalField(
decimal_places=2,
max_digits=3))).values(
"data", "date")
serializer_class = CompanyChartSerializer
def filter_queryset(self, queryset):
return queryset.filter(id=self.request.user.member.company_id)
def calculate_procent(self, obj):
run_current = "user__cards__run"
expression = "user__cards__cards_user__card"
date = expression + "__date"
run = Q(user__cards__cards_user__card__change__run=0)
time_remained = expression + "__change__time"
run_remained = expression + "__change__run"
run_initial = expression + "__change__initial_run"
return obj.annotate(now_days=ExtractDay(Now()),
now_month=ExtractMonth(Now()),
now_year=ExtractYear(Now()),
days=ExtractDay(date),
month=ExtractMonth(date),
year=ExtractYear(date),
).annotate(
passed_days=ExpressionWrapper(F('now_days') - F('days') + 31 * (F('now_month') - F('month')) + 365 * (
F('now_year') - F('year')), output_field=FloatField()),
run_total=F(run_remained) - F(run_initial),
run_passed=F(run_current) - F(run_initial),
).annotate(
procent=Case(
When(Q(passed_days__gt=0) & run, then=ExpressionWrapper(F('passed_days') / F(time_remained) * 100,
output_field=FloatField())),
When(~Q(run_passed__lte=0), then=ExpressionWrapper(F('run_passed') / F('run_total') * 100,
output_field=FloatField())),
default=0.0,
),
)
def retrieve_valid_sessions(self):
"""
Returns a queryset containing Sessions that fit one of the following conditions:
* The submit_before is set and is still valid
* The submit_before is NOT set, the Session is in use and the started_at + duration is still valid
* The submit_before is NOT set and the Session is NOT in use
And all of these conditions must only contain Sessions that are not frozen. Frozen sessions cannot be edited!
"""
queryset = self.get_queryset()
return queryset.annotate(
# Calculate the submit before based on the started_at + duration
submit_before_based_on_duration=ExpressionWrapper(
F('started_at') + F('duration'), output_field=DateTimeField())
).filter(
(
# All sessions that have a submit_before that has not yet passed
(Q(submit_before__isnull=False) & Q(submit_before__gt=Now())) |
# All sessions that do not have a submit_before but where the created_at + duration has not yet passed
(Q(submit_before__isnull=True)
& Q(submit_before_based_on_duration__gt=Now())) |
# All sessions that have no submit_before and has not yet been answered
(Q(submit_before__isnull=True)
& Q(submit_before_based_on_duration__isnull=True))),
# Frozen session are not editable anymore
frozen=False,
).all()
def get_stale_tasks(self):
"""Get stale tasks"""
# pylint: disable=import-outside-toplevel
from muckrock.task.models import (
NewAgencyTask,
OrphanTask,
FlaggedTask,
PortalTask,
SnailMailTask,
)
stale_tasks = OrderedDict()
stale_tasks["Processing Requests"] = (FOIARequest.objects.filter(
status="submitted",
date_processing__lt=(
date.today() -
timedelta(5))).order_by("date_processing").annotate(
days_old=ExtractDay(Now() - F("date_processing"))))[:5]
task_types = [
(NewAgencyTask, 3),
(OrphanTask, 5),
(FlaggedTask, 5),
(PortalTask, 5),
(SnailMailTask, 5),
]
for task_type, days_old in task_types:
stale_tasks[task_type.type] = (task_type.objects.filter(
date_created__lt=(timezone.now() - timedelta(days_old)),
resolved=False,
).order_by("date_created").annotate(days_old=ExtractDay(
Cast(Now() - F("date_created"), DurationField())))[:5])
return stale_tasks
class SessionChartsViewSet(GenericViewSet, ListModelMixin):
queryset = Session.objects.annotate(
data=Avg("answered_questions__value") * F("set__weight"),
date=Case(When(until__lte=Now(), then=F("until")), default=Now()),
)
def filter_queryset(self, queryset):
return queryset.filter(id=self.request.user.member.company_id)
class TaskListView(apps.common.mixins.AdminRequiredMixin,
apps.common.mixins.JqPaginatedListView):
model = Task
ordering = '-date_start'
json_fields = [
'name', 'date_start', 'username', 'metadata', 'date_done', 'status',
'progress', 'time', 'date_work_start', 'work_time', 'worker',
'description'
]
db_time = Coalesce(
F('date_done') - F('date_start'),
Now() - F('date_start'))
db_work_time = Coalesce(
F('date_done') - F('date_work_start'),
Now() - F('date_work_start'),
F('date_start') - F('date_start'))
db_user = Coalesce(F('user__username'), F('main_task__user__username'))
template_name = 'task/task_list.html'
def get_queryset(self):
qs = Task.objects.main_tasks().order_by('-date_start')
qs = qs.annotate(time=self.db_time,
work_time=self.db_work_time,
username=self.db_user)
return qs
def get_json_data(self, **kwargs):
data = super().get_json_data()
for item in data['data']:
item['url'] = reverse('task:task-detail', args=[item['pk']])
item['purge_url'] = reverse('task:purge-task')
item['result_links'] = []
if item['metadata']:
if isinstance(item['metadata'], dict):
metadata = item['metadata']
item['description'] = metadata.get('description')
result_links = metadata.get('result_links', [])
for link_data in result_links:
link_data['link'] = reverse(link_data['link'])
item['result_links'] = result_links
return data
def get_context_data(self, **kwargs):
ctx = super().get_context_data(**kwargs)
ctx['projects'] = \
[(p.pk, p.name) for p in Project.objects.filter(type__code=DocumentType.GENERIC_TYPE_CODE)]
ctx['active_classifiers'] = TextUnitClassifier.objects.filter(
is_active=True).exists()
if DocumentProperty.objects.exists():
ctx['ls_document_properties'] = DocumentProperty.objects.order_by('key') \
.values_list('key', flat=True).distinct()
if TextUnitProperty.objects.exists():
ctx['ls_text_unit_properties'] = TextUnitProperty.objects.order_by('key') \
.values_list('key', flat=True).distinct()
return ctx
def peers(request):
r = {}
r['nets'] = []
r['params'] = {}
available_services = ['inet2', 'wix', 'homeix']
service_name = request.GET.get('service', None)
if service_name not in available_services:
raise Http404('Wrong service name: %s' % service_name)
our_service = Ourservice.objects.get(name=service_name)
root_net = Net.objects.get(pk=our_service.root_net)
nets = Net.objects.filter(ipaddress_from__gte=root_net.ipaddress_from,
ipaddress_to__lte=root_net.ipaddress_to,
service__client__enabled=True,
service__start_time__lte=Now(),
service__name=service_name,
service__asn__isnull=False,
netmask=32,
status='+')
nets = nets.filter(
Q(service__status='on')
| Q(service__status='test', service__end_time__gte=Now()))
nets = nets.prefetch_related('service', 'service__asn', 'service__cities',
'service__client')
for net in nets:
community = None
if net.city is not None:
community = net.city.community
elif net.service.client.city is not None:
community = net.service.client.city.community
net_object = {
'service_name': net.service.name,
'service_type': net.service.servicetype,
'clientid': net.service.client.pk,
'address': net.address,
'ipv6_address': net.address6,
'mac': net.mac or '',
'peer-as': net.service.asn.asn,
'as-set': net.service.asn.asset or None,
'as-set6': net.service.asn.asset6 or None,
'netname': net.service.asn.engname or net.service.client.netname,
'community': community,
}
r['nets'].append(net_object)
r['params']['count'] = len(r['nets'])
return JsonResponse(r)
class AllOrganizations(OnlyForAdminsMixin, AMYListView):
context_object_name = 'all_organizations'
template_name = 'fiscal/all_organizations.html'
filter_class = OrganizationFilter
queryset = Organization.objects.prefetch_related(
Prefetch('membership_set',
to_attr='current_memberships',
queryset=Membership.objects.filter(
agreement_start__lte=Now(),
agreement_end__gte=Now(),
)))
title = 'All Organizations'
class AvailableSlotViewSet(mixins.ListModelMixin, viewsets.GenericViewSet):
queryset = TimeSlot.objects.prefetch_related(
Prefetch('appointment_set',
queryset=Appointment.objects.filter(
start_time__gte=Now()))).select_related(
'owner', 'owner__tutordata').prefetch_related(
'owner__tutordata__subjects').filter(
Q(weekly=True) | Q(start_time__gte=Now()),
owner__tutordata__verified=True)
serializer_class = AvailableSlotSerializer
permission_classes = [permissions.IsAuthenticated]
filter_backends = [DjangoFilterBackend]
filterset_class = filters.AvailableSlotFilter
pagination_class = LimitOffsetPagination
def get_queryset(self):
qs = self.queryset.all()
if self.request.user.studentdata and settings.NAKLAR_SCHEDULING_SCHOOLDATA:
qs = qs.filter(owner__tutordata__schooldata=self.request.user.
studentdata.school_data)
return qs
@action(['GET'],
detail=False,
serializer_class=SubjectSerializer,
filterset_class=None)
def subjects(self, request, *args, **kwargs):
qs = self.filter_queryset(self.get_queryset())
subjects = set()
for timeslot in qs:
if len(timeslot.available_slots()) > 0:
subjects = subjects.union(
timeslot.owner.tutordata.subjects.all())
serializer = SubjectSerializer(subjects, many=True)
return Response(serializer.data)
def list(self, request, *args, **kwargs):
queryset = self.filter_queryset(self.get_queryset())
slots = []
for timeslot in queryset:
slots.extend(
timeslot.
available_slots(earliest_start=timezone.now() + timedelta(
minutes=settings.NAKLAR_SCHEDULING_APPOINTMENT_DISTANCE)))
slots.sort(key=lambda x: x.start_time)
page = self.paginate_queryset(slots)
if page is not None:
serializer = self.get_serializer(page, many=True)
return self.get_paginated_response(serializer.data)
serializer = self.get_serializer(slots, many=True)
return Response(serializer.data)
def calculate_average(self, obj):
return obj.annotate(now_days=ExtractDay(Now()),
now_month=ExtractMonth(Now()),
now_year=ExtractYear(Now()),
days=ExtractDay('user__date'),
month=ExtractMonth('user__date'),
year=ExtractYear('user__date'),
).annotate(
calculate_days=F('now_days') - F('days') + 31 * (F('now_month') - F('month')) + 365 * (
F('now_year') - F('year')),
run_passed=ExpressionWrapper(F('user__cards__run') - F('user__cards__initial_run'),
output_field=FloatField())
).annotate(average_speed=ExpressionWrapper(F('run_passed') / F('calculate_days'),
output_field=FloatField()))
def get(self, request):
result = json.loads(requests.get("https://datausa.io/api/covid19/states").text)
filtered_list = list(
filter(
lambda item: ('2020/07/' in item['Date'] or '2020/08' in item['Date'])
and item['Geography'] != 'American Samoa', result['data']))
for i in filtered_list:
if State.objects.filter(name=i['Geography']).exists():
state_id = State.objects.get(name=i['Geography']).id
else:
state = State(
name =i['Geography'],
populations=i['Population'],
is_deleted =False,
created_at =Now(),
updated_at =Now()
)
state.save()
state_id = state.id
test = Test(
state_id =state_id,
count =i['Tests'],
is_deleted=False,
created_at=Now(),
updated_at=Now()
)
test.save()
test_result = TestResult(
test_id =test.id,
confirmed_growth =i['ConfirmedGrowth'],
confirmed =i['Confirmed'],
confirmed_per_capita=i['ConfirmedPC'],
positive_percent =i['PositivePct'],
is_deleted =False,
created_at =Now(),
updated_at =Now()
)
test_result.save()
hospital_status = HospitalStatus(
state_id =state_id,
hospitalized=i['Hospitalized'],
death =i['Deaths'],
is_deleted =False,
created_at =Now(),
updated_at =Now()
)
hospital_status.save()
return JsonResponse({'result': "daily_crawling_success", 'data': filtered_list}, status=200)
def get_model_instance(cls):
return Action(timestamp=Now(),
action_type=False,
session=SessionTest.model_create(),
participant=ParticipantTest.model_create(),
quantity=2,
event=EventTest.model_create())
def push_message(self, message):
LineMessageQueue(employee=self,
scheduled_at=Now(),
message=json.dumps({
'M': 't',
'text': message
})).save()
def with_timedelta(self):
"""
Adds a DurationField with distance between now and the start time (future or past).
Use with with_next_date() !
Returns:
QuerySet
"""
return self.annotate(timedelta=models.Case(
models.When(next_date__gte=Now(),
then=models.F("next_date") - Now()),
models.When(next_date__lt=Now(),
then=Now() - models.F("next_date")),
output_field=models.DurationField(),
))
def peer_cmd():
logger.info("Start")
addresses = get_nodes_list()
# explore every peer and collect updates
updates = {}
if settings.TEST_NET:
for address in addresses:
explore_node(address, updates)
else:
with ThreadPoolExecutor(max_workers=20) as executor:
executor.map(lambda address: explore_node(address, updates),
addresses)
updates_with_data = tuple(filter(lambda x: x is not None,
updates.values()))
# if more than __% peers were gone offline in __min, probably network problem
if len(updates_with_data) < get_count_nodes_online() * 0.9:
logger.warning("Peers update was rejected: %d - %d",
len(updates_with_data), len(addresses))
return
# set all peers unreachable, if will no update - peer will be unreachable
PeerMonitor.objects.update(state=PeerMonitor.State.UNREACHABLE)
# calculate state and apply updates
for update in updates_with_data:
logger.debug("Update: %r", update)
peer_obj = PeerMonitor.objects.filter(
announced_address=update["announced_address"]).first()
if not peer_obj:
logger.info("Found new peer: %s", update["announced_address"])
update["state"] = get_state(update, peer_obj)
form = PeerMonitorForm(update, instance=peer_obj)
if form.is_valid():
form.save()
else:
logger.info("Not valid data: %r - %r", form.errors, update)
PeerMonitor.objects.update(lifetime=F("lifetime") + 1)
PeerMonitor.objects.filter(
state__in=[PeerMonitor.State.UNREACHABLE, PeerMonitor.State.STUCK
]).update(downtime=F("downtime") + 1)
PeerMonitor.objects.annotate(duration=ExpressionWrapper(
Now() - F("last_online_at"), output_field=DurationField())).filter(
duration__gte=timedelta(days=30)).delete()
PeerMonitor.objects.update(
availability=100 - (F("downtime") / F("lifetime") * 100),
modified_at=timezone.now(),
)
logger.info("Done")
def mark_run(self):
"""
Update the last_run to Now, and save.
"""
self.last_run = Now()
self.save()
self.refresh_from_db()
def filter_for_api(self, academic_year):
from partnership.models import PartnershipYear, PartnershipAgreement
return self.annotate(
current_academic_year=models.Value(
academic_year.id, output_field=models.AutoField()),
).annotate(
has_years_in=models.Exists(
PartnershipYear.objects.filter(
partnership=OuterRef('partnership_id'),
academic_year=academic_year,
)),
has_valid_agreement_in_current_year=models.Exists(
PartnershipAgreement.objects.filter(
partnership=OuterRef('partnership_id'),
status=AgreementStatus.VALIDATED.name,
start_academic_year__year__lte=academic_year.year,
end_academic_year__year__gte=academic_year.year,
)),
).filter(
# If mobility, should have agreement for current year
# and have a partnership year for current year
Q(
partnership__partnership_type=PartnershipType.MOBILITY.name,
has_valid_agreement_in_current_year=True,
has_years_in=True,
)
# Else all other types do not need agreement
| (~Q(partnership__partnership_type=PartnershipType.MOBILITY.name)
& Q(partnership__end_date__gte=Now())),
# And must be public
partnership__is_public=True,
)
def create_table(request):
"""
Example JSON Request:
{ "dining_hall": "F",
"meal_period": "BR",
"creator_id": 3
}
"""
try:
payload = json.loads(request.body)
dining_hall = payload["dining_hall"]
datetime = Now() #change later
meal = payload["meal_period"]
creator = payload["creator_id"]
except Exception as e:
return JsonResponse({
'error':
'Invalid JSON request - required fields: dining_hall, datetime, meal, creator'
})
new_room = DiningTable.objects.create(dining_hall=dining_hall,
datetime=datetime,
users=[creator],
unread_msg_count={creator: None},
meal_period=meal,
creator_id=creator)
response = "Created new table at " + new_room.get_dining_hall_display(
) + " with ID " + str(new_room.id)
log.debug("[TABLES] " + response)
response_data = {"Success": response}
return JsonResponse(response_data)
def home(request):
orders = Order.objects.all()
customers = Customer.objects.all()
non_closed_orders = orders.filter(Q(status='Abierta') | Q(status='En revisión'))
duration = ExpressionWrapper(Now() - F('date_created'),
output_field=fields.DurationField())
non_closed_orders = non_closed_orders.annotate(duration=duration)
non_closed_orders = non_closed_orders.annotate(duration_days=Extract('duration', 'day'))
non_closed_orders = non_closed_orders.order_by("date_created")
if request.user.group == "taller":
taller_tag = TagOrder.objects.get(name="taller")
non_closed_orders = non_closed_orders.filter(order_tags=taller_tag)
taller_orders = orders.filter(order_tags=taller_tag)
opened = taller_orders.filter(status='Abierta').count()
on_revision = taller_orders.filter(status='En revisión').count()
closed = taller_orders.filter(status='Cerrada').count()
else:
opened = orders.filter(status='Abierta').count()
on_revision = orders.filter(status='En revisión').count()
closed = orders.filter(status='Cerrada').count()
context = {'orders': non_closed_orders, 'customers': customers,
'opened': opened, 'on_revision': on_revision,
'closed': closed, 'to_date': datetime.now()}
return render(request, 'accounts/dashboard.html', context)
def get(self, request):
user = request.user
plans = settings.PLAN_DEFINITIONS
try:
current_plan = Subscriptions.objects.get(
account=user.account, period__contains=Now()
).plan
except Subscriptions.DoesNotExist:
current_plan = None
try:
limit = plans[current_plan]["limit"]
except KeyError:
limit = 0
count = {"domestic": 0, "international": 0}
savings = {"domestic": 0, "international": 0}
# TODO: optimize db usage (aggregate on DB)
trips_booked = booking_models.BookingContact.objects.filter(user__account=user.account)
for f in trips_booked:
kind = "domestic" if f.is_domestic() else "international"
count[kind] += 1
savings[kind] += max(0, AVERAGE_PRICES[kind] - f.data["conversion"]["USD"])
data = {
"savings": savings,
"count": count,
"remaining": limit - sum(count.values()) if limit is not None else None
}
return Response(data)
def get_queryset(self):
queryset = super().get_queryset()
provider_id = getattr(self.request.user, "provider_id", None)
if provider_id:
# Filter for general-purpose policies,
# or the ones written for this provider
queryset = queryset.filter(
Q(providers__isnull=True) | Q(providers=provider_id)
)
# The raw results will expose what other providers this policy applies to
# Is this information leakage?
else:
# Only general-purpose policies to other users
queryset = queryset.filter(providers__isnull=True)
# Filter by date range
start_time = self.request.GET.get("start_time")
if start_time:
start_time = utils.from_mds_timestamp(int(start_time))
else:
start_time = Now()
range_q = Q(end_date__gt=start_time) | Q(end_date__isnull=True)
end_time = self.request.GET.get("end_time")
if end_time:
end_time = utils.from_mds_timestamp(int(end_time))
range_q &= Q(start_date__lte=end_time)
queryset = queryset.filter(range_q)
return queryset
def AjaxCreatePlanning(request):
if request.method == 'POST':
planning = Planning.objects.filter(lead=request.POST.get('id'),
active=False)
if (planning):
return HttpResponse('Finish plans')
elif (request.POST.get('date') == ''):
return HttpResponse('Set date')
else:
format = '%d/%m/%Y %H:%M'
start = datetime.strptime(request.POST.get('date'),
format).strftime('%Y-%m-%d %H:%M')
lead = Leads.objects.get(id=request.POST.get('id'))
Planning.objects.create(lead=lead,
manager=lead.manager.closer,
creator=request.user.username,
type=request.POST.get('type'),
update=start)
lastid = Leads.objects.latest().id
Leads.objects.filter(id=lastid).update(update=Now())
return HttpResponse('ok')
return HttpResponse('Bad request')
