large ammount of changes, main ones:

- allow multiple instances of same question - wrong answer => new instance of question added at the end of topic - show current topic on sidebar - fixed reload crash - fixed text show previous answer if incorrect not yet working.

large ammount of changes, main ones:
- allow multiple instances of same question - wrong answer => new instance of question added at the end of topic - show current topic on sidebar - fixed reload crash - fixed text show previous answer if incorrect not yet working.
Miguel Barão
1 parent 987cf289
Showing 9 changed files with 284 additions and 247 deletions Show diff stats
BUGS.md
app.py
knowledge.py
questions.py
serve.py
templates/learn.html
templates/question-text.html
templates/question-textarea.html
templates/topics.html
 BUGS:
-- nao permite perguntas repetidas. iterar questions da configuracao em vez das do ficheiro. ver app.py linha 223.
-- pymips: activar/desactivar instruções
+- topicos no sidebar devem ser links para iniciar um topico acessivel. os inacessiveis devem estar inactivos.
 - tabs em textarea nao funcionam correctamente (insere 1 espaco em vez de 4)
 - reportar comentarios após submeter.
-- logs debug mostrar user
-- logs mostrar fim de topico
-- textarea, text devem mostrar no html os valores iniciais de ans, se existir
+- textarea deve mostrar no html os valores iniciais de ans, se existir
 - detect questions in questions.yaml without ref -> error ou generate default.
 - error if demo.yaml has no topics
-- reload da página rebenta o estado.
 - guardar state cada vez que topico termina
-- indicar o topico actual no sidebar
 - session management. close after inactive time.
 - implementar xsrf. Ver [http://www.tornadoweb.org/en/stable/guide/security.html#cross-site-request-forgery-protection]()
 - titulos das perguntas não suportam markdown
 TODO:
-- implementar http com redirect para https.
-- topicos no sidebar devem ser links para iniciar um topico acessivel. os inacessiveis devem estar inactivos.
+- pymips: activar/desactivar instruções
+- implementar servidor http com redirect para https.
 - usar codemirror no textarea
-- mostrar comments quando falha a resposta
 - generators not working: bcrypt (ver blog)
 FIXED:
+- logs inicio de topico
+- indicar o topico actual no sidebar
+- reload da página rebenta o estado.
+- text deve mostrar no html os valores iniciais de ans, se existir
+- nao permite perguntas repetidas. iterar questions da configuracao em vez das do ficheiro. ver app.py linha 223.
 - level depender do numero de respostas correctas
 - pymips a funcionar
 - logs mostram que está a gerar cada pergunta 2 vezes...??
@@ -37,8 +37,8 @@ class LearnApp(object):
         # online students
         self.online = {}
-        # build dependency graph
-        self.build_dependency_graph(conffile)
+        self.depgraph = build_dependency_graph(conffile)
+
         # connect to database and check registered students
         self.db_setup(self.depgraph.graph['database'])
@@ -62,6 +62,7 @@ class LearnApp(object):
                 return False    # wrong password
             # success
+            logger.info(f'User "{uid}" logged in')
             tt = s.query(StudentTopic).filter(StudentTopic.student_id == uid)
             state = {}
@@ -76,7 +77,6 @@ class LearnApp(object):
                 'number': student.id,
                 'state': Knowledge(self.depgraph, state=state, student=student.id)
             }
-            logger.info(f'User "{uid}" logged in')
             return True
     # ------------------------------------------------------------------------
@@ -124,115 +124,23 @@ class LearnApp(object):
         return True
     # ------------------------------------------------------------------------
-    def get_student_name(self, uid):
-        return self.online[uid].get('name', '')
-
-    # ------------------------------------------------------------------------
-    def get_student_state(self, uid):
-        return self.online[uid]['state'].get_knowledge_state()
-
-    # ------------------------------------------------------------------------
-    def get_student_progress(self, uid):
-        return self.online[uid]['state'].get_topic_progress()
-
-    # ------------------------------------------------------------------------
-    def get_student_question(self, uid):
-        return self.online[uid]['state'].get_current_question()     # dict
-
-    # ------------------------------------------------------------------------
-    def get_title(self):
-        return self.depgraph.graph['title']
-
-    # ------------------------------------------------------------------------
-    def get_topic_name(self, ref):
-        return self.depgraph.node[ref]['name']
-
-    # ------------------------------------------------------------------------
-    def get_current_public_dir(self, uid):
-        topic = self.online[uid]['state'].get_current_topic()
-        p = self.depgraph.graph['path']
-        return path.join(p, topic, 'public')
-
-    # ------------------------------------------------------------------------
     # check answer and if correct returns new question, otherwise returns None
     # ------------------------------------------------------------------------
     def check_answer(self, uid, answer):
         knowledge = self.online[uid]['state']
-        current_question = knowledge.check_answer(answer)
+        q = knowledge.check_answer(answer)
-        if current_question is not None:
-            logger.debug('check_answer: saving answer to db ...')
-            with self.db_session() as s:
-                s.add(Answer(
-                    ref=current_question['ref'],
-                    grade=current_question['grade'],
-                    starttime=str(current_question['start_time']),
-                    finishtime=str(current_question['finish_time']),
-                    student_id=uid))
-                s.commit()
-
-        return knowledge.new_question()
-
-    # ------------------------------------------------------------------------
-    # Given configuration file, loads YAML on that file and builds the graph.
-    # First, topics such as `computer/mips/exceptions` are added as nodes
-    # together with dependencies. Then, questions are loaded to a factory.
-    # ------------------------------------------------------------------------
-    def build_dependency_graph(self, config_file):
-
-        # Load configuration file to a dict
-        try:
-            with open(config_file, 'r') as f:
-                config = yaml.load(f)
-        except FileNotFoundError:
-            logger.critical(f'File not found: "{config_file}"')
-            raise LearnAppException
-        except yaml.scanner.ScannerError as err:
-            logger.critical(f'Parsing YAML file "{config_file}": {err}')
-            raise LearnAppException
-        else:
-            logger.info(f'Configuration file "{config_file}"')
-
-        # create graph
-        prefix = config.get('path', '.')
-        title = config.get('title', '')
-        database = config.get('database', 'students.db')
-        g = nx.DiGraph(path=prefix, title=title, database=database)
-
-        # iterate over topics and build graph
-        topics = config.get('topics', {})
-        for ref,attr in topics.items():
-            g.add_node(ref)
-            if isinstance(attr, dict):
-                g.node[ref]['name'] = attr.get('name', ref)
-                g.node[ref]['questions'] = attr.get('questions', [])
-                g.add_edges_from((d,ref) for d in attr.get('deps', []))
-
-        # iterate over topics and create question factories
-        logger.info('Loading:')
-        for ref in g.nodes_iter():
-            fullpath = path.expanduser(path.join(prefix, ref))
-            filename = path.join(fullpath, 'questions.yaml')
-
-            loaded_questions = load_yaml(filename, default=[])
-
-            # make dict from list of questions for easier selection
-            qdict = {q['ref']: q for q in loaded_questions}
-
-            # 'questions' not provided in configuration means load all
-            if not g.node[ref]['questions']:
-                g.node[ref]['questions'] = qdict.keys() #[q['ref'] for q in loaded_questions]
-
-            g.node[ref]['factory'] = []
-            for qref in g.node[ref]['questions']:
-                q = qdict[qref]
-                q['path'] = fullpath
-                g.node[ref]['factory'].append(QFactory(q))
+        with self.db_session() as s:
+            s.add(Answer(
+                ref=q['ref'],
+                grade=q['grade'],
+                starttime=str(q['start_time']),
+                finishtime=str(q['finish_time']),
+                student_id=uid))
+            s.commit()
-            logger.info(f'  {len(g.node[ref]["factory"])} questions from "{ref}"')
+        return q['grade']
-        self.depgraph = g
-        return g
     # ------------------------------------------------------------------------
     # Fill db table 'Topic' with topics from the graph if not already there.
@@ -274,3 +182,113 @@ class LearnApp(object):
         finally:
             session.close()
+
+
+    # ========================================================================
+    # methods that do not change state (pure functions)
+    # ========================================================================
+
+
+    # ------------------------------------------------------------------------
+    def get_student_name(self, uid):
+        return self.online[uid].get('name', '')
+
+    # ------------------------------------------------------------------------
+    def get_student_state(self, uid):
+        return self.online[uid]['state'].get_knowledge_state()
+
+    # ------------------------------------------------------------------------
+    def get_student_progress(self, uid):
+        return self.online[uid]['state'].get_topic_progress()
+
+    # ------------------------------------------------------------------------
+    def get_student_question(self, uid):
+        return self.online[uid]['state'].get_current_question()     # dict
+
+    # ------------------------------------------------------------------------
+    def get_student_topic(self, uid):
+        return self.online[uid]['state'].get_current_topic()        # str
+
+    # ------------------------------------------------------------------------
+    def get_title(self):
+        return self.depgraph.graph['title']
+
+    # ------------------------------------------------------------------------
+    def get_topic_name(self, ref):
+        return self.depgraph.node[ref]['name']
+
+    # ------------------------------------------------------------------------
+    def get_current_public_dir(self, uid):
+        topic = self.online[uid]['state'].get_current_topic()
+        p = self.depgraph.graph['path']
+        return path.join(p, topic, 'public')
+
+
+
+# ============================================================================
+# Given configuration file, loads YAML on that file and builds a digraph.
+# First, topics such as `computer/mips/exceptions` are added as nodes
+# together with dependencies. Then, questions are loaded to a factory.
+#
+#   g.graph['path']         base path where topic directories are located
+#   g.graph['title']        title defined in the configuration YAML
+#   g.graph['database']     sqlite3 database file to use
+#
+# Nodes are the topic references e.g. 'my/topic'
+#   g.node['my/topic']['name']      name of the topic
+#   g.node['my/topic']['questions'] list of question refs defined in YAML
+#   g.node['my/topic']['factory']   dict with question factories
+# ----------------------------------------------------------------------------
+def build_dependency_graph(config_file):
+
+    # Load configuration file to a dict
+    try:
+        with open(config_file, 'r') as f:
+            config = yaml.load(f)
+    except FileNotFoundError:
+        logger.critical(f'File not found: "{config_file}"')
+        raise LearnAppException
+    except yaml.scanner.ScannerError as err:
+        logger.critical(f'Parsing YAML file "{config_file}": {err}')
+        raise LearnAppException
+    else:
+        logger.info(f'Configuration file "{config_file}"')
+
+    # create graph
+    prefix = config.get('path', '.')
+    title = config.get('title', '')
+    database = config.get('database', 'students.db')
+    g = nx.DiGraph(path=prefix, title=title, database=database)
+
+    # iterate over topics and build graph
+    topics = config.get('topics', {})
+    for ref,attr in topics.items():
+        g.add_node(ref)
+        if isinstance(attr, dict):
+            g.node[ref]['name'] = attr.get('name', ref)
+            g.node[ref]['questions'] = attr.get('questions', [])
+            g.add_edges_from((d,ref) for d in attr.get('deps', []))
+
+    # iterate over topics and create question factories
+    logger.info('Loading:')
+    for tref in g.nodes_iter():
+        tnode = g.node[tref]  # current node (topic)
+        fullpath = path.expanduser(path.join(prefix, tref))
+        filename = path.join(fullpath, 'questions.yaml')
+
+        loaded_questions = load_yaml(filename, default=[])
+
+        # if questions not in configuration then load all, preserve order
+        if not tnode['questions']:
+            tnode['questions'] = [q['ref'] for q in loaded_questions]
+
+        # make questions factory (without repeting same question)
+        tnode['factory'] = {}
+        for q in loaded_questions:
+            if q['ref'] in tnode['questions']:
+                q['path'] = fullpath
+                tnode['factory'][q['ref']] = QFactory(q)
+
+        logger.info(f'  {len(tnode["questions"])} questions from "{tref}"')
+
+    return g
@@ -17,41 +17,87 @@ logger = logging.getLogger(__name__)
 # kowledge state of each student....??
 # ----------------------------------------------------------------------------
 class Knowledge(object):
+    # =======================================================================
+    # methods that update state
+    # =======================================================================
+
     def __init__(self, depgraph, state={}, student=''):
         self.depgraph = depgraph
         self.state = state # {'topic_id': {'level':0.5, 'date': datetime}, ...}
         self.student = student
-        # compute recommended sequence of topics (FIXME)
+        # compute recommended sequence of topics  ['a', 'b',...]
         self.topic_sequence = nx.topological_sort(self.depgraph)
-        # select a topic to do
-        self.new_topic()
+        print(self.topic_sequence)
+        print(self.depgraph.edges())
+
+        # select a topic to do and initialize questions
+        self.start_topic()
     # ------------------------------------------------------------------------
     # Start a new topic. If not provided, selects the first with level < 0.8
     # If all levels > 0.8, will stay in the last one forever...
     # ------------------------------------------------------------------------
-    def new_topic(self, topic=None):
+    def start_topic(self, topic=None):
         if topic is None:
             for topic in self.topic_sequence:
-                if topic not in self.state or self.state[topic]['level'] < 0.8:
+                unlocked = topic in self.state
+                needs_work = unlocked and self.state[topic]['level'] < 0.8
+                factory = self.depgraph.node[topic]['factory']
+                if needs_work and factory:
                     break
-
-        logger.info(f'Student {self.student} new topic "{topic}"')
+                # logger.info(f'{self.student} skipped topic "{topic}"')
+        else:
+            factory = self.depgraph.node[topic]['factory']
+            # FIXME if factory is empty???
         self.current_topic = topic
-        # self.current_topic_idx = self.topic_sequence.index(topic)
-        self.questions = self.generate_questions_for_topic(topic)
-        self.current_question = None
+        logger.info(f'User "{self.student}" topic set to "{topic}"')
+
+        # generate question instances for current topic
+        questionlist = self.depgraph.node[topic]['questions']
+        factory = self.depgraph.node[topic]['factory']
+        self.questions = [factory[qref].generate() for qref in questionlist]
+
+        self.current_question = self.questions.pop(0)
+        self.current_question['start_time'] = datetime.now()
         self.finished_questions = []
-        self.correct_answers = 1
-        self.wrong_answers = 0
     # ------------------------------------------------------------------------
-    def generate_questions_for_topic(self, topic):
-        factory = self.depgraph.node[topic]['factory']
-        return [q.generate() for q in factory]
+    # returns the current question with correction, time and comments updated
+    # ------------------------------------------------------------------------
+    def check_answer(self, answer):
+        q = self.current_question
+        q['finish_time'] = datetime.now()
+        grade = q.correct(answer)
+        logger.debug(f'User {self.student}: grade = {grade}')
+
+        # new question if answer is correct
+        if grade > 0.999:
+            self.finished_questions.append(q)
+            try:
+                self.current_question = self.questions.pop(0) # FIXME empty?
+            except IndexError:
+                self.current_question = None
+                self.state[self.current_topic] = {
+                    'level': 1.0,
+                    'date': datetime.now()
+                }
+            else:
+                self.current_question['start_time'] = datetime.now()
+        else:
+            # FIXME debug this
+            factory = self.depgraph.node[self.current_topic]['factory']
+            self.questions.append(factory[q['ref']].generate())
+            print([q['ref'] for q in self.questions])
+
+        return q
+
+
+    # ========================================================================
+    # pure functions of the state (no side effects)
+    # ========================================================================
     # ------------------------------------------------------------------------
     def get_current_question(self):
@@ -62,8 +108,8 @@ class Knowledge(object):
         return self.current_topic
     # ------------------------------------------------------------------------
-    def get_knowledge_state(self):
-        ts = []   # FIXME why list??
+    def get_knowledge_state(self):  # [('topic', 0.9), ...]
+        ts = []
         for t in self.topic_sequence:
             if t in self.state:
                 ts.append((t, self.state[t]['level']))
@@ -73,44 +119,5 @@ class Knowledge(object):
     # ------------------------------------------------------------------------
     def get_topic_progress(self):
-        return len(self.finished_questions) / (len(self.finished_questions) + len(self.questions))
-
-    # ------------------------------------------------------------------------
-    # if answer to current question is correct generates a new question
-    # otherwise returns None
-    def new_question(self):
-        if self.current_question is None or \
-            self.current_question.get('grade', 0.0) > 0.9:
-
-            # if no more questions in this topic, go to the next one
-            # keep going if there are no questions in the next topics
-            while not self.questions:
-                self.state[self.current_topic] = {
-                    'level': self.correct_answers / (self.correct_answers + self.wrong_answers),
-                    'date': datetime.now()
-                }
-                self.new_topic()
-
-            self.current_question = self.questions.pop(0)
-            self.current_question['start_time'] = datetime.now()
-            self.finished_questions.append(self.current_question)
-
-            logger.debug(f'Student {self.student}: new_question({self.current_question["ref"]})')
-            return self.current_question
-
-    # ------------------------------------------------------------------------
-    # returns the current question with correction, time and comments updated
-    # ------------------------------------------------------------------------
-    def check_answer(self, answer):
-        question = self.current_question
-        if question is not None:
-            question['finish_time'] = datetime.now()
-            grade = question.correct(answer)
-            if grade > 0.9:
-                self.correct_answers += 1
-            else:
-                self.wrong_answers +=1
-
-            logger.debug(f'Student {self.student}: check_answer({answer}) = {grade}')
+        return len(self.finished_questions) / (1 + len(self.finished_questions) + len(self.questions))
-        return question
@@ -416,20 +416,11 @@ class QFactory(object):
         # which will print a valid question in yaml format to stdout. This
         # output is then yaml parsed into a dictionary `q`.
         if q['type'] == 'generator':
-            logger.debug(f'Running script "{q["script"]}"...')
+            logger.debug(f' \_ Running script "{q["script"]}"...')
             q.setdefault('arg', '') # optional arguments will be sent to stdin
             script = path.join(q['path'], q['script'])
             out = run_script(script=script, stdin=q['arg'])
             q.update(out)
-            # try:
-            #     q.update(out)
-            # except:
-            #     logger.error(f'Question generator "{q["ref"]}"')
-            #     q.update({
-            #         'type': 'alert',
-            #         'title': 'Erro interno',
-            #         'text': 'Ocorreu um erro a gerar esta pergunta.'
-            #         })
         # Finally we create an instance of Question()
         try:
@@ -160,70 +160,68 @@ class QuestionHandler(BaseHandler):
         # 'alert':      '', FIXME
     }
-    @tornado.web.authenticated
-    def get(self):
-        user = self.current_user
-        state = self.learn.get_student_state(user)  # all topics
+    def new_question(self, user):
+        state = self.learn.get_student_state(user)  # all topics [('a', 0.1), ...]
+        current_topic = self.learn.get_student_topic(user) # str
         progress = self.learn.get_student_progress(user) # float
-        question = self.learn.get_current_question(user)
-        print(question)  # FIXME cant get current question
+        question = self.learn.get_student_question(user) # dict?
+
+        question_html = self.render_string(self.templates[question['type']],question=question, md=md)
+        topics_html = self.render_string('topics.html', state=state, current_topic=current_topic, gettopicname=self.learn.get_topic_name)
+
+        return {
+            'method': 'new_question',
+            'params': {
+                'question': tornado.escape.to_unicode(question_html),
+                'state': tornado.escape.to_unicode(topics_html),
+                'progress': progress,
+                }
+            }
+
+    def shake(self, user):
+        progress = self.learn.get_student_progress(user)  # in the current topic
+        return {
+            'method': 'shake',
+            'params': {
+                'progress': progress,
+                }
+            }
+
+    def finished_topic(self, user):
+        state = self.learn.get_student_state(user)        # all topics
+        current_topic = self.learn.get_student_topic(uid)
-        question_html = self.render_string(
-            self.templates[question['type']],
-            question=question,      # dictionary with the question
-            md=md,                  # function that renders markdown to html
-            )
         topics_html = self.render_string('topics.html',
             state=state,
+            current_topic=current_topic,
             topicname=self.learn.get_topic_name,    # translate ref to names
             )
-        print(topics_html)
-        print(question_html)
-        self.write({
-            'method': 'new_question',
+        return {
+            'method': 'finished_topic',
             'params': {
-                'question': tornado.escape.to_unicode(question_html),
                 'state': tornado.escape.to_unicode(topics_html),
-                'progress': progress,
                 }
-            })
+            }
-    # posting can change state and return new question
+    @tornado.web.authenticated
+    def get(self):
+        self.write(self.new_question(self.current_user))
+
+    # handles answer posted
     @tornado.web.authenticated
     def post(self):
         user = self.current_user
         answer = self.get_body_arguments('answer')
-        next_question = self.learn.check_answer(user, answer)
-        state = self.learn.get_student_state(user)  # all topics
-        progress = self.learn.get_student_progress(user) # in the current topic
-
-        if next_question is not None:
-            question_html = self.render_string(
-                self.templates[next_question['type']],
-                question=next_question, # dictionary with the question
-                md=md,                  # function that renders markdown to html
-                )
-            topics_html = self.render_string(
-                'topics.html',
-                state=state,
-                topicname=self.learn.get_topic_name,    # function that translates topic references to names
-                )
-
-            self.write({
-                'method': 'new_question',
-                'params': {
-                    'question': tornado.escape.to_unicode(question_html),
-                    'state': tornado.escape.to_unicode(topics_html),
-                    'progress': progress,
-                    },
-                })
+        grade = self.learn.check_answer(user, answer)
+        question = self.learn.get_student_question(user)  # same, new or None
+
+        if question is None:
+            self.write(self.finished_topic(user))
+        elif grade > 0.999:
+            self.write(self.new_question(user))
         else:
-            self.write({
-                'method': 'shake',
-                'params': {
-                    'progress': progress,
-                    },
-                })
+            self.write(self.shake(user))
+
 # ----------------------------------------------------------------------------
 def main():
@@ -262,15 +260,15 @@ def main():
         })
     http_server.listen(8443)
-    # --- start webserver
+    # --- run webserver
     logging.info('Webserver running...')
+
     try:
-        tornado.ioloop.IOLoop.current().start()
-        # running...
+        tornado.ioloop.IOLoop.current().start()  # running...
     except KeyboardInterrupt:
         tornado.ioloop.IOLoop.current().stop()
-    finally:
-        logging.critical('Webserver stopped.')
+
+    logging.critical('Webserver stopped.')
 # ----------------------------------------------------------------------------
 if __name__ == "__main__":
@@ -153,7 +153,7 @@ $.fn.extend({
     }
 });
-// Processes the response given by the server after an answer is submitted.
+// Process the response given by the server
 function updateQuestion(response){
     switch (response["method"]) {
     case "new_question":
@@ -194,12 +194,20 @@ function updateQuestion(response){
         // audio.play();
         $('#question_div').animateCSS('zoomIn');
         break;
+
     case "shake":
         // var audio = new Audio('/static/sounds/wrong.mp3');
         // audio.play();
         $('#topic_progress').css('width', (100*response["params"]["progress"])+'%').attr('aria-valuenow', 100*response["params"]["progress"]);
         $('#question_div').animateCSS('shake');
         break;
+
+    case "finished_topic":
+        $('#topic_progress').css('width', '100%').attr('aria-valuenow', 100);
+        $("#topics").html(response["params"]["state"]);
+
+        $("#question_div").html('<img src="/static/trophy.png" alt="trophy" class="img-rounded img-responsive center-block">');  // FIXME size
+        break;
     }
 }
@@ -217,14 +225,12 @@ function postQuestion() {
     });
 }
-// Send answer and receive a response.
-// The response can be a new_question or a shake if the answer is wrong.
+// Get current question
 function getQuestion() {
     $.ajax({
         // type: "GET",
         url: "/question",
         // headers: {"X-XSRFToken": token},
-        // data: $("#question_form").serialize(), // {'a':10,'b':20},
         dataType: "json", // expected from server
         success: updateQuestion,
         error: function() {alert("O servidor não responde.");}
@@ -2,7 +2,11 @@
 {% block answer %}
 <fieldset data-role="controlgroup">
-    <input type="text" class="form-control" id="answer" name="answer" value="{{ question['answer'] or '' }}" autofocus>
+    {% if question['answer'] %}
+        <input type="text" class="form-control" id="answer" name="answer" value="{{ question['answer'][0] }}" autofocus>
+    {% else %}
+        <input type="text" class="form-control" id="answer" name="answer" value="" autofocus>
+    {% end %}
 </fieldset><br />
 <input type="hidden" name="question_ref" value="{{ question['ref'] }}">
 {% end %}
 {% extends "question.html" %}
 {% block answer %}
+
 <textarea class="form-control" rows="{{ question['lines'] }}" name="answer" autofocus>{{ question['answer'] or '' }}</textarea><br />
 <input type="hidden" name="question_ref" value="{{ question['ref'] }}">
+
 {% end %}
@@ -4,10 +4,22 @@
 <ul class="nav nav-pills nav-stacked">
     {% for t in state %}
-    <li role="presentation" class="disabled">    <!-- class="active" -->
-        <a href="#" class="disabled">{{ topicname(t[0]) }}<br>
-        {{ round(t[1]*5)*'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]*5)*'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
-        </a>
-    </li>
+
+        {% if t[0] == current_topic %}
+        <li class="active">    <!-- class="active" class="disabled" -->
+
+            <a> {{ gettopicname(t[0]) }}<br>
+            {{ round(t[1]*5)*'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]*5)*'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
+            </a>
+
+        {% else %}
+        <li>    <!-- class="active" class="disabled" -->
+
+            <a href="#"> {{ gettopicname(t[0]) }}<br>
+            {{ round(t[1]*5)*'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]*5)*'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
+            </a>
+
+        {% end %}
+        </li>
     {% end %}
-</ul>
 \ No newline at end of file
+</ul>
1	{% extends "question.html" %}	1	{% extends "question.html" %}
2		2
3	{% block answer %}	3	{% block answer %}
		4	+
4	<textarea class="form-control" rows="{{ question['lines'] }}" name="answer" autofocus>{{ question['answer'] or '' }}</textarea><br />	5	<textarea class="form-control" rows="{{ question['lines'] }}" name="answer" autofocus>{{ question['answer'] or '' }}</textarea><br />
5	<input type="hidden" name="question_ref" value="{{ question['ref'] }}">	6	<input type="hidden" name="question_ref" value="{{ question['ref'] }}">
		7	+
6	{% end %}	8	{% end %}
	@@ -4,10 +4,22 @@		@@ -4,10 +4,22 @@
4		4
5	<ul class="nav nav-pills nav-stacked">	5	<ul class="nav nav-pills nav-stacked">
6	{% for t in state %}	6	{% for t in state %}
7	- <li role="presentation" class="disabled"> <!-- class="active" -->
8	- <a href="#" class="disabled">{{ topicname(t[0]) }}<br>
9	- {{ round(t[1]5)'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]5)'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
10	- </a>
11	- </li>	7	+
		8	+ {% if t[0] == current_topic %}
		9	+ <li class="active"> <!-- class="active" class="disabled" -->
		10	+
		11	+ <a> {{ gettopicname(t[0]) }}<br>
		12	+ {{ round(t[1]5)'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]5)'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
		13	+ </a>
		14	+
		15	+ {% else %}
		16	+ <li> <!-- class="active" class="disabled" -->
		17	+
		18	+ <a href="#"> {{ gettopicname(t[0]) }}<br>
		19	+ {{ round(t[1]5)'<i class="fa fa-star text-success" aria-hidden="true"></i>' + round(5-t[1]5)'<i class="fa fa-star-o" aria-hidden="true"></i>' }}
		20	+ </a>
		21	+
		22	+ {% end %}
		23	+ </li>
12	{% end %}	24	{% end %}
13	-</ul>
14	\ No newline at end of file	25	\ No newline at end of file
		26	+</ul>