def get(self, exploration_id):
"""Populates the data on the individual exploration page."""
# TODO(sll): Maybe this should send a complete state machine to the
# frontend, and all interaction would happen client-side?
exploration = Exploration.get(exploration_id)
init_state = exploration.init_state.get()
params = self.get_params(init_state)
init_html, init_widgets = parse_content_into_html(
init_state.content, 0, params)
interactive_widget_html = InteractiveWidget.get_raw_code(
init_state.widget.widget_id,
params=utils.parse_dict_with_params(
init_state.widget.params, params)
)
self.values.update({
'block_number': 0,
'interactive_widget_html': interactive_widget_html,
'interactive_params': init_state.widget.params,
'oppia_html': init_html,
'params': params,
'state_id': init_state.id,
'title': exploration.title,
'widgets': init_widgets,
})
if init_state.widget.widget_id in DEFAULT_ANSWERS:
self.values['default_answer'] = (
DEFAULT_ANSWERS[init_state.widget.widget_id])
self.response.write(json.dumps(self.values))
EventHandler.record_exploration_visited(exploration_id)
EventHandler.record_state_hit(exploration_id, init_state.id)
def reload_demos():
"""Reload the default widgets, then reload the default explorations."""
Widget.delete_all_widgets()
InteractiveWidget.load_default_widgets()
NonInteractiveWidget.load_default_widgets()
Exploration.delete_demo_explorations()
Exploration.load_demo_explorations()
def post(self, widget_id):
"""Handles POST requests, for parameterized widgets."""
payload = json.loads(self.request.get('payload'))
logging.info(payload)
params = payload.get('params', {})
if isinstance(params, list):
new_params = {}
for item in params:
new_params[item['name']] = item['default_value']
params = new_params
state_params_dict = {}
state_params_given = payload.get('state_params')
if state_params_given:
for param in state_params_given:
# Pick a random parameter for each key.
state_params_dict[param['name']] = (
utils.get_random_choice(param['values']))
response = InteractiveWidget.get_with_params(
widget_id, params=utils.parse_dict_with_params(
params, state_params_dict)
)
self.response.write(json.dumps({'widget': response}))
def get_state_for_frontend(state, exploration):
"""Returns a representation of the given state for the frontend."""
state_repr = state.as_dict()
modified_state_dict = state.internals_as_dict(human_readable_dests=True)
# TODO(sll): The following is for backwards-compatibility and should be
# deleted later.
rules = {}
for handler in state_repr['widget']['handlers']:
rules[handler['name']] = handler['rules']
for item in rules[handler['name']]:
item['attrs'] = {'classifier': item['name']}
if item['name'] == 'Default':
item['rule'] = 'Default'
else:
item['rule'] = InteractiveWidget.get(
state.widget.widget_id).get_readable_name(
handler['name'], item['name']
)
state_repr['widget']['rules'] = rules
state_repr['widget']['id'] = state_repr['widget']['widget_id']
state_repr['widget']['sticky'] = state_repr['widget']['sticky']
state_repr['yaml'] = utils.yaml_from_dict(modified_state_dict)
return state_repr
def post(self, exploration_id, state_id):
"""Handles feedback interactions with readers."""
values = {'error': []}
exploration = Exploration.get(exploration_id)
state = State.get(state_id, exploration)
old_state = state
payload = json.loads(self.request.get('payload'))
# The 0-based index of the last content block already on the page.
block_number = payload.get('block_number')
params = self.get_params(state, payload.get('params'))
# The reader's answer.
answer = payload.get('answer')
# Add the reader's answer to the parameter list. This must happen before
# the interactive widget is constructed.
params['answer'] = answer
interactive_widget_properties = (
InteractiveWidget.get_with_params(
state.widget.widget_id)['actions']['submit'])
dest_id, feedback, rule, recorded_answer = state.transition(
answer, params, interactive_widget_properties)
if recorded_answer:
EventHandler.record_rule_hit(
exploration_id, state_id, rule, recorded_answer)
# Add this answer to the state's 'unresolved answers' list.
if recorded_answer not in old_state.unresolved_answers:
old_state.unresolved_answers[recorded_answer] = 0
old_state.unresolved_answers[recorded_answer] += 1
# TODO(sll): Make this async?
old_state.put()
assert dest_id
html_output, widget_output = '', []
# TODO(sll): The following is a special-case for multiple choice input,
# in which the choice text must be displayed instead of the choice
# number. We might need to find a way to do this more generically.
if state.widget.widget_id == 'MultipleChoiceInput':
answer = state.widget.params['choices'][int(answer)]
# Append reader's answer.
values['reader_html'] = feconf.JINJA_ENV.get_template(
'reader_response.html').render({'response': answer})
if dest_id == feconf.END_DEST:
# This leads to a FINISHED state.
if feedback:
html_output, widget_output = self.append_feedback(
feedback, html_output, widget_output, block_number, params)
EventHandler.record_exploration_completed(exploration_id)
else:
state = State.get(dest_id, exploration)
EventHandler.record_state_hit(exploration_id, state_id)
if feedback:
html_output, widget_output = self.append_feedback(
feedback, html_output, widget_output, block_number, params)
# Append text for the new state only if the new and old states
# differ.
if old_state.id != state.id:
state_html, state_widgets = parse_content_into_html(
state.content, block_number, params)
# Separate text for the new state and feedback for the old state
# by an additional line.
if state_html and feedback:
html_output += '<br>'
html_output += state_html
widget_output.append(state_widgets)
if state.widget.widget_id in DEFAULT_ANSWERS:
values['default_answer'] = DEFAULT_ANSWERS[state.widget.widget_id]
values['exploration_id'] = exploration.id
values['state_id'] = state.id
values['oppia_html'] = html_output
values['widgets'] = widget_output
values['block_number'] = block_number + 1
values['params'] = params
if dest_id != feconf.END_DEST:
values['finished'] = False
if state.widget.sticky and (
state.widget.widget_id == old_state.widget.widget_id):
values['interactive_widget_html'] = ''
values['sticky_interactive_widget'] = True
else:
values['interactive_widget_html'] = (
InteractiveWidget.get_raw_code(
state.widget.widget_id,
params=utils.parse_dict_with_params(
state.widget.params, params)
)
)
else:
values['finished'] = True
values['interactive_widget_html'] = ''
self.response.write(json.dumps(values))
def get(self, widget_id):
"""Handles GET requests."""
response = InteractiveWidget.get_with_params(widget_id)
self.response.write(json.dumps({'widget': response}))
def setUp(self):
"""Loads the default widgets."""
super(ExplorationDataUnitTests, self).setUp()
InteractiveWidget.load_default_widgets()