def registration(req, pk=None): contact = None if pk is not None: contact = get_object_or_404( Contact, pk=pk) if req.method == "POST": if req.POST["submit"] == "Delete Contact": contact.delete() return HttpResponseRedirect( reverse(registration)) else: form = ContactForm( instance=contact, data=req.POST) if form.is_valid(): contact = form.save() return HttpResponseRedirect( reverse(registration)) else: form = ContactForm( instance=contact) return render_to_response(req, "registration/dashboard.html", { "contacts_table": ContactTable(Contact.objects.all(), request=req), "contact_form": form, "contact": contact })
def message_tester(req, identity): if req.method == "POST": form = forms.MessageForm(req.POST) if form.is_valid(): cd = form.cleaned_data utils.send_test_message(**cd) return _redirect(cd["identity"]) else: form = forms.MessageForm({ "identity": identity }) # attempt to fetch the message log from the router, but don't expode # if it's not available. (the router probably just isn't running.) try: router_available = True message_log = utils.get_message_log() except RouterNotResponding: router_available = False message_log = None return render_to_response( req, "httptester/index.html", { "router_available": router_available, "message_log": message_log, "message_form": form, })
def mwana_alerts(request): transport_time = get_from_request(request, "input_transport_time") retrieving_time = get_from_request(request, "input_retrieving_time") notifying_time = get_from_request(request, "input_notifying_time") lab_processing_days = get_from_request(request, "input_lab_processing_days") lab_sending_days = get_from_request(request, "input_lab_sending_days") alerter = Alerter() transport_time, not_sending_dbs_alerts = alerter.get_districts_not_sending_dbs_alerts(transport_time) retrieving_time, not_retrieving_results = alerter.get_clinics_not_retriving_results_alerts(retrieving_time) notifying_time, not_notifying_or_using_results = alerter.get_clinics_not_sending_dbs_alerts(notifying_time) lab_processing_days, not_processing_dbs = alerter.get_labs_not_processing_dbs_alerts(lab_processing_days) lab_sending_days, not_sending_dbs = alerter.get_labs_not_sending_payloads_alerts(lab_sending_days) return render_to_response( request, "alerts/alerts.html", { "not_sending_dbs_alerts": not_sending_dbs_alerts, "transport_time": transport_time, "not_retrieving_results": not_retrieving_results, "retrieving_time": retrieving_time, "not_notifying_or_using_results": not_notifying_or_using_results, "notifying_time": notifying_time, "not_processing_dbs": not_processing_dbs, "lab_processing_days": lab_processing_days, "not_sending_dbs": not_sending_dbs, "lab_sending_days": lab_sending_days, "days": range(1, 60), }, )
def request_details(request, request_pk): """Supply request details view""" sreq = get_object_or_404(SupplyRequest, id=request_pk) if request.method == "POST": original_status = sreq.status form = SupplyRequestForm(request.POST, instance=sreq) if form.is_valid(): sreq = form.save(commit=False) sreq.modified = datetime.utcnow() sreq.save() if sreq.status != original_status and \ sreq.requested_by and \ sreq.requested_by.default_connection: # if the status has changed, let's send a message # to the original requester so they know things are # proceeding. text = ("Your request for more %(supply)s at %(loc)s has been updated! " +\ "The new status is: %(status)s.") % \ {"supply": sreq.type.name, "loc": sreq.location.name, "status": sreq.get_status_display().upper()} send_message(sreq.requested_by.default_connection, text) return web_message(request, "Supply request %d status set to %s" % \ (sreq.pk, sreq.get_status_display()), link=reverse("supply_dashboard")) elif request.method == "GET": form = SupplyRequestForm(instance=sreq) return render_to_response(request, "supply/single_request.html", {"sreq": sreq, "form": form})
def view_location(req, location_code, location_type_slug): location = get_object_or_404(Location, slug=location_code) loc_type = get_object_or_404(LocationType, exists_in=location) locations = loc_type.location_set.all().order_by("slug") return render_to_response(req, "locations/dashboard.html", { "locations": locations })
def message_log(req): message_table = MessagelogTable(request=req) message_table.paginate(QuerySetPaginator, MESSAGES_PER_PAGE, page=req.GET.get('page', 1)) return render_to_response(req, "messagelog/index.html", { "messages": message_table, })
def dashboard(request): """Supply dashboard""" active_requests = SupplyRequest.active().order_by("-created").order_by("location") locations = set((req.location for req in active_requests)) for location in locations: location.active_requests = active_requests.filter(location=location) return render_to_response(request, "supply/dashboard.html", {"active_requests": active_requests, "locations": locations })
def location_details(request, location_pk): """Supply location details view""" loc = get_object_or_404(Location.objects.select_related(depth=3), pk=location_pk) # this is sneaky, but allows us to access this list from # template tags without doing extra querying. loc.active_requests = SupplyRequest.active().filter(location=loc) return render_to_response(request, "supply/single_location.html", {"location": loc})
def location_details(request, location_pk): """Supply location details view""" loc = get_object_or_404(Location.objects.select_related(depth=3), pk=location_pk) # this is sneaky, but allows us to access this list from # template tags without doing extra querying. loc.active_requests = SupplyRequest.active().filter(location=loc) return render_to_response(request, "supply/single_location.html", {"location": loc} )
def patient_update (request, patid): patient = get_object_or_404(Registration, patient_id=patid) form = PatientForm(instance=patient) sent = SentNotif.objects.filter(patient_id=patient) patient.notifications = ', '.join(str(d) for d in sorted([s.day for s in sent])) if len(sent) > 0 else 'none sent yet' annotate_patient(patient) return render_to_response(request, 'circumcision/patient.html', {'px': patient, 'pat_form': form})
def dashboard(request): """Supply dashboard""" active_requests = SupplyRequest.active().order_by("-created").order_by( "location") locations = set((req.location for req in active_requests)) for location in locations: location.active_requests = active_requests.filter(location=location) return render_to_response(request, "supply/dashboard.html", { "active_requests": active_requests, "locations": locations })
def locations(req, location_uid=None): view_location = None if location_uid is not None: view_location = Location.get_for_uid( location_uid) if req.method == "POST": model_class = utils.get_model(req.POST["type"]) form_class = utils.form_for_model(model_class) model = None if req.POST.get("id", None): model = get_object_or_404( model_class, pk=req.POST["id"]) if req.POST["submit"] == "Delete": model.delete() return HttpResponseRedirect( reverse(view_location)) form = form_class(instance=model, data=req.POST) if form.is_valid(): model = form.save() if req.POST.get("parent_type", None) and req.POST.get("parent_id", None): parent_class = utils.get_model(req.POST["parent_type"]) parent = get_object_or_404(parent_class, pk=req.POST["parent_id"]) model.parent = parent model.save() return HttpResponseRedirect( reverse(locations, args=(model.uid,))) types = [ LocationTypeStub(type, req, view_location) for type in Location.subclasses()] return render_to_response(req, "locations/dashboard.html", { "breadcrumbs": _breadcrumbs(view_location), "location": view_location, "location_types": types, # from rapidsms.contrib.locations.settings "default_latitude": settings.MAP_DEFAULT_LATITUDE, "default_longitude": settings.MAP_DEFAULT_LONGITUDE, # if there are no locationtypes, then we should display a # big error, since this app is useless without them. "no_location_types": (len(types) == 0) } )
def registration(req, pk=None): contact = None if pk is not None: contact = get_object_or_404( Contact, pk=pk) if req.method == "POST": if req.POST["submit"] == "Delete Contact": contact.delete() return HttpResponseRedirect( reverse(registration)) else: form = ContactForm( instance=contact, data=req.POST) if form.is_valid(): contact = form.save() return HttpResponseRedirect( reverse(registration)) else: form = ContactForm( instance=contact) class ContactRow(ModelRow): # add an 'url' attribute; a link to the edit page, with the same # GET parameters as the current view. this lets us persist the # pagination params (page=, per-page=), maintaining the current # state of the contacts list (on the left). def url(self): u = reverse(registration, args=[self.data.pk]) if req.GET: u += "?%s" % req.GET.urlencode() return u # add an 'is_active' attr, to highlight the row that we're # currently editing (if any) in the form to the right. def is_active(self): return self.data == contact return render_to_response(req, "registration/dashboard.html", { "contacts": ContactTable(request=req, row_class=ContactRow), "contact_form": form, "contact": contact })
def edit(request, pk, template="scheduler/edit.html"): context = {} schedule = get_object_or_404(EventSchedule, id=pk) if request.method == 'POST': form = ScheduleForm(request.POST, instance=schedule) if form.is_valid(): form.save() context['status'] = _("Schedule '%(name)s' successfully updated" % \ {'name':schedule.callback} ) else: context['errors'] = form.errors else: form = ScheduleForm(instance=schedule) context['form'] = form context['schedule'] = schedule return render_to_response(request, template, context)
def patient_list (request): #handle submission for updating a patient (from /patient/xxx/) patient_id = None if request.method == 'POST' and 'patient_id' in request.POST: patient_id = request.POST['patient_id'] save_msg = None if patient_id != None: form = PatientForm(request.POST, instance=Registration.objects.get(patient_id=patient_id)) if form.is_valid(): form.save() save_msg = 'Successfully updated patient %s' % patient_id else: save_msg = 'Unable to update patient %s! %s' % (patient_id, form.errors) regs = load_patients() return render_to_response(request, 'circumcision/overview.html', {'days': config.notification_days, 'patients': paginated(request, regs), 'save_msg': save_msg, 'qt': util.reg_totals(regs)})
def view_location_type(req, location_type_slug): # look up the location type by the slug # (maybe not as concise as the loc_type = get_object_or_404( LocationType, slug=location_type_slug) # prefetch all locations in this loc_type, # since we're going to plot them ALL on the # google map whether or not they're visible all_locations = list(loc_type.locations.all().order_by("code")) return render_to_response(req, "locations/view_location_type.html", { "active_location_type_tab": loc_type.pk, "locations": paginated(req, all_locations, prefix="loc", wrapper=with_related_objects), "relations": related_objects(Location), "all_locations": all_locations, "location_type": loc_type })
def edit_location(req, location_type_slug, location_pk): loc_type = get_object_or_404(LocationType, slug=location_type_slug) location = get_object_or_404(Location, pk=location_pk) if req.method == "GET": return render_to_response(req, "locations/location_form.html", { "active_location_type_tab": loc_type.pk, "location": location, # redirect back to this view to save (below) "save_url": reverse("edit_location", kwargs={ "location_type_slug": location_type_slug, "location_pk": location_pk }), # is the map visible? default to 0 (hidden) # since the map makes everything very slow "show_map": int(req.GET.get("map", 0)) }) elif req.method == "POST": # if DELETE was clicked... delete # the object, then and redirect if req.POST.get("delete", ""): pk = location.pk location.delete() return web_message(req, "Location %d deleted" % (pk), link=reverse("locations_dashboard")) # otherwise, just update the object # and display the success message else: location = update_via_querydict(location, req.POST) location.save() return web_message(req, "Location %d saved" % (location.pk), link=reverse("locations_dashboard"))
def dashboard(req, location_pk=None): # to avoid the breadcrumb trail being empty browsing the entire # world, hard-code the first item. TODO: configure via settings. breadcrumbs = [("Planet Earth", reverse(dashboard))] # if a location was given, we will display its sub-locations via its # sub-locationtypes. if location_pk is not None: location = get_object_or_404(Location, pk=location_pk) location_form = LocationForm(instance=location) # add each ancestor to the breadcrumbs. for loc in location.path: url = reverse(dashboard, args=(loc.pk,)) breadcrumbs.append((loc.name, url)) # no location is fine; we're browing the entire world. the top-level # location types will be returned by filter(exists_in=None). else: location = None location_form = None # build a list of [sub-]locationtypes with their locations, to avoid # having to invoke the ORM from the template (which is foul). locations_data = [ (x, Location.objects.filter(type=x)) for x in LocationType.objects.filter(exists_in=location) ] return render_to_response(req, "locations/dashboard.html", { "breadcrumbs": breadcrumbs, "locations_data": locations_data, "location_form": location_form, "location": location } )
def add_location(req, location_type_slug): loc_type = get_object_or_404(LocationType, slug=location_type_slug) if req.method == "GET": return render_to_response(req, "locations/location_form.html", { "active_location_type_tab": loc_type.pk, # redirect back to this view to save (below) "save_url": reverse("add_location", kwargs={ "location_type_slug": location_type_slug}), # is the map visible? default to 1 (visible), # since i almost always want to set the location "show_map": int(req.GET.get("map", 1)) }) elif req.method == "POST": location = insert_via_querydict(Location, req.POST, { "type": loc_type }) location.save() return web_message(req, "Location %d saved" % (location.pk), link=reverse("locations_dashboard"))
def request_details(request, request_pk): """Supply request details view""" sreq = get_object_or_404(SupplyRequest, id=request_pk) if request.method == "POST": original_status = sreq.status form = SupplyRequestForm(request.POST, instance=sreq) if form.is_valid(): sreq = form.save(commit=False) sreq.modified = datetime.utcnow() sreq.save() if sreq.status != original_status and \ sreq.requested_by and \ sreq.requested_by.default_connection: # if the status has changed, let's send a message # to the original requester so they know things are # proceeding. text = ("Your request for more %(supply)s at %(loc)s has been updated! " +\ "The new status is: %(status)s.") % \ {"supply": sreq.type.name, "loc": sreq.location.name, "status": sreq.get_status_display().upper()} send_message(sreq.requested_by.default_connection, text) return web_message(request, "Supply request %d status set to %s" % \ (sreq.pk, sreq.get_status_display()), link=reverse("supply_dashboard")) elif request.method == "GET": form = SupplyRequestForm(instance=sreq) return render_to_response(request, "supply/single_request.html", { "sreq": sreq, "form": form })
def mwana_alerts(request): transport_time = get_from_request(request, 'input_transport_time') retrieving_time = get_from_request(request, 'input_retrieving_time') notifying_time = get_from_request(request, 'input_notifying_time') lab_processing_days = get_from_request(request, 'input_lab_processing_days') lab_sending_days = get_from_request(request, 'input_lab_sending_days') alerter = Alerter() transport_time, not_sending_dbs_alerts = \ alerter.get_districts_not_sending_dbs_alerts(transport_time) retrieving_time, not_retrieving_results = \ alerter.get_clinics_not_retriving_results_alerts(retrieving_time) notifying_time, not_notifying_or_using_results = \ alerter.get_clinics_not_sending_dbs_alerts(notifying_time) lab_processing_days, not_processing_dbs = \ alerter.get_labs_not_processing_dbs_alerts(lab_processing_days) lab_sending_days, not_sending_dbs = \ alerter.get_labs_not_sending_payloads_alerts(lab_sending_days) return render_to_response( request, 'alerts/alerts.html', { 'not_sending_dbs_alerts': not_sending_dbs_alerts, 'transport_time': transport_time, 'not_retrieving_results': not_retrieving_results, 'retrieving_time': retrieving_time, 'not_notifying_or_using_results': not_notifying_or_using_results, 'notifying_time': notifying_time, 'not_processing_dbs': not_processing_dbs, 'lab_processing_days': lab_processing_days, 'not_sending_dbs': not_sending_dbs, 'lab_sending_days': lab_sending_days, 'days': range(1, 60), })
def dashboard(request): locations = Location.objects.all() return render_to_response(request, "labresults/dashboard.html", {"locations": locations })
def mwana_reports (request): # , startdate=datetime.today().date()-timedelta(days=30), # enddate=datetime.today().date( from mwana.apps.reports.webreports.reportcreator import Results160Reports today = datetime.today().date() try: startdate1 = text_date(request.REQUEST['startdate']) except (KeyError, ValueError, IndexError): startdate1 = today -timedelta(days=30) try: enddate1 = text_date(request.REQUEST['enddate']) except (KeyError, ValueError, IndexError): enddate1 = datetime.today().date() startdate = min(startdate1, enddate1, datetime.today().date()) enddate = min(max(enddate1, startdate1), datetime.today().date()) r = Results160Reports() res = r.dbs_sent_results_report(startdate, enddate) min_processing_time, max_processing_time, num_of_dbs_processed, \ num_facs_processing, processing_time =\ r.dbs_avg_processing_time_report(startdate, enddate) min_entering_time, max_entering_time, num_of_rsts_entered, \ num_facs_entering, entering_time =\ r.dbs_avg_entering_time_report(startdate, enddate) min_retrieval_time, max_retrieval_time, num_of_dbs_retrieved, \ num_facs_retrieving, retrieval_time =\ r.dbs_avg_retrieval_time_report(startdate, enddate) min_turnaround_time, max_turnaround_time, num_of_rsts, num_of_facilities,\ turnaround_time = r.dbs_avg_turnaround_time_report(startdate, enddate) min_transport_time, max_transport_time, num_of_dbs, num_of_facs,\ transport_time = r.dbs_avg_transport_time_report(startdate, enddate) samples_reported = r.dbs_sample_notifications_report(startdate, enddate) samples_at_lab = r.dbs_samples_at_lab_report(startdate, enddate) pending = r.dbs_pending_results_report(startdate, enddate) payloads = r.dbs_payloads_report(startdate, enddate) births = r.reminders_patient_events_report(startdate, enddate) single_bar_length, tt_in_graph, graph = r.dbs_graph_data(startdate, enddate) percent_positive_country, percent_negative_country, percent_rejected_country\ , percent_positive_provinces, percent_negative_provinces\ , percent_rejected_provinces, total_dbs, months_reporting,\ days_reporting, year_reporting =r.dbs_positivity_data() return render_to_response(request, 'labresults/reports.html', {'startdate':startdate, 'enddate':enddate, 'today':today, 'sent_results_rpt':res, 'turnaround_time_rpt':turnaround_time, 'min_turnaround_time':min_turnaround_time, 'max_turnaround_time':max_turnaround_time, 'num_of_results':num_of_rsts, 'num_of_facilities':num_of_facilities, 'processing_time_rpt':processing_time, 'min_processing_time':min_processing_time, 'max_processing_time':max_processing_time, 'num_of_dbs_processed':num_of_dbs_processed, 'num_facs_processing':num_facs_processing, 'retrieval_time_rpt':retrieval_time, 'min_retrieving_time':min_retrieval_time, 'max_retrieving_time':max_retrieval_time, 'num_of_dbs_retrieved':num_of_dbs_retrieved, 'num_facs_retrieving':num_facs_retrieving, 'entering_time_rpt':entering_time, 'min_entering_time':min_entering_time, 'max_entering_time':max_entering_time, 'num_of_rsts_entered':num_of_rsts_entered, 'num_facs_entering':num_facs_entering, 'transport_time_rpt':transport_time, 'min_transport_time':min_transport_time, 'max_transport_time':max_transport_time, 'num_of_dbs':num_of_dbs, 'num_of_facs':num_of_facs, 'samples_reported_rpt':samples_reported, 'samples_at_lab_rpt':samples_at_lab, 'pending_results':pending, 'payloads_rpt':payloads, 'births_rpt':births, 'formattedtoday':today.strftime("%d %b %Y"), 'formattedtime':datetime.today().strftime("%I:%M %p"), 'graph':graph, 'single_bar_length':single_bar_length, 'tt_in_graph':tt_in_graph, 'percent_positive_country':percent_positive_country, 'percent_negative_country':percent_negative_country, 'percent_rejected_country':percent_rejected_country, 'percent_positive_provinces':percent_positive_provinces, 'percent_negative_provinces':percent_negative_provinces, 'percent_rejected_provinces':percent_rejected_provinces, 'total_dbs':total_dbs, 'months_reporting':months_reporting, 'days_reporting':days_reporting, 'year_reporting':year_reporting, })
def log_viewer (request, daysback='7', source_filter=''): try: daysback = int(daysback) except ValueError: #todo: return error - parameter is not an int pass if daysback <= 0 or daysback >= 10000: #todo: return error - parameter out of range pass #get log records to display - any log entry in a payload that was received in the past N days cutoff_date = (datetime.now() - timedelta(days=daysback)) payloads = labresults.Payload.objects.filter(incoming_date__gte=cutoff_date) logs = labresults.LabLog.objects.filter(payload__in=payloads) #extract displayable info from log records, remove duplicate (re-sent) entries log_info = {} meta_logs = [] #meta logs are log messages related to logging itself; they have no line numbers or timestamps for log_record in logs: if log_record.message == None: #skip log entries that weren't parseable continue if not log_record.payload.source.startswith(source_filter): continue log_entry = { 'line': log_record.line, 'timestamp': log_record.timestamp, 'level': log_record.level, 'message': log_record.message, 'received_on': log_record.payload.incoming_date, 'received_from': log_record.payload.source, 'version': log_record.payload.version, } log_uid = (log_entry['line'], log_entry['timestamp']) if log_entry['line'] == -1: meta_logs.append(log_entry) elif log_uid in log_info: if log_entry['received_on'] < log_info[log_uid]['received_on']: #save the earliest 'received on' date for re-sent entries log_info[log_uid] = log_entry else: log_info[log_uid] = log_entry log_entries = log_info.values() log_entries.extend(meta_logs) #sort records into chronological order (best-faith effort) lines = set(lg['line'] for lg in log_entries) #if log entry buffer contains both high- and low-numbered lines, log file rotation may have occurred recently wraparound = len(lines | set(range(0, 500))) > 0 and (max(lines) if lines else 0) >= log_rotation_threshold #if multiple log messages have the same line #, could suggest the log file was recently erased collisions = any(len([lg for lg in log_entries if lg['line'] == ln]) > 1 for ln in lines if ln != -1) log_entries.sort(cmp=lambda x, y: log_cmp(x, y, wraparound)) #format information for display log_display_items = [] for le in log_entries: ldi = { 'type': 'log', 'line': le['line'], 'timestamp': '%s.%03d' % (le['timestamp'].strftime('%Y-%m-%d %H:%M:%S'), le['timestamp'].microsecond / 1000), 'level': level_abbr(le['level']), 'message': le['message'], 'received_on': le['received_on'], 'received_from': recvd_from(le['received_from'], le['version']) } if ldi['line'] == -1: ldi['type'] = 'meta-log' elif len(log_display_items) > 0: prev_line = log_display_items[-1]['line'] if prev_line != -1: expected_next_line = prev_line + len(log_display_items[-1]['message'].split('\n')) cur_line = le['line'] if cur_line > expected_next_line: log_display_items.append({'type': 'alert', 'message': 'missing log entries (%d lines)' % (cur_line - expected_next_line)}) elif cur_line < expected_next_line: log_display_items.append({'type': 'alert', 'message': 'logfile rotation (?)'}) log_display_items.append(ldi) return render_to_response(request, 'labresults/logview.html', {'display_info': log_display_items, 'collisions': collisions, 'days': daysback, 'source': source_filter})
def messaging(req): return render_to_response(req, "messaging/dashboard.html", { "people": paginated(req, Contact.objects.all()), "filters": filters.fetch() })
def log_viewer(request, daysback='7', source_filter=''): try: daysback = int(daysback) except ValueError: #todo: return error - parameter is not an int pass if daysback <= 0 or daysback >= 10000: #todo: return error - parameter out of range pass #get log records to display - any log entry in a payload that was received in the past N days cutoff_date = (datetime.now() - timedelta(days=daysback)) payloads = labresults.Payload.objects.filter( incoming_date__gte=cutoff_date) logs = labresults.LabLog.objects.filter(payload__in=payloads) #extract displayable info from log records, remove duplicate (re-sent) entries log_info = {} meta_logs = [ ] #meta logs are log messages related to logging itself; they have no line numbers or timestamps for log_record in logs: if log_record.message == None: #skip log entries that weren't parseable continue if not log_record.payload.source.startswith(source_filter): continue log_entry = { 'line': log_record.line, 'timestamp': log_record.timestamp, 'level': log_record.level, 'message': log_record.message, 'received_on': log_record.payload.incoming_date, 'received_from': log_record.payload.source, 'version': log_record.payload.version, } log_uid = (log_entry['line'], log_entry['timestamp']) if log_entry['line'] == -1: meta_logs.append(log_entry) elif log_uid in log_info: if log_entry['received_on'] < log_info[log_uid]['received_on']: #save the earliest 'received on' date for re-sent entries log_info[log_uid] = log_entry else: log_info[log_uid] = log_entry log_entries = log_info.values() log_entries.extend(meta_logs) #sort records into chronological order (best-faith effort) lines = set(lg['line'] for lg in log_entries) #if log entry buffer contains both high- and low-numbered lines, log file rotation may have occurred recently wraparound = len(lines | set(range(0, 500))) > 0 and ( max(lines) if lines else 0) >= log_rotation_threshold #if multiple log messages have the same line #, could suggest the log file was recently erased collisions = any( len([lg for lg in log_entries if lg['line'] == ln]) > 1 for ln in lines if ln != -1) log_entries.sort(cmp=lambda x, y: log_cmp(x, y, wraparound)) #format information for display log_display_items = [] for le in log_entries: ldi = { 'type': 'log', 'line': le['line'], 'timestamp': '%s.%03d' % (le['timestamp'].strftime('%Y-%m-%d %H:%M:%S'), le['timestamp'].microsecond / 1000), 'level': level_abbr(le['level']), 'message': le['message'], 'received_on': le['received_on'], 'received_from': recvd_from(le['received_from'], le['version']) } if ldi['line'] == -1: ldi['type'] = 'meta-log' elif len(log_display_items) > 0: prev_line = log_display_items[-1]['line'] if prev_line != -1: expected_next_line = prev_line + len( log_display_items[-1]['message'].split('\n')) cur_line = le['line'] if cur_line > expected_next_line: log_display_items.append({ 'type': 'alert', 'message': 'missing log entries (%d lines)' % (cur_line - expected_next_line) }) elif cur_line < expected_next_line: log_display_items.append({ 'type': 'alert', 'message': 'logfile rotation (?)' }) log_display_items.append(ldi) return render_to_response( request, 'labresults/logview.html', { 'display_info': log_display_items, 'collisions': collisions, 'days': daysback, 'source': source_filter })
def mwana_reports(request): # , startdate=datetime.today().date()-timedelta(days=30), # enddate=datetime.today().date( from mwana.apps.reports.webreports.reportcreator import Results160Reports today = datetime.today().date() try: startdate1 = text_date(request.REQUEST['startdate']) except (KeyError, ValueError, IndexError): startdate1 = today - timedelta(days=30) try: enddate1 = text_date(request.REQUEST['enddate']) except (KeyError, ValueError, IndexError): enddate1 = datetime.today().date() startdate = min(startdate1, enddate1, datetime.today().date()) enddate = min(max(enddate1, startdate1), datetime.today().date()) r = Results160Reports() res = r.dbs_sent_results_report(startdate, enddate) min_processing_time, max_processing_time, num_of_dbs_processed, \ num_facs_processing, processing_time =\ r.dbs_avg_processing_time_report(startdate, enddate) min_entering_time, max_entering_time, num_of_rsts_entered, \ num_facs_entering, entering_time =\ r.dbs_avg_entering_time_report(startdate, enddate) min_retrieval_time, max_retrieval_time, num_of_dbs_retrieved, \ num_facs_retrieving, retrieval_time =\ r.dbs_avg_retrieval_time_report(startdate, enddate) min_turnaround_time, max_turnaround_time, num_of_rsts, num_of_facilities,\ turnaround_time = r.dbs_avg_turnaround_time_report(startdate, enddate) min_transport_time, max_transport_time, num_of_dbs, num_of_facs,\ transport_time = r.dbs_avg_transport_time_report(startdate, enddate) samples_reported = r.dbs_sample_notifications_report(startdate, enddate) samples_at_lab = r.dbs_samples_at_lab_report(startdate, enddate) pending = r.dbs_pending_results_report(startdate, enddate) payloads = r.dbs_payloads_report(startdate, enddate) births = r.reminders_patient_events_report(startdate, enddate) single_bar_length, tt_in_graph, graph = r.dbs_graph_data( startdate, enddate) percent_positive_country, percent_negative_country, percent_rejected_country\ , percent_positive_provinces, percent_negative_provinces\ , percent_rejected_provinces, total_dbs, months_reporting,\ days_reporting, year_reporting =r.dbs_positivity_data() return render_to_response( request, 'labresults/reports.html', { 'startdate': startdate, 'enddate': enddate, 'today': today, 'sent_results_rpt': res, 'turnaround_time_rpt': turnaround_time, 'min_turnaround_time': min_turnaround_time, 'max_turnaround_time': max_turnaround_time, 'num_of_results': num_of_rsts, 'num_of_facilities': num_of_facilities, 'processing_time_rpt': processing_time, 'min_processing_time': min_processing_time, 'max_processing_time': max_processing_time, 'num_of_dbs_processed': num_of_dbs_processed, 'num_facs_processing': num_facs_processing, 'retrieval_time_rpt': retrieval_time, 'min_retrieving_time': min_retrieval_time, 'max_retrieving_time': max_retrieval_time, 'num_of_dbs_retrieved': num_of_dbs_retrieved, 'num_facs_retrieving': num_facs_retrieving, 'entering_time_rpt': entering_time, 'min_entering_time': min_entering_time, 'max_entering_time': max_entering_time, 'num_of_rsts_entered': num_of_rsts_entered, 'num_facs_entering': num_facs_entering, 'transport_time_rpt': transport_time, 'min_transport_time': min_transport_time, 'max_transport_time': max_transport_time, 'num_of_dbs': num_of_dbs, 'num_of_facs': num_of_facs, 'samples_reported_rpt': samples_reported, 'samples_at_lab_rpt': samples_at_lab, 'pending_results': pending, 'payloads_rpt': payloads, 'births_rpt': births, 'formattedtoday': today.strftime("%d %b %Y"), 'formattedtime': datetime.today().strftime("%I:%M %p"), 'graph': graph, 'single_bar_length': single_bar_length, 'tt_in_graph': tt_in_graph, 'percent_positive_country': percent_positive_country, 'percent_negative_country': percent_negative_country, 'percent_rejected_country': percent_rejected_country, 'percent_positive_provinces': percent_positive_provinces, 'percent_negative_provinces': percent_negative_provinces, 'percent_rejected_provinces': percent_rejected_provinces, 'total_dbs': total_dbs, 'months_reporting': months_reporting, 'days_reporting': days_reporting, 'year_reporting': year_reporting, })
def dashboard(request): locations = Location.objects.all() return render_to_response(request, "labresults/dashboard.html", {"locations": locations})
def dashboard(req): return render_to_response(req, "dashboard.html")
def index(request, template="scheduler/index.html"): context = {} schedules = EventSchedule.objects.all() context['schedules'] = paginated(request, schedules) return render_to_response(request, template, context)
def message_log(req): return render_to_response(req, "messagelog/index.html", { "messages_table": MessageTable(Message.objects.all(), request=req) })