def select( request, 
            redirect_field_name = REDIRECT_FIELD_NAME,
            domain_select_template = 'domain/select.html' ):
    
    domains_for_user = Domain.active_for_user(request.user)
    if len(domains_for_user) == 0:       
        vals = dict( error_msg = "You are not a member of any existing domains - please contact your system administrator",
                     show_homepage_link = False   )
        return render_to_response(request, 'error.html', vals)
    
    redirect_to = request.REQUEST.get(redirect_field_name, '')    
    if request.method == 'POST': # If the form has been submitted...        
        form = DomainSelectionForm(domain_list=domains_for_user,
                                   data=request.POST) # A form bound to the POST data
                     
        if form.is_valid():
            # We've just checked the submitted data against a freshly-retrieved set of domains
            # associated with the user. It's safe to set the domain in the sesssion (and we'll
            # check again on views validated with the domain-checking decorator)
            form.save(request) # Needs request because it saves domain in session
    
            #  Weak attempt to give user a good UX - make sure redirect_to isn't garbage.
            if not redirect_to or '//' in redirect_to or ' ' in redirect_to:
                redirect_to = reverse('homepage')
            return HttpResponseRedirect(redirect_to) # Redirect after POST
    else:
        # An unbound form
        form = DomainSelectionForm( domain_list=domains_for_user ) 

    vals = dict( next = redirect_to,
                 form = form )

    return render_to_response(request, domain_select_template, vals)

def users(req):
    template_name = "iavi/users.html"
    current_user = req.user
    try:
        profile = current_user.get_profile()
        locations = profile.locations.all()
    except IaviProfile.DoesNotExist:
        # if they don't have a profile they aren't associated with
        # any locations and therefore can't view anything.  Only
        # exceptions are the superusers
        if current_user.is_superuser:
            # todo: allow access to everything
            locations = Location.objects.all()
        else:
            return render_to_response(req, "iavi/no_profile.html", {})

    all_users = User.objects.all()
    for user in all_users:
        try:
            profile = user.get_profile()
            # set some fields in the user object so we can access them in the template
            location_strings = [str(location) for location in profile.locations.all()]
            user.locations = ", ".join(location_strings)
        except IaviProfile.DoesNotExist:
            user.locations = ""
        if user.is_superuser:
            user.permission_string = "Administrator"
        else:
            user.permission_string = ", ".join([str(group) for group in user.groups.all()])

    return render_to_response(req, template_name, {"all_users": all_users})

def data(req):
    template_name = "iavi/data.html"
    user = req.user
    try:
        profile = user.get_profile()
        locations = profile.locations.all()
    except IaviProfile.DoesNotExist:
        # if they don't have a profile they aren't associated with
        # any locations and therefore can't view anything.  Only
        # exceptions are the superusers
        if user.is_superuser:
            # todo: allow access to everything
            locations = Location.objects.all()
        else:
            return render_to_response(req, "iavi/no_profile.html", {})

    seven_days = timedelta(days=7)
    # thirty_days = timedelta(days=30)
    tomorrow = datetime.today() + timedelta(days=1)

    kenya_reports = (
        KenyaReport.objects.filter(started__gte=tomorrow - seven_days)
        .filter(reporter__location__in=locations)
        .order_by("-started")
    )
    uganda_reports = (
        UgandaReport.objects.filter(started__gte=tomorrow - seven_days)
        .filter(reporter__location__in=locations)
        .order_by("-started")
    )
    return render_to_response(req, template_name, {"kenya_reports": kenya_reports, "uganda_reports": uganda_reports})

def data(req, id = None):
    allTrees = Tree.objects.all()
    # ok, the plan is to generate a table of responses per state, but this is tricky with loops.
    # the first thing we'll do is get all the possible states you can reach from the tree
    # then we'll tabulate the results of each state's first value
    # then we'll look at paths, by using the concatenated list of states taken for that path as a key
    if len(allTrees) != 0:
        t = get_tree(id)
        all_states = t.get_all_states()
        loops = t.has_loops() 
        if not loops:
            # this is the easy case.  just create one column per state and then display the results
            sessions = Session.objects.all().filter(tree=t)
            return render_to_response(req, "tree/data.html",
                                      { "trees": allTrees, "t": t, "states" : all_states, "sessions" : sessions, "loops" : loops}
                                      )
        else: 
            # here what we want is a table where the columns are every unique path through the 
            # tree, and the rows are the sessions, with the paths filled in.
            # Since there are loops we have to generate the list of unique paths from
            # the session data.  
            # So we get every session, and for every entry in that session we get the path.
            # If we haven't seen the path we add it to the master list.  
            # Then we walk back through the master list, and walk through each session to
            # see if it has an entry matching that path, and if so set the answer.  
            sessions = Session.objects.all().filter(tree=t)
            paths = {}
            # i think paths will be a dictionary of paths to dictionaries of sessions to answers
            # e.g. { <path> : { <session> : <answer>}
            # which will allow us to iterate through paths and say:
            # if paths[path].has_key(session):
            #    this_cell = paths[path][session]
            for session in sessions:
                entries = session.entry_set.all().order_by('sequence_id')
                path = ''
                for entry in entries:
                    path = path + str(entry.transition.current_state.id) + '/'
                    entry.path = path
                    if paths.has_key(path):
                        paths[path][session] = entry.transition.answer
                    else:
                        paths[path] = { session : entry.transition.answer }
            return render_to_response(req, "tree/data.html",
                                      { "trees": allTrees, "t": t, "paths" : paths, "sessions" : sessions, "loops" : loops }
                                      )
        # now we need to map all states to answers
        states_w_answers = {}
        for state in all_states:
            states_w_answers[state] = map((lambda x: x.answer), state.transition_set.all()) 
        # now we need to get all the entries
        all_entries = Entry.objects.all().filter(session__tree = t)
        if loops:
            # stupid error fix to prevent trees with loops from exploding.  This should be done better
            t = Tree()
            t.trigger = "Sorry, can't display this tree because it has loops.  We're working on it."
        return render_to_response(req, "tree/index.html",
            { "trees": allTrees, "t": t })
    else:
        return render_to_response("tree/index.html",
            context_instance=RequestContext(req))

def index(req):
    allTrees = Tree.objects.all()
    if len(allTrees) != 0:
		t = allTrees[len(allTrees) - 1]
		return render_to_response(req, "tree/index.html",
		    { "trees": allTrees, "t": t })
    else:
		return render_to_response(req, "tree/index.html", {})

def report_view(req):
    cls = ReportMalnutrition

    report_title = cls._meta.verbose_name
    rows = []

    reports = cls.objects.all()
    i = 0
    for report in reports:
        i += 1
        row = {}
        row["cells"] = []
        row["cells"].append({"value": report.case})
        row["cells"].append({"value": report.reporter})
        row["cells"].append({"value": \
                report.entered_at.strftime("%d/%m/%Y")})
        row["cells"].append({"value": report.muac, "num": True})
        row["cells"].append({"value": report.height, "num": True})
        row["cells"].append({"value": report.weight, "num": True})
        row["cells"].append({"value": report.status})

        if i == 100:
            row['complete'] = True
            rows.append(row)
            break
        rows.append(row)

    columns, sub_columns = cls.table_columns()

    aocolumns_js = "{ \"sType\": \"html\" },"
    for col in columns[1:] + (sub_columns if sub_columns != None else []):
        if not 'colspan' in col:
            aocolumns_js += "{ \"asSorting\": [ \"desc\", \"asc\" ], " \
                            "\"bSearchable\": false },"
    aocolumns_js = aocolumns_js[:-1]

    aggregate = False
    print columns
    print sub_columns
    print len(rows)
    context_dict = {'get_vars': req.META['QUERY_STRING'],
                    'columns': columns, 'sub_columns': sub_columns,
                    'rows': rows, 'report_title': report_title,
                    'aggregate': aggregate, 'aocolumns_js': aocolumns_js}

    if req.method == 'GET' and 'excel' in req.GET:
        '''response = HttpResponse(mimetype="application/vnd.ms-excel")
        filename = "%s %s.xls" % \
                   (report_title, datetime.now().strftime("%d%m%Y"))
        response['Content-Disposition'] = "attachment; " \
                                          "filename=\"%s\"" % filename
        from findug.utils import create_excel
        response.write(create_excel(context_dict))
        return response'''
        return render_to_response(req, 'childcount/report.html', context_dict)
    else:
        return render_to_response(req, 'childcount/report.html', context_dict)

def config_submit(req):
    c = MTurkConfig.objects.filter(current=True)
    if c:
        template_path = "xtrans/config_submit.html"
        f = ConfigForm(instance=c)
        return render_to_response(req, template_path, {'form':f})
    else:
        template_path = "xtrans/config_blank.html"
        return render_to_response(req,template_path,{})

def custom_report(request, domain_id, report_name):
    context = {}
    context["report_name"] = report_name
    report_method = util.get_report_method(request.user.selected_domain, report_name)
    if not report_method:
        return render_to_response(request, 
                                  "custom/report_not_found.html",
                                  context)
    context["report_display"] = report_method.__doc__
    context["report_body"] = report_method(request)
    return render_to_response(request, "custom/base.html", context)

def reports(request, template_name="list.html"):
    # not sure where this view will live in the UI yet
    context = {}
    extuser = request.extuser
    context["domain"] = extuser.domain
    context["case_reports"] = Case.objects.filter(domain=extuser.domain)
    context["sql_reports"] = SqlReport.objects.filter(domain=extuser.domain, is_active=True)
    context["custom_reports"] = util.get_custom_reports(extuser.domain)
    if not context["custom_reports"] and not context["sql_reports"] and not context["case_reports"]:
        return render_to_response(request, "domain_not_found.html", context)
    return render_to_response(request, template_name, context)

def reports(request, template_name="list.html"):
    # not sure where this view will live in the UI yet
    context = {}
    context['case_reports'] = Case.objects.filter(domain=request.user.selected_domain)
    context['sql_reports'] = SqlReport.objects.filter(domain=request.user.selected_domain, is_active=True)
    context['custom_reports'] = util.get_custom_reports(request.user.selected_domain)
    if not context['custom_reports'] and not context['sql_reports']\
       and not context['case_reports']:
        return render_to_response(request, 
                                  "domain_not_found.html",
                                  context)
    return render_to_response(request, template_name, context)

def all_builds(request, template_name="buildmanager/all_builds.html"):    
    context = {}    
    try: 
        extuser = ExtUser.objects.all().get(id=request.user.id)
        context["domain"] = extuser.domain
        projects = Project.objects.filter(domain=extuser.domain)
        builds = _get_build_dictionary(projects)
        context['all_builds'] = builds
    except ExtUser.DoesNotExist:
        template_name="hq/no_permission.html"
        return render_to_response(request, template_name, context)
    return render_to_response(request, template_name, context)

 def post(req, template_name):
     xform_body = req.POST["xform"]
     try:
         result, errors, has_error = readable_form(xform_body)
         return render_to_response(req, template_name, {"success": True, 
                                                        "message": "Your form was successfully validated!",
                                                        "xform": xform_body,
                                                        "readable_form": result
                                                        })
     except Exception, e:
         return render_to_response(req, template_name, {"success": False, 
                                                        "message": "Failure to generate readable xform! %s" % e,
                                                        "xform": xform_body
                                                        })

 def post(req, template_name):
     xform_body = req.POST["xform"]
     hq_validation = True if "hq-validate" in req.POST else False
     try:
         xformvalidator.validate_xml(xform_body, do_hq_validation=hq_validation)
         return render_to_response(
             req,
             template_name,
             {"success": True, "message": "Your form was successfully validated!", "xform": xform_body},
         )
     except Exception, e:
         return render_to_response(
             req, template_name, {"success": False, "message": "Validation Fail! %s" % e, "xform": xform_body}
         )

def index(req):
    template_name="logger/index_flat.html"
    columns = (("date", "Date"),
               ("connection__identity", "From/To"),
               ("connection__backend", "Backend"),
               ("is_incoming", "Direction"),
               ("text", "Message"))
    sort_column, sort_descending = _get_sort_info(req, default_sort_column="date", 
                                                  default_sort_descending=True)
    sort_desc_string = "-" if sort_descending else ""
    search_string = req.REQUEST.get("q", "")

    query = Message.objects.select_related("connection", "connection__backend"
            ).order_by("%s%s" % (sort_desc_string, sort_column))

    if search_string == "":
        query = query.all()

    else:
        query = query.filter(
           Q(text__icontains=search_string) |
           Q(connection__identity__icontains=search_string))

    messages = paginated(req, query)
    return render_to_response(req, template_name, {"columns": columns,
                                                   "messages": messages,
                                                   "sort_column": sort_column,
                                                   "sort_descending": sort_descending,
                                                   "search_string": search_string})

def org_sms_report(request, template_name="hq/org_single_report.html"):
    context = {}
    # the decorator and middleware ensure this will be set.
    extuser = request.extuser
    startdate, enddate = utils.get_dates(request)
    context['startdate'] = startdate
    context['enddate'] = enddate    
    
    context['extuser'] = extuser
    context['domain'] = extuser.domain
    context['daterange_header'] = repinspector.get_daterange_header(startdate, enddate)
    context['view_name'] = 'hq.views.org_sms_report'
    
    # commented out because these reports aren't actually different reports
    # report = ReportSchedule.objects.get(id=id)
    # context["report"] = report
    # get the domain from the user, the root organization from the domain,
    # and then the report from the root organization
    #reporter.
    root_orgs = Organization.objects.filter(parent=None, domain=extuser.domain)
    # note: this pretty sneakily decides for you that you only care
    # about one root organization per domain.  should we lift this 
    # restriction?  otherwise this may hide data from you 
    root_org = root_orgs[0]
    
    # this call makes the meat of the report.
    #data = repinspector.get_data_below(root_org, startdate, enddate, 0)
    #data = custom._get_flat_data_for_domain(extuser.domain, startdate, enddate + timedelta(days=1))
    data = custom._get_flat_data_for_domain(extuser.domain, startdate, enddate + timedelta(days=1))
    heading = "Report for period: " + startdate.strftime('%m/%d/%Y') + " - " + enddate.strftime('%m/%d/%Y')
    rendered = reporter.render_direct_sms(data, startdate, enddate, 
                                          "hq/reports/sms_organization.txt", 
                                          {"heading" : heading })
    context['report_display'] = rendered
    return render_to_response(request, template_name, context)

def inspector(request, table_name, template_name="graphing/table_inspector.html"):
    context = {}
    context['table_name'] = table_name
    
    str_column = None
    str_column_value = None
    datetime_column = None
    data_column = None
    display_mode = None    
    
    for item in request.GET.items():
        if item[0] == 'str_column':
            str_column = item[1]                    
        if item[0] == 'str_column_value':
            str_column_value = item[1] 
        if item[0] == 'datetime_column':
            datetime_column = item[1]   
        if item[0] == 'data_column':
            data_column = item[1]        
        if item[0] == 'display_mode':
            display_mode = item[1]    
            
    context['str_column'] = str_column
    context['str_column_value'] = str_column_value
    context['datetime_column'] = datetime_column
    context['data_column'] = data_column
    context['display_mode'] = display_mode    
    
    return render_to_response(request, template_name, context)

def summary_trend(request, template_name="graphing/summary_trend.html"):
    """This is just a really really basic trend of total counts for a given set 
       of forms under this domain/organization"""    
    context = {}        
    formname = ''
    formdef_id = -1
    
    for item in request.GET.items():
        if item[0] == 'formdef_id':
            formdef_id=item[1]    
    if formdef_id == -1:
        context['chart_title'] = 'All Data'
        context['dataset'] = {}        
        defs = FormDefModel.objects.all().filter(domain=request.user.selected_domain)
    
        for fdef in defs:            
            d = dbhelper.DbHelper(fdef.element.table_name, fdef.form_display_name)            
            context['dataset'][fdef.form_display_name.__str__()] = d.get_counts_dataset(None,None)                    
    
    else:
        fdef = FormDefModel.objects.all().filter(id=formdef_id)
        context['chart_title'] = fdef[0].form_display_name
        d = dbhelper.DbHelper(fdef[0].element.table_name,fdef[0].form_display_name)        
        context['dataset'] = d.get_integer_series_dataset()
    
    context ['maxdate'] = 0;
    context ['mindate'] = 0;
    return render_to_response(request, template_name, context)

def toggle(req,status):
    if(status):
        status = 'On'
    else:
        status = 'Off'
    template_path = "xtrans/index.html"
    return render_to_response(req, template_path, {'status':status})

def reporter_view(req, reporter_id):
    ''' Displays a summary of his activities and history '''

    reporter = Reporter.objects.get(id=reporter_id)

    return render_to_response(req, 'findug/reporter.html',
                              {"reporter": reporter})

def single_submission(request, submission_id, template_name="receiver/single_submission.html"):
    context = {}        
    slog = Submission.objects.all().filter(id=submission_id)
    context['submission'] = slog[0]
    rawstring = str(slog[0].raw_header)
    
    # In order to display the raw header information, we need to 
    # escape the python object brackets in the output 
    rawstring = rawstring.replace(': <',': "<')
    rawstring = rawstring.replace('>,','>",')
    rawstring = rawstring.replace('>}','>"}') 
    processed_header = eval(rawstring)
    
    get_original = False
    for item in request.GET.items():
        if item[0] == 'get_original':
            get_original = True           
    
    if get_original:
        response = HttpResponse(mimetype='text/plain')
        fin = open(slog[0].raw_post ,'r')
        txt = fin.read()
        fin.close()
        response.write(txt) 
        return response
    
    attachments = Attachment.objects.all().filter(submission=slog[0])
    context ['processed_header'] = processed_header
    context['attachments'] = attachments
    return render_to_response(request, template_name, context)