def discussion_reaction(request):
"""
Return data from DBas discussion_reaction page.
Path: /{slug}/reaction/{arg_id_user}/{relation}/{arg_id_sys}
:param request: request
:return: bubbles for information and items for the next step
"""
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.reaction(db_issue, db_user,
request.validated['arg_user'],
request.validated['arg_sys'],
request.validated['relation'],
history, request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
keys = [
item['attitude'] for item in prepared_discussion['items']['elements']
]
return {'bubbles': bubbles, 'attacks': dict(zip(keys, items))}
def jump(request):
"""
View configuration for the jump view.
:param request: request of the web server
:return: dictionary
"""
emit_participation(request)
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.jump(db_issue, db_user,
request.validated['argument'],
history, request.path)
rdict = prepare_request_dict(request)
if not request.validated.get("from_api", False):
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, True)
return prepared_discussion
def add_position_with_premise(request):
db_user: User = request.validated['user']
db_issue: Issue = request.validated['issue']
reference_text: str = request.validated['reference']
origin: DataOrigin = request.validated['origin']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
host, path = split_url(request.environ.get("HTTP_REFERER"))
new_position = set_position(db_user, db_issue,
request.validated['position-text'])
conclusion_id: int = new_position['statement_uids'][0]
db_conclusion: Statement = DBDiscussionSession.query(Statement).get(
conclusion_id)
pd = set_positions_premise(db_issue, db_user, db_conclusion,
[[request.validated['reason-text']]], True,
history, request.mailer)
statement_uids: List[int] = flatten(pd['statement_uids'])
LOG.info("Created %d statements: %s", len(statement_uids), statement_uids)
__store_origin_and_reference(db_issue, db_user, origin, host, path,
reference_text, statement_uids)
if origin:
add_origin_for_list_of_statements(origin,
new_position['statement_uids'])
add_origin_for_list_of_statements(origin,
flatten(pd['statement_uids']))
return __http_see_other_with_cors_header('/api' + pd['url'])
def justify_argument(request) -> dict:
r"""
View configuration for discussion step, where we will ask the user for her a justification of her opinion/interest.
Path: /discuss/{slug}/justify/{argument_id:\d+}/{attitude}/{relation}
:param request: request of the web server
:return: dict
"""
LOG.debug("Justify an argument. %s", request.matchdict)
emit_participation(request)
db_argument: Argument = request.validated['argument']
db_issue = request.validated['issue']
db_user = request.validated['user']
inner_attitude = request.validated['attitude']
relation = request.validated['relation']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.justify_argument(db_issue, db_user,
db_argument,
inner_attitude, relation,
history, request.path)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict_during_justification_argument(request, db_user,
db_issue,
prepared_discussion)
return prepared_discussion
def choose(request):
"""
View configuration for discussion step, where the user has to choose between given statements.
:param request: request of the web server
:return: dictionary
"""
# '/discuss/{slug}/choose/{is_argument}/{supportive}/{id}*pgroup_ids'
LOG.debug("Choose a statement. %s", request.matchdict)
emit_participation(request)
db_user: User = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
pgroups = {
'pgroup_uid': request.validated['pgroup_uid'],
'pgroup_uids': request.validated['pgroup_uids'],
}
prepared_discussion = discussion.choose(db_issue, db_user,
request.validated['is_argument'],
request.validated['is_supportive'],
pgroups, history, request.path)
rdict = prepare_request_dict(request)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, False)
return prepared_discussion
def support(request):
"""
View configuration for discussion step, where we will present another supportive argument.
:param request: request of the web server
:return: dictionary
"""
LOG.debug("Support a statement. %s", request.matchdict)
emit_participation(request)
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.support(db_issue, db_user,
request.validated['arg_user'],
request.validated['arg_sys'],
history, request.path)
rdict = prepare_request_dict(request)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, False)
return prepared_discussion
def reaction(request):
r"""
View configuration for discussion step, where we will ask the user for her reaction (support, undercut, rebut)...
Path: /discuss/{slug}/reaction/{arg_id_user:\d+}/{relation}/{arg_id_sys:\d+}
:param request: request of the web server
:return: dictionary
"""
LOG.debug("React to a step. %s", request.validated)
emit_participation(request)
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.reaction(db_issue, db_user,
request.validated['arg_user'],
request.validated['arg_sys'],
request.validated['relation'],
history, request.path)
rdict = prepare_request_dict(request)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, True)
return prepared_discussion
def finish(request):
"""
View configuration for discussion step, where we present a small/daily summary on the end
:param request: request of the web server
:return:
"""
LOG.debug("Finish the discussion. %s", request.matchdict)
emit_participation(request)
emit_agreement_with_argument(request)
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.finish(db_issue, db_user,
request.validated['argument'],
history)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, prepare_request_dict(request),
request.authenticated_userid, True)
return prepared_discussion
def choose(request):
"""
View configuration for discussion step, where the user has to choose between given statements.
This step is shown when the user has given multiple reasons at the same time for/against a statement. The
corresponding premisegroup ids are given in the url.
:param request: request of the web server
:return: dictionary
"""
# '/discuss/{slug}/choose/*pgroup_ids'
LOG.debug("Choose a statement. %s", request.matchdict)
emit_participation(request)
db_user: User = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.choose(db_issue, db_user,
request.validated['pgroup_uids'],
history, request.path)
rdict = prepare_request_dict(request)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, False)
return prepared_discussion
def prepare_request_dict(request: Request):
"""
:param request:
:return:
"""
LOG.debug("Preparing request dict for renderer")
db_user = request.validated['user']
nickname = db_user.nickname if db_user.nickname != nick_of_anonymous_user else None
db_last_topic = history_handler.get_last_issue_of(db_user)
slug = __get_slug(request.matchdict)
db_issue = __get_issue(request, slug, db_last_topic)
issue_handler.save_issue_id_in_session(db_issue.uid, request)
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
set_language_for_visit(request)
return {
'nickname': nickname,
'user': db_user,
'path': request.path,
'app_url': request.application_url,
'matchdict': request.matchdict,
'params': request.params,
'session': request.session,
'registry': request.registry,
'issue': db_issue,
'history': history,
'ui_locales': get_language_from_cookie(request)
}
def attitude(request):
"""
View configuration for discussion step, where we will ask the user for her attitude towards a statement.
Route: /discuss/{slug}/attitude/{position_id}
:param request: request of the web server
:return: dictionary
"""
LOG.debug("View attitude: %s", request.matchdict)
emit_participation(request)
db_statement = request.validated['statement']
db_issue = request.validated['issue']
db_user = request.validated['user']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.attitude(db_issue, db_user, db_statement,
history, request.path)
modify_discussion_url(prepared_discussion)
modify_discussion_bubbles(prepared_discussion, request.registry)
rdict = prepare_request_dict(request)
append_extras_dict(prepared_discussion, rdict,
request.authenticated_userid, False)
return prepared_discussion
def discussion_support(request):
"""
View configuration for discussion step, where we will present another supportive argument.
Path: /{slug}/support/{arg_id_user}/{arg_id_sys}
:param request: request
:return: bubbles for information and items for the next step
"""
LOG.debug("Support a statement. %s", request.matchdict)
emit_participation(request)
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.support(db_issue, db_user,
request.validated['arg_user'],
request.validated['arg_sys'],
history, request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
keys = [
item['attitude'] for item in prepared_discussion['items']['elements']
]
return {'bubbles': bubbles, 'attacks': dict(zip(keys, items))}
def discussion_finish(request):
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.finish(db_issue, db_user,
request.validated['argument'], history)
return {'bubbles': extract_items_and_bubbles(prepared_discussion)[0]}
def add_premise_to_statement(request: IRequest):
db_user: User = request.validated['user']
db_issue: Issue = request.validated['issue']
db_statement: Statement = request.validated['statement']
reference_text: str = request.validated['reference']
is_supportive = request.validated['attitude'] == Attitudes.AGREE
origin: DataOrigin = request.validated['origin']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
host, path = split_url(request.environ.get("HTTP_REFERER"))
pd = set_positions_premise(db_issue, db_user, db_statement, [[request.validated['reason-text']]], is_supportive,
history, request.mailer)
__store_origin_and_reference(db_issue, db_user, origin, host, path, reference_text, flatten(pd['statement_uids']))
return __http_see_other_with_cors_header('/api' + pd['url'])
def discussion_justify_statement(request) -> dict:
"""
Pick attitude from path and query the statement. Show the user some statements to follow the discussion.
Path: /{slug}/justify/{statement_id}/{attitude}
:param request: request
:return: dict
"""
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.justify_statement(
db_issue, db_user, request.validated['statement'],
request.validated['attitude'], history, request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
return {'bubbles': bubbles, 'items': items}
def add_premise_to_argument(request):
db_user: User = request.validated['user']
db_issue: Issue = request.validated['issue']
db_argument: Argument = request.validated['argument']
reference_text: str = request.validated['reference']
relation: Relations = request.validated['relation']
origin: DataOrigin = request.validated['origin']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
host, path = split_url(request.environ.get("HTTP_REFERER"))
if reference_text:
for premise in db_argument.premisegroup.premises:
store_reference(reference_text, host, path, db_user, premise.statement, db_issue)
pd = set_arguments_premises(db_issue, db_user, db_argument, [[request.validated['reason-text']]], relation,
history, request.mailer)
__store_origin_and_reference(db_issue, db_user, origin, host, path, reference_text, pd['statement_uids'])
return __http_see_other_with_cors_header('/api' + pd['url'])
def discussion_justify_argument(request) -> dict:
"""
Justify an argument. Attitude and relation are important to show the correct items for the user.
/{slug}/justify/{argument_id}/{attitude}/{relation}
:param request:
:return:
"""
db_user = request.validated['user']
db_issue = request.validated['issue']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.justify_argument(
db_issue, db_user, request.validated['argument'],
request.validated['attitude'], request.validated['relation'], history,
request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
return {'bubbles': bubbles, 'items': items}
def discussion_dontknow_argument(request) -> dict:
"""
Dont know an argument.
/{slug}/justify/{argument_id}/dontknow
:param request:
:return:
"""
db_user = request.validated['user']
db_issue = request.validated['issue']
hist = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.dont_know_argument(
db_issue, db_user, request.validated['argument'], hist, request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
keys = [
item['attitude'] for item in prepared_discussion['items']['elements']
]
return {'bubbles': bubbles, 'attacks': dict(zip(keys, items))}
def discussion_attitude(request):
"""
Return data from DBas discussion_attitude page.
/{slug}/attitude/{position_id}
:param request: request
:return: dbas.discussion_attitude(True)
"""
db_position = request.validated['position']
db_issue = request.validated['issue']
db_user = request.validated['user']
history = history_handler.save_and_set_cookie(request, db_user, db_issue)
prepared_discussion = discussion.attitude(db_issue, db_user, db_position,
history, request.path)
bubbles, items = extract_items_and_bubbles(prepared_discussion)
keys = [
item['attitude'] for item in prepared_discussion['items']['elements']
]
return {'bubbles': bubbles, 'attitudes': dict(zip(keys, items))}
