Python template.render_to_response函数代码示例

def createpatient(request):
    # this code path is when the user's POSTed to us
    if request.method == 'POST':
        # set up the form object
        form = PatientForm(request.POST)
        # if the form is valid, do this stuff
        if form.is_valid():
            # pull out the data from the form
            medical_record_number = form.cleaned_data['medical_record_number']
            first_name = form.cleaned_data['first_name']
            last_name = form.cleaned_data['last_name']
            #TODO: figure out how to ensure uniqueness
            # create a Patient object with that data
            patient = Patient(medical_record_number = medical_record_number,
                              first_name = first_name,
                              last_name = last_name)
            # save the object to the DB
            patient.put()
            # this grabs all the forms associated to that patient
            forms = Form.all().filter('patient =', patient.key())
            # this calls the template patient_detail.html and passes the patient and the forms
            return render_to_response(request, 'dorkdoc/patient_detail.html', 
                { 'patient' : patient,
                  'forms'   : forms
                }
            )
            
    # this code path is when the user GETs this URL
    else:
        # create a blank form object
        form = PatientForm()
    
    # this passes the form data to the createpatient template
    return render_to_response(request, 'createpatient.html', {'form' : form })

def search(request):
    """
    Route searching
    """	
    error = None
    agency = None
    if "agency" in request.GET:
        agency_id = request.GET['agency']
        agency = db.Key.from_path(Agency.kind(),agency_id)

    if "keyword" not in request.GET:
        return render_to_response( 
            request,
            'gogogo/route/search.html'
            ,{ 
                'page_title': _("Route searching"),
                'result' : [],
                'error' : _("Error! No keyword provided!")
               })
        
    keyword = request.GET['keyword']
    keyword = keyword.lower()

    route_list_loader = ListLoader(Route)
    route_list_loader.load()
    
    route_list = route_list_loader.get_data()
    
    result = []
    
    agency_property = getattr(Route,"agency")

    for route in route_list:
        if agency:
            key = agency_property.get_value_for_datastore(route)
            if agency != key:
                continue
    
        if route.short_name.lower().find(keyword) != -1:
            result.append(route)
            continue
            
        for name in route.long_name:
            if name.lower().find(keyword)!= -1:
                result.append(route)
                continue
            
    result = [trEntity(createEntity(route),request) for route in result  ]
        
    return render_to_response( 
        request,
        'gogogo/route/search.html'
        ,{ 
            'page_title': _("Route searching"),
            'result' : result,
            'error' : error
           })		

def create_admin_user(request):
    return render_to_response(request, 'myapp/admin_created.html')
    user = User.get_by_key_name('admin')
    if not user or user.username != 'admin' or not (user.is_active and
            user.is_staff and user.is_superuser and
            user.check_password('admin')):
        user = User(key_name='admin', username='admin',
            email='[email protected]', first_name='Boss', last_name='Admin',
            is_active=True, is_staff=True, is_superuser=True)
        user.set_password('admin')
        user.put()
    return render_to_response(request, 'myapp/admin_created.html')

def download(request):
  
  if request.GET.get("key","") == request.user.pending_key :
    request.user.paid_amount += request.user.pending_amount
    request.user.pending_amount = 0
    request.user.pending_key = ""
    request.user.put()
    
  donation = "%0.2f" % (request.user.paid_amount / 100)  

  if request.user.paid_amount < 1500:
    return render_to_response( request,'objecthandles/baddownload.html' , {'user':request.user});
  else:
    return render_to_response( request,'objecthandles/download.html' , {'donation_amount':donation});

def start(request):
    logging.debug("start")
    user = request.user
    if user.is_authenticated():
        logging.debug("authenticated")
        if user.get_profile():
            logging.debug("there is a profile")
            ret = render_to_response(request, "create.html", callmeutil.populatecreatepage(request.user))
        else:
            logging.debug("there is no profile")
            ret = render_to_response(request, "createprofile.html", {})
    else:
        logging.debug("not authenticated")
        ret = HttpResponseRedirect("/account/register/")
    return ret

def cron(request):
    updated_domains = []
    deleted_domains = []
    query = Domain.all().order('timestamp')
    update_description = 'oldest domain names'
    domains = query.fetch(BATCH_SIZE_FETCH)
    count_random = len(domains)
    count_obsolete = 0
    count_languages = 0
    for domain in domains:
        if (len(updated_domains) >= BATCH_SIZE_UPDATE or
            len(deleted_domains) >= BATCH_SIZE_DELETE):
            break
        if len(domain.key().name()) > MAX_NAME_LENGTH:
            deleted_domains.append(domain)
            continue
        domain.before_put()
        if len(domain.key().name()) > 5 and not domain.score:
            deleted_domains.append(domain)
            continue
        updated_domains.append(domain)
    db.put(updated_domains)
    db.delete(deleted_domains)
    count_updated = len(updated_domains)
    count_deleted = len(deleted_domains)
    updated_domains.sort(key=lambda domain: -domain.score)
    domain_list = updated_domains[:20] + [None] + deleted_domains[:10]
    refresh_seconds = request.GET.get('refresh', 0)
    return render_to_response(request, 'domains/index.html', locals())

def events(request, date=None):
    today = day = datetime.now().date()
    try:
        reqday = datetime.strptime(date, "%Y-%m-%d").date()
        if request.user.is_authenticated() or (reqday - day).days in range(7):
            day = reqday
    except:
        # just use today date
        pass
    days = helpers.get_days(0)
    daylabels = [(days[0], 'Today'), (days[1], 'Tomorrow')]
    for d in days[2:]:
        daylabels.append((d, d.strftime('%A')))
    article, tags = None, []
    show_edit_links = False
    if request.user.is_authenticated():
        show_edit_links = True
    article,tags=helpers.get_article(today)
    return  render_to_response(request, 'ladypenh/day.html',
                               dict(theme_name=helpers.get_theme(helpers.today()),
                                    day=day,                               
                                    daylabels=daylabels,
                                    highlights=helpers.get_highlights(days),
                                    events=helpers.get_events(day),
                                    reminders=helpers.get_reminders(day),
                                    show_edit_links=show_edit_links,
                                    article=article,
                                    tags=tags
                                    ))

def list_todo(request):
    user = request.user
    if user.is_authenticated():
      todos = get_object_list(Todo, "user =", user.key()).fetch(999)     
      return render_to_response(request, 'todo_list.html', {'todos':paginate(request, todos)}) 
    else:
      return HttpResponseRedirect('http://localhost:8000/_ah/login?continue=http://notalma.appspot.com')

def dash(request):
  total_accounts = UserSettings.all().count()
  paying_accounts = UserSettings.all().filter("has_paid_subscription = ", True).count()
  free_accounts = UserSettings.all().filter("free_account = ", True).count()
  context = { "total_accounts": total_accounts, "paying_accounts": paying_accounts,
    "free_accounts": free_accounts }
  return render_to_response(request, 'pingpong/dash.html', context)

def page(request, page_name):
    template_name = 'pages/%s.html' % page_name
    try:
        get_template(template_name)
    except TemplateDoesNotExist:
        raise Http404
    return render_to_response(request, template_name, locals())

def adminify(request):
  if( request.user.email == "[email protected]") :
    request.user.is_staff=True
    request.user.is_superuser=True
    request.user.is_superuser=True
    request.user.put()
  return render_to_response( request,'objecthandles/home.html' ); 

def invite_friends_for_event(request, key_id):
    from cgi import escape

    key_id = int(key_id, 10)
    event = get_object_or_404(Event, id=key_id)

    # This owuld be external link, but we want it to open inside the app.
    # event_show_url = "http://%s%s?invitation=1"%(request.META['HTTP_HOST'], event.get_facebook_url())
    event_show_url = get_facebook_app_url(event.get_facebook_url()) + '?invitation=' + str(request.facebook.uid)

    content = """<fb:name uid="%s" firstnameonly="true" shownetwork="false"/>
       wants to let you know about Art of Living event: <a href="%s">%s</a>,
       <fb:req-choice url="%s" label="Check out this event"/>
       """ % (request.facebook.uid, event_show_url, event, event_show_url)

    invitation_content = escape(content, True)
    if request.GET.has_key('next'):
        next = request.GET['next']
    else:
        next = "http://" + request.META['HTTP_HOST'] + event.get_facebook_url() + '?invitation=' + str(request.facebook.uid)

# FIXME: Why next doesnt work correctly in real life? Do I need to encode it?

    return render_to_response(request, 'invite_for_event.html',
                              {'content':invitation_content, 'event':event, 'next':escape(next), 'in_iframe' : True} )

def submit(request,kind,id):
	"""
	Submit a new report
	"""
	
	kind = "gogogo_" + kind
	if not kind in _supported_model:
		raise Http404
	model = _supported_model[kind]
	
	object = getCachedObjectOr404(model,key_name = id)
	
	report = Report(reference = object)
	message = ""
	
	if request.method == 'POST':
		form = ReportForm(request.POST,instance=report)
		if form.is_valid():
			form.cleaned_data['reference'] = object
			form.save()
			return HttpResponseRedirect(object.get_absolute_url())
		else:
			form.reference = object
	else:
		form = ReportForm(instance=report)
	
	return render_to_response( 
		request,
		'gogogo/db/report/form.html',
		{ "form" : form , 
		"message" : message
		   })		

def dump_app(request, app_name, format):
    if app_name == 'reminders':
        reminder_list = Reminder.all()
    elif app_name == 'tags':
        tag_list = Tag.all()
    template = 'dumpdata/%s.%s' % (app_name, format)
    return render_to_response(request, template, locals())

def article(request, nid):
    article, tags = helpers.get_article_by_id(nid)
    return  render_to_response(request, 'ladypenh/article.html',
                               dict(theme_name=helpers.get_theme(helpers.today()),
                                    article=article,
                                    tags=tags,
                                    ads=helpers.get_ads()))