Example #1
0
def delete_defaulter_cohort(request):
    if not Authorize.authorize(request.user,['superuser']) :
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    cohort_uuid = request.GET['cohort_uuid']
    DefaulterCohort.delete_defaulter_cohort(cohort_uuid)
    return HttpResponseRedirect('/ltfu/manage_defaulter_cohorts')
Example #2
0
def delete_report_table(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")
    if "report_table_id" in request.GET:
        rt = ReportTable.objects.get(id=request.GET["report_table_id"])
        rt.delete()
    return HttpResponseRedirect("/")
Example #3
0
def create_report_table(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    if request.method == "POST":
        name = get_var(request.POST, "name")
        report_table_sql = get_var(request.POST, "report_table_sql")
        description = get_var(request.POST, "description")
        report_table_id = get_var(request.POST, "report_table_id")
        if name and report_table_sql:
            if report_table_id:
                rt = ReportTable.objects.get(id=report_table_id)
                rt.name = name
                rt.description = description
                rt.report_table_sql = report_table_sql
                ReportTableParameter.objects.filter(report_table_id=rt.id).delete()
            else:
                rt = ReportTable(name=name, report_table_sql=report_table_sql, description=description)
            rt.save()
            count = report_table_sql.count("%s")
            rt.create_parameters(request.POST, count)

        return HttpResponseRedirect("/amrs_reports/manage_report_tables")
    else:
        report_table_id = get_var(request.GET, "report_table_id")
        rt = None
        parameters = []
        if report_table_id:
            rt = ReportTable.objects.get(id=report_table_id)
            parameters = rt.get_parameters()
        return render(request, "amrs_reports/create_report_table.html", {"report_table": rt, "parameters": parameters})
Example #4
0
def delete_defaulter_cohort(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    cohort_uuid = request.GET["cohort_uuid"]
    DefaulterCohort.delete_defaulter_cohort(cohort_uuid)
    return HttpResponseRedirect("/ltfu/manage_defaulter_cohorts")
Example #5
0
def ltfu_clinic(request):
    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    location_id = get_var_from_request(request,'location_id')
    locations = Location().get_locations()
    location = Location().get_location(location_id)

    ltfu_date = get_var_from_request(request,'ltfu_date')

    if location_id :
        rt = ReportTable.objects.filter(name='ltfu_clinic')[0]
        parameter_values = (ltfu_date,location_id)
        table = rt.run_report_table(parameter_values=parameter_values,as_dict=True)['rows']

        rt = ReportTable.objects.filter(name='ltfu_stats')[0]
        result = rt.run_report_table(as_dict=True)
        ltfu_stats = result['rows']
        return render(request,'ltfu/ltfu_clinic.html',
                      {'ltfu_clinic_table':table,
                       'locations':locations,
                       'location':location,
                       'ltfu_stats':ltfu_stats,
                       }
                      )
Example #6
0
def ajax_get_defaulter_cohort(request):
    if not Authorize.authorize(request.user, ["outreach_supervisor", "outreach_all", "outreach_worker"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")
    defaulter_cohort_id = request.POST["defaulter_cohort_id"]

    dc = DefaulterCohort.objects.get(id=defaulter_cohort_id)

    data = request.session.get(dc.location_uuid, "")
    if data is not None and data != "":
        patients = json.loads(request.session.get(dc.location_uuid, ""))
    else:
        patients = dc.get_patients()
        request.session[dc.location_uuid] = json.dumps(patients, cls=DjangoJSONEncoder)

    d = {
        "name": dc.name,
        "date_created": dc.date_created,
        "patients": patients,
        "id": dc.id,
        "location_uuid": dc.location_uuid,
        "uuid": dc.uuid,
    }
    d = json.dumps(d, cls=DjangoJSONEncoder)

    return HttpResponse(d, content_type="application/json")
Example #7
0
def view_reason_missed_appt(request):
    if not Authorize.authorize(request.user,['outreach_all']) :
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    
    start_date = get_var_from_request(request,'start_date')
    if start_date is None : start_date = '2014-01-01'
    end_date = get_var_from_request(request,'end_date')
    if end_date is None : end_date = '2020-01-01'

    all_locations = 0
    location_ids_str = get_var_from_request(request,'location_ids')

    if location_ids_str is None or location_ids_str == '()':
        location_ids = ('-1',)
        all_locations = 1
        location_ids_str = ''
    else :
        location_ids = tuple(location_ids_str.split(','))


    rt = ReportTable.objects.get(name='retention_reason_missed_appt_total')
    parameter_values = (start_date,end_date,all_locations,location_ids)
    rows = rt.run_report_table(parameter_values=parameter_values,as_dict=True)['rows']
    times_asked = rows[0]['total']

    rt = ReportTable.objects.get(name='retention_reason_missed_appt')
    parameter_values = (start_date,end_date,all_locations,location_ids)
    rows = rt.run_report_table(parameter_values=parameter_values,as_dict=True)['rows']

    coded_reasons = {}
    concept_ids = []
    for row in rows :
        codes = row['reason_missed_appt'].split(' // ')
        for code in codes:
            if code in coded_reasons : coded_reasons[code]['count'] += row['count']
            else : 
                coded_reasons[code] = {'count':row['count']}
                concept_ids.append(code)
    concept_ids = tuple(concept_ids)

    rt = ReportTable.objects.get(name='amrs_concept_name')
    parameter_values = (concept_ids,)
    rows = rt.run_report_table(parameter_values=parameter_values,as_dict=True)['rows']              

    reasons = []
    for r in rows:
        reasons.append({'concept_id':r['concept_id'],
                        'name':r['name'],
                        'count':coded_reasons[str(r['concept_id'])]['count']
                        })


    return render(request,'ltfu/reason_missed_appt.html',
                  {'reason_missed_appt':reasons,
                   'start_date':start_date,
                   'end_date':end_date,
                   'location_ids': location_ids_str,
                   'times_asked': times_asked,
                   }
                  )
Example #8
0
def view_datasets(request):
    if not Authorize.authorize(request.user,['admin']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    if request.method == 'POST' :
        pass
    else :
        pass
Example #9
0
def outreach_dashboard(request):
    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all','outreach_worker']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    
    clinics = DefaulterCohort.get_outreach_locations()
    device = get_device(request)
    return render(request,'ltfu/outreach_dashboard_mobile.html',{'clinics':clinics,
                                                                 'device':device,})
Example #10
0
def outreach_clinic_dashboard(request):
    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all','outreach_worker']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    location = Location.get_location(location_uuid)
    defaulter_cohort = DefaulterCohort.objects.filter(location_uuid=location_uuid,retired=0)[0]
    device = get_device(request)
    return render(request,'ltfu/outreach_clinic_dashboard_mobile.html',{'location':location,
                                                                        'defaulter_cohort':defaulter_cohort,
                                                                        'device':device})
Example #11
0
def index(request):
    if not Authorize.authorize(request.user):
        return HttpResponseRedirect("amrs_user_validation/access_denied")
    device = u.get_device(request)

    if device["is_mobile"]:
        return render(request, "amrs_reports/index_mobile.html", {})
    else:
        return render(request, "amrs_reports/index.html", {})
Example #12
0
def delete_report(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    if "report_id" in request.GET:
        r = Report.objects.get(id=request.GET["report_id"])
        ReportMember.objects.filter(report_id=r.id).delete()
        r.delete()

    return HttpResponseRedirect("/")
Example #13
0
def view_data_entry_forms_done(request):
    if not Authorize.authorize(request.user,['superuser']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    
    rt = ReportTable.objects.filter(name='data_entry_forms_done')[0]
    table = rt.run_report_table(as_dict=True)['rows']
     
    return render(request,'ltfu/forms_done.html',
                  {'forms_done' : table,
                   })
Example #14
0
def manage_defaulter_cohorts(request):    
    if not Authorize.authorize(request.user,['superuser']) :
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    dcs = DefaulterCohort.objects.all()    
    return render(request,
                  'ltfu/manage_defaulter_cohorts.html',
                  {"defaulter_cohorts":dcs,                   
                   }
                  )
Example #15
0
def ltfu_clinics(request):
    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    rt = ReportTable.objects.filter(name='ltfu_clinics')[0]
    ltfu_clinics_table = rt.run_report_table(as_dict=True)['rows']
    parameters = ReportTableParameter.objects.filter(report_table_id=rt.id)
    return render(request,"ltfu/ltfu_clinics.html",
                  {'report_table':rt,
                   'ltfu_clinics_table':ltfu_clinics_table,
                   'parameters':parameters,
                   })
Example #16
0
def create_dataset(request):
    if not Authorize.authorize(request.user,['admin']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    if request.method == 'POST' :
        pass

    else :
        dataset_id = get_var_from_request(request,'dataset_id')
        d = None
        if dataset_id is not None :
            d = AmrsDataset.objects.filter(id=dataset_id)
        return render(request,'amrs_data_manager/create_dataset.html',{'dataset':d})
Example #17
0
def outreach_worker_defaulter_list(request):
    if not Authorize.authorize(request.user,['outreach_all','outreach_manager','outreach_supervisor','outreach_worker']) :
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    
    cohort_uuid = get_var_from_request(request,'defaulter_cohort_uuid')
    prev_cohort_uuid = request.session.get('cohort_uuid')

    # this means the user is coming from a form submission page, otherwise there should always be a cohort_uuid
    if cohort_uuid is None : cohort_uuid = prev_cohort_uuid

    request.session['cohort_uuid'] = cohort_uuid
    dc = DefaulterCohort.objects.get(cohort_uuid=cohort_uuid)    
 
    if prev_cohort_uuid is not None and prev_cohort_uuid == cohort_uuid: 
        my_defaulter_list = json.loads(request.session.get('my_defaulter_list',''))
    else : my_defaulter_list = []
            
    if my_defaulter_list is None or len(my_defaulter_list) == 0 :
        patient_uuids_in_use = []
        sessions = Session.objects.filter(expire_date__gt=datetime.now())
        print 'num sessions: ' + str(len(sessions))
        for s in sessions:
            print 'user_id: ' + str(request.user.id)
            print 'session owner: ' + str(s.get_decoded().get('_auth_user_id'))
            session_owner_id = s.get_decoded().get('_auth_user_id')
            if session_owner_id is not None and request.user.id != int(session_owner_id):
                decoded = s.get_decoded().get('my_defaulter_list')
                if decoded is not None:
                    defaulters = json.loads(decoded)
                    for d in defaulters:
                        patient_uuids_in_use.append(d['uuid'])


            #3/8/2014: the following is a temporary solution to deleting old sessions. it is NOT in the right place                             
            if session_owner_id is None:
                s.delete()

        my_defaulter_list = dc.get_defaulter_list(patient_uuids_in_use)
        
        request.session['my_defaulter_list'] = json.dumps(my_defaulter_list, cls=DjangoJSONEncoder)

    location = Location.get_location(dc.location_id)
    defaulter_cohorts = DefaulterCohort.objects.all().order_by('name')
    
    return render(request,'ltfu/outreach_worker_defaulter_list.html',
                  {'defaulter_list':my_defaulter_list,
                   'location':location,
                   'defaulter_cohort':dc,
                   'defaulter_cohorts':defaulter_cohorts,
                   }
                  )
Example #18
0
def ltfu_ampath(request):
    if not Authorize.authorize(request.user,['outreach_all']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    rt = ReportTable.objects.filter(name='ltfu_ampath')[0]
    result = rt.run_report_table(as_dict=True)
    rows = result['rows']
    totals = {}
    for row in rows :
        for key, value in row.items():
            try :
                totals[key] = int(totals[key]) + int(value)
            except Exception, e :
                print str(e) + ' in exception'
Example #19
0
def create_defaulter_cohort(request):
    if not Authorize.authorize(request.user, ["outreach_supervisor", "outreach_all", "outreach_worker"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")
    location_uuid = request.GET["location_uuid"]
    dc = DefaulterCohort.create_defaulter_cohort(location_uuid)
    patients = dc.get_patients()

    request.session[dc.location_uuid] = json.dumps(patients, cls=DjangoJSONEncoder)
    device = get_device(request)
    return render(
        request,
        "ltfu/view_defaulter_cohort_mobile.html",
        {"defaulter_cohort": dc, "patients": patients, "device": device},
    )
Example #20
0
def ajax_get_new_defaulter_cohort(request):
    if not ajax_auth(request):
        return HttpResponseForbidden()

    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all','outreach_worker']) :
        return HttpResponseRedirect('/amrs_user_validation/access_denied')
    
    defaulter_cohort_id = get_var_from_request(request,'defaulter_cohort_id')    
    defaulter_cohort_uuid = get_var_from_request(request,'defaulter_cohort_uuid')
    
    if defaulter_cohort_id : dc = DefaulterCohort.objects.get(id=defaulter_cohort_id)
    else : dc = DefaulterCohort.objects.get(uuid=defaulter_cohort_uuid)
    
    new_dc = DefaulterCohort.create_defaulter_cohort(old_defaulter_cohort_id=dc.id)    
    d = CohortCache.get_cohort(dc.id)

    return HttpResponse(d,content_type='application/json')
Example #21
0
def get_report_as_pdf(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    report_id = get_var_from_request(request, "report_id")
    if report_id:
        r = Report.objects.get(id=report_id)
        args = r.run_report(request.POST)
        template = r.template
        if template is None or template == "":
            template = "amrs_reports/view_report_pdf.html"
        template = get_template(template)
        context = {"report": r, "report_members": args}
        html = template.render(RequestContext(request, context))

        response = HttpResponse(mimetype="application/pdf")
        HTML(string=html, url_fetcher=my_fetcher, base_url=request.build_absolute_uri()).write_pdf(response)
        return response
Example #22
0
def view_indicators_by_clinic(request):
    if not Authorize.authorize(request.user) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    locations = Location.get_locations()
    location_groups = DerivedGroup.objects.filter(base_class='Location').order_by('name')
    start_date = get_var_from_request(request,'start_date')
    if start_date is None : start_date = '2000-01-01'

    end_date = get_var_from_request(request,'end_date')
    if end_date is None : end_date = '2020-01-01'
    try:
        values = (start_date,end_date,)
        rt = ReportTable.objects.get(name='hiv_clinic_key_indicators')
        clinic_indicators = rt.run_report_table(parameter_values=values,as_dict=True)['rows']

    except Exception, e:
        clinic_indicators = {}
        print e
Example #23
0
def view_defaulter_cohort(request):
    if not Authorize.authorize(request.user, ["outreach_supervisor", "outreach_all", "outreach_worker"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")
    location_uuid = request.GET["location_uuid"]

    dc = DefaulterCohort.objects.filter(location_uuid=location_uuid, retired=0)[0]

    data = request.session.get(dc.location_uuid, "")
    if data is not None and data != "":
        patients = json.loads(request.session.get(dc.location_uuid, ""))
    else:
        patients = dc.get_patients()
        request.session[dc.location_uuid] = json.dumps(patients, cls=DjangoJSONEncoder)

    device = get_device(request)
    return render(
        request,
        "ltfu/view_defaulter_cohort_mobile.html",
        {"defaulter_cohort": dc, "patients": patients, "device": device},
    )
Example #24
0
def run_report_table(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    report_table_id = get_var_from_request(request, "report_table_id")
    if report_table_id:
        rt = ReportTable.objects.get(id=report_table_id)
        result = rt.run_report_table(request.POST)
        cols = result["cols"]
        rows = result["rows"]
        parameters = ReportTableParameter.objects.filter(report_table_id=rt.id)
        return render(
            request,
            "amrs_reports/view_report_table.html",
            {"report_table": rt, "cols": cols, "rows": rows, "parameters": parameters},
        )

    else:
        report_tables = ReportTable.objects.all()
        return render(request, "amrs_reports/run_report_table.html", {"report_tables": report_tables})
Example #25
0
def view_indicators_by_provider(request):
    if not Authorize.authorize(request.user,['superuser']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    start_date = get_var_from_request(request,'start_date')
    if start_date is None : start_date = '2014-01-01'
    end_date = get_var_from_request(request,'end_date')
    if end_date is None : end_date = '2020-01-01'
    
    rt = ReportTable.objects.get(name='outreach_indicators_by_provider')
    parameter_values = (start_date,end_date)
    table = rt.run_report_table(parameter_values=parameter_values,as_dict=True)['rows']
        
    return render(request,'ltfu/outreach_indicators.html',
                  {'indicators':table,
                   'start_date':start_date,
                   'end_date':end_date,
                   'query_subject':'provider',
                   }
                  )
Example #26
0
def index(request):
    if not Authorize.authorize(request.user) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    locations = Location.get_locations()
    location_groups = DerivedGroup.objects.filter(base_class='Location').order_by('name')

    system_indicators = request.session.get('hiv_system_indicators')
    if system_indicators is not None : system_indicators = simplejson.loads(system_indicators)

    if system_indicators is None :
        try:
            rt = ReportTable.objects.get(name='hiv_system_key_indicators')
            system_indicators = rt.run_report_table(as_dict=True)['rows']

            if system_indicators : 
                print 'saving system indicators to session'
                request.session['system_indicators'] = simplejson.dumps(system_indicators)

        except Exception, e:
            pass
Example #27
0
def create_report(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    if request.method == "POST":
        print request.POST
        name = get_var(request.POST, "report_name")
        description = get_var(request.POST, "description")
        template = get_var(request.POST, "template")
        report_id = get_var(request.POST, "report_id")
        if name:
            if report_id:
                r = Report.objects.get(id=report_id)
                r.name = name
                r.description = description
            else:
                r = Report(name=name, description=description)
            r.save()
            cur_index = 2
            while True:
                row = get_var(request.POST, "report_table_values_" + str(cur_index))
                if row is None:
                    break
                rm = ReportMember(report_id=r.id)
                args = row.split(";;;")

                for arg in args:
                    split = arg.split("===")
                    setattr(rm, split[0], split[1])
                rm.save()
                cur_index += 1

        return HttpResponseRedirect("/")
    else:
        report_id = get_var(request.GET, "report_id")
        report_tables = ReportTable.objects.all().order_by("name")
        r = None
        if report_id:
            r = Report.objects.get(id=report_id)
        return render(request, "amrs_reports/create_report.html", {"report": r, "report_tables": report_tables})
Example #28
0
def view_patient(request):
    if not Authorize.authorize(request.user,['outreach_supervisor','outreach_all','outreach_worker']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    dcm_id = request.GET.get('defaulter_cohort_member_id',None)
    patient_uuid = request.GET.get('patient_uuid',None)
    if dcm_id is not None :        
        member = DefaulterCohortMember.objects.get(id=dcm_id)        
        p = member.get_patient_info()
        patient_uuid = p['uuid']
    else : 
        qs = DefaulterCohortMember.objects.filter(patient_uuid=patient_uuid,retired=0)
        if qs.count() > 0 :
            member = qs[0]
            p = member.get_patient_info()    
        else :
            p = Patient.get_patient_by_uuid(patient_uuid)
    device = get_device(request)
    encounters = RetentionDataset.get_patient_encounters(patient_uuid)
    encounter_types = EncounterType.get_encounter_types()
    locations = Location.get_locations()
    loc = {}
    enc_types = {}
    for l in locations :
        loc[l['location_id']] = l
    for e in encounter_types:
        enc_types[e['encounter_type_id']] = e

    for e in encounters :
        e['location_name'] = loc[e['location_id']]['name']
        e['encounter_type_name'] = enc_types[e['encounter_type']]['name']
        

    return render(request,'ltfu/view_patient_mobile.html',
                  {'patient':p,
                   'encounters':encounters,
                   'device':device}
                  )
Example #29
0
def run_report(request):
    if not Authorize.authorize(request.user, ["superuser"]):
        return HttpResponseRedirect("/amrs_user_validation/access_denied")

    report_id = get_var_from_request(request, "report_id")
    if report_id:
        r = Report.objects.get(id=report_id)
        args = r.run_report(request.POST)
        template = r.template
        if template is None or template == "":
            template = "amrs_reports/view_report.html"

        return render(request, template, {"report": r, "report_members": args})

    else:
        report_tables = ReportTable.objects.all()
        return render(request, "amrs_reports/run_report.html", {"report_tables": report_tables})

    if request.method == "POST":
        report_id = get_var(request.POST, "report_id")
        r = Report.objects.get(id=report_id)
        result = r.run_report(request.POST)
        return render(request, result[0], result[1])
Example #30
0
def run_report_table(request):
    if not Authorize.authorize(request.user,['superuser']) :        
        return HttpResponseRedirect('/amrs_user_validation/access_denied')

    report_table_id = get_var_from_request(request,'report_table_id')
    if report_table_id :
        rt = ReportTable.objects.get(id=report_table_id)
        result = rt.run_report_table(request.POST)
        cols = result['cols']
        rows = result['rows']
        parameters = ReportTableParameter.objects.filter(report_table_id=rt.id)
        return render(request,"amrs_reports/view_report_table.html",
                      {'report_table':rt,
                       'cols':cols,
                       'rows':rows,
                       'parameters':parameters,                       
                       })

    else :
        report_tables = ReportTable.objects.all()
        return render(request, "amrs_reports/run_report_table.html",
                      {'report_tables':report_tables,
                       })