Python utilities.render_template函数代码示例

    def render(self):
        if self.debug:
            return render_template('index_debug.html',
                                   lti_dump=g.lti.dump_all())
        if g.lti.is_instructor():
            return render_template('index_instructor.html')

        return render_template('index_student.html')

 def answerQuestion(self, uID, qID, qText, timerD, questionStartTime):
     if answer.AnswerModel.check_answer_exists(uID, qID):
         aID = answer.AnswerModel.get_answer_id(uID, qID)
         if self.timeLeft(timerD, questionStartTime):
             return render_template('answer.html', questionID=qID, userID=uID, questionText=qText, timerDuration=timerD, date=time.mktime(questionStartTime.timetuple()), go="true")
         else:
             return render_template('answer.html', questionID=qID, userID=uID, questionText=qText, timerDuration=timerD, date=time.mktime(questionStartTime.timetuple()), go="false")
     else:
         #answer.AnswerModel.save(qID, uID, "")
         return render_template('answer.html', questionID=qID, userID=uID, questionText=qText, timerDuration=timerD, date=time.mktime(questionStartTime.timetuple()), go="true")

    def render(self):
        if self.debug:
            return render_template('index_debug.html',
                                   lti_dump=g.lti.dump_all())
        if g.lti.is_instructor():
            return render_template('question_list.html')
        else:
            UserModel.save(g.lti.get_user_id(), g.lti.get_user_name())

        return render_template('index_student.html')

 def get_list_asked():
    """Retrieves questions asked by the user currently logged in."""
    if g.lti.is_instructor():
        # TODO: pagination, etc..... same goes for get_questions
        session.commit()
        return render_template('question_list.html',
                               questions=session.query(Question).filter_by(user_id=g.lti.get_user_id()  ) )
    else:
        session.commit()
        return render_template('question_list.html',
                               questions=session.query(Question).filter_by(user_id=g.lti.get_user_id()  ) )

    def get_list_to_answer():
     """Retrieves questions to be answered by the instructor (all questions )"""
     if g.lti.is_instructor():
         # TODO: pagination, etc..... same goes for get_questions
         session.commit()
         return render_template('answer_student_questions.html',
                                questions=session.query(Question).\
                                    filter(Question.course_id == g.lti.get_course_id() ).\
                                    filter(Question.course_id != g.lti.get_user_id() ))         #Filter questions by instructor

     #Only instructors can answer these questions
     else:
         return render_template('access_restricted.html')

 def renderanswerform():
     try:
         questionid = int(request.values['question_id'])
         question = Question.by_id(questionid)
     except:
         return abort(404)
     return render_template('student_answer.html', question = question)

    def post(self):
        t_values = {}
        current_link_id = self.request.POST['current_link_id']
        link_title = self.request.POST['link_title']
        link_target = self.request.POST['link_target']
        link_sequence = self.request.POST['link_sequence']
        logging.info("LinkManager post: current_link_id = %s, link_title = %s, link_target = %s, link_sequence = %s" % (current_link_id, link_title, 'link_target', 'link_sequence'))

        if current_link_id:
            # edit existed link
            link = Link.get_by_id(long(current_link_id))
            link.title = link_title
            link.target = link_target
            link.sequence = long(link_sequence)
            link.put()
            t_values['alert_message'] = "link %s has been updated" % (link.title)
        else:
            # create new link
            link = Link(title=link_title, target=link_target, sequence=long(link_sequence))
            link.put()
            t_values['alert_message'] = "link %s has been added" % (link.title)

        # find all links
        links = Link.all().order("-date")
        t_values["links"] = links
        return self.response.out.write(render_template("links.html", t_values, "", True))

    def get(self, page_slug=""):
        if page_slug:
            t_values = {}

            posts = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').filter("slug =", page_slug)
            if posts.count() == 1:
                logging.warning("find one page with slug=%s" % (page_slug))
                posts = posts.fetch(limit=1)
                post = posts[0]
                t_values['post'] = post
                # dump(post)

                # find all comments
                comments = Comment.all().filter("entry =", post).order("date")
                t_values['comments'] = comments
            else:
                logging.warning("%d entries share the same slug %s" % (posts.count(), page_slug))

            links = Link.all().order("date")
            t_values['links'] = links

            categories = Category.all()
            t_values['categories'] = categories

            pages = Entry.all().filter("is_external_page =", True).filter("entrytype =", 'page').order("date")
            t_values['pages'] = pages

            return self.response.out.write(render_template("page.html", t_values, "basic", False))
        else:
            self.redirect(uri_for("weblog.index"))

    def get(self, page_id="", operation=""):
        t_values = {}
        logging.info("PageManager get: page_id = %s, operation = %s" % (page_id, operation))

        # find current_post based on page_id
        if page_id:
            current_post = Entry.get_by_id(long(page_id))
            if current_post:
                logging.info("find post %s from post id %s" % (page_id, current_post.title))
                if operation == "edit":
                    t_values['current_post'] = current_post
                elif operation == "publish":
                    current_post.is_external_page = True
                    current_post.put()
                    t_values['alert_message'] = "Post %s has been changed to public" % (current_post.title)
                elif operation == "unpublish":
                    current_post.is_external_page = False
                    current_post.put()
                    t_values['alert_message'] = "Post %s has been changed to private" % (current_post.title)
                elif operation == "delete":
                    current_post.delete()
                    t_values['alert_message'] = "Post %s has been changed to deleted" % (current_post.title)

        # show all posts
        posts = Entry.all().filter("entrytype =", 'page')
        t_values['posts'] = posts
        return self.response.out.write(render_template("pages.html", t_values, "", True))

 def get_list():
     questions = Question.get_filtered()
     for question in questions:
         if question is not None and question.activate_time is not None:
             if question.get_time_left() < 0:
                 question.answerable = False
     session.commit()
     return render_template('question_list.html', questions=questions)

 def saveReviewAnswer(self):
     questionID = int(self.request.form['questionID'])
     userID = self.request.form['userID']
     reviewAnswer = self.request.form['reviewAnswer']
     edit = int(self.request.form['edit'])
     answer.AnswerModel.savereview(
         questionID, userID, reviewAnswer, edit)
     return render_template('answersaved.html', flag='true')

def import_data():
    if 'file' not in request.files or not request.files['file']:
        return render_template('error.html', error="No file given.")

    #answers = request.form.get('answers', False) == 'on'
    data = request.files['file'].read()
    data = yaml.load(data)
    return Question.import_course(g.lti.get_user_id(), g.lti.get_course_id(),
                                  data)  #, answers)

    def get_list_table(limit,offset):
        (questions, curpage, maxpages, startpage, pagecount) = Question.get_filtered_offset(limit,offset,orderby='created')
        
        for question in questions:
            if question is not None and question.activate_time is not None:
                if question.get_time_left() < 0:         
                    question.answerable = False
        session.commit()

        return render_template('question_list_tbl.html', questions=questions,
                currentpage=curpage,startpage=startpage,pagecount=pagecount,maxpages=maxpages)

    def render_filtered_by_questionid(self,questionid):
        postdata = self.request.form
        args = {"questionID": questionid}

        if self.request.method == "POST":
            if "userID" in postdata and len(postdata["userID"]) > 0:
                args["userID"] = postdata["userID"]
            if "id" in postdata and len(postdata["id"]) > 0:
                args["id"] = postdata["id"]

        return render_template('answerfilter_by_questionid.html', answers=answer.AnswerModel.get_filtered(**args))

def get_pagination():
    curpage = int(request.args['currentpage'])
    startpage = int(request.args['startpage'])
    pagecount = int(request.args['pagecount'])
    maxpages = int(request.args['maxpages'])

    return render_template('pagination.html',
                           currentpage=curpage,
                           startpage=startpage,
                           pagecount=pagecount,
                           maxpages=maxpages)