def test_get_discussion_language(self):
matchdict, params, session, current_issue_uid = {}, {}, {}, {}
self.assertEqual('en', lib.get_discussion_language(matchdict, params, session, current_issue_uid))
current_issue_uid = 4
self.assertEqual('de', lib.get_discussion_language(matchdict, params, session, current_issue_uid))
matchdict, params, session, current_issue_uid = {'issue': 1}, {}, {}, {}
self.assertEqual('en', lib.get_discussion_language(matchdict, params, session, current_issue_uid))
matchdict, params, session, current_issue_uid = {}, {'issue': 1}, {}, {}
self.assertEqual('en', lib.get_discussion_language(matchdict, params, session, current_issue_uid))
matchdict, params, session, current_issue_uid = {}, {}, {'issue': 1}, {}
self.assertEqual('en', lib.get_discussion_language(matchdict, params, session, current_issue_uid))
def review_optimization_argument(request):
"""
Values for the review for an argument, which should be optimized
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Request to review an optimization. %s - %s", request.json_body,
request.authenticated_userid)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
should_optimized = request.validated['should_optimized']
new_data = request.validated['new_data']
main_page = request.application_url
_t = Translator(ui_locales)
QueueAdapter(OptimizationQueue(),
db_user,
main_page,
_t,
new_data=new_data).add_vote(db_review, should_optimized)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
key_optimization)
return True
def flag_argument_or_statement(request):
"""
Flags an argument or statement for a specific reason
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Flag an argument or statement. %s", request.json_body)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
uid = request.validated['uid']
reason = request.validated['reason']
extra_uid = request.validated['extra_uid']
is_argument = request.validated['is_argument']
db_user = request.validated['user']
return flag_element(uid, reason, db_user, is_argument, ui_locales,
extra_uid)
def flag_argument_or_statement(request):
"""
Flags an argument or statement for a specific reason
:param request: current request of the server
:return: json-dict()
"""
logger('views', 'main: {}'.format(request.json_body))
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
uid = request.validated['uid']
reason = request.validated['reason']
extra_uid = request.validated['extra_uid']
is_argument = request.validated['is_argument']
db_user = request.validated['user']
return review_flag_helper.flag_element(uid, reason, db_user, is_argument,
ui_locales, extra_uid)
def split_or_merge_premisegroup(request):
"""
Flags a premisegroup for a specific reason
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Flag a premisegroup for split or merge. %s", request.params)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
_tn = Translator(ui_locales)
db_user = request.validated['user']
pgroup = request.validated['pgroup']
key = request.validated['key']
if key not in [key_merge, key_split]:
raise HTTPBadRequest()
return flag_pgroup_for_merge_or_split(key, pgroup, db_user, _tn)
def mark_or_unmark_statement_or_argument(request):
"""
Set statements as seen, when they were hidden
:param request: current request of the server
:return: json
"""
LOG.debug("Set statement as seen. %s", request.json_body)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
arg_or_stmt = request.validated['arg_or_stmt']
step = request.validated['step']
is_supportive = request.validated['is_supportive']
should_mark = request.validated['should_mark']
history = request.json_body.get('history', '')
db_user = request.validated['user']
return mark_statement_or_argument(arg_or_stmt, step, is_supportive,
should_mark, history, ui_locales,
db_user)
def split_or_merge_premisegroup(request):
"""
Flags a premisegroup for a specific reason
:param request: current request of the server
:return: json-dict()
"""
logger('views', 'main: {}'.format(request.params))
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
_tn = Translator(ui_locales)
db_user = request.validated['user']
pgroup = request.validated['pgroup']
key = request.validated['key']
if key not in ['merge', 'split']:
raise HTTPBadRequest()
return review_flag_helper.flag_pgroup_for_merge_or_split(
key, pgroup, db_user, _tn)
def review_lock(request):
"""
Locks an optimization review so that the user can do an edit
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Lock an optimization review. %s", request.json_body)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
_tn = Translator(ui_locales)
lock = request.validated['lock']
db_review = request.validated['db_model']
db_user = request.validated['user']
if lock:
return OptimizationQueue().lock_optimization_review(
db_user, db_review, _tn)
else:
return OptimizationQueue().unlock_optimization_review(db_review, _tn)
def review_lock(request):
"""
Locks an optimization review so that the user can do an edit
:param request: current request of the server
:return: json-dict()
"""
logger('views', 'main: {}'.format(request.json_body))
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
_tn = Translator(ui_locales)
lock = request.validated['lock']
db_review = request.validated['db_model']
db_user = request.validated['user']
if lock:
return review_queue_helper.lock_optimization_review(
db_user, db_review, _tn)
else:
return review_queue_helper.unlock_optimization_review(db_review, _tn)
def review_delete_argument(request):
"""
Values for the review for an argument, which should be deleted
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Review an argument-delete request. %s", request.json_body)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
should_delete = request.validated['should_delete']
main_page = request.application_url
_t = Translator(ui_locales)
QueueAdapter(DeleteQueue(), db_user, main_page,
_t).add_vote(db_review, should_delete)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
key_delete)
return True
def review_merged_premisegroup(request):
"""
Values for the review for a statement, which should be merged
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Request to merge premisegroups. %s - %s", request.json_body,
request.authenticated_userid)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
should_merge = request.validated['should_merge']
main_page = request.application_url
_t = Translator(ui_locales)
QueueAdapter(MergeQueue(), db_user, main_page,
_t).add_vote(db_review, should_merge)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
key_merge)
return True
def review_duplicate_statement(request):
"""
Values for the review for an argument, which is maybe a duplicate
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Request to review duplicate statements. %s - %s",
request.json_body, request.authenticated_userid)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
is_duplicate = request.validated['is_duplicate']
main_page = request.application_url
_t = Translator(ui_locales)
QueueAdapter(DuplicateQueue(), db_user, main_page,
_t).add_vote(db_review, is_duplicate)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
key_duplicate)
return True
def review_edit_argument(request):
"""
Values for the review for an argument, which should be edited
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Review request to edit argument: %s - %s", request.json_body,
request.authenticated_userid)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
is_edit_okay = request.validated['is_edit_okay']
main_page = request.application_url
_t = Translator(ui_locales)
QueueAdapter(EditQueue(), db_user, main_page,
_t).add_vote(db_review, is_edit_okay)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
key_edit)
return True
def split_or_merge_statement(request):
"""
Flags a statement for a specific reason
:param request: current request of the server
:return: json-dict()
"""
LOG.debug("Flag a statement for a split or merge. %s", request.json_body)
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
_tn = Translator(ui_locales)
db_user = request.validated['user']
statement: Statement = request.validated['statement']
pgroup: PremiseGroup = DBDiscussionSession.query(Premise).filter(
Premise.statement_uid == statement.uid).one().premisegroup
key = request.validated['key']
tvalues = request.validated['text_values']
if key not in [key_merge, key_split]:
raise HTTPBadRequest()
return flag_statement_for_merge_or_split(key, pgroup, tvalues, db_user,
_tn)
def review_delete_argument(request):
"""
Values for the review for an argument, which should be deleted
:param request: current request of the server
:return: json-dict()
"""
logger('views', 'main: {}'.format(request.json_body))
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
should_delete = request.validated['should_delete']
main_page = request.application_url
_t = Translator(ui_locales)
dbas.review.opinions.add_review_opinion_for_delete(db_user, main_page,
db_review,
should_delete, _t)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
'deletes')
return True
def review_edit_argument(request):
"""
Values for the review for an argument, which should be edited
:param request: current request of the server
:return: json-dict()
"""
logger(
'Views', 'main: {} - {}'.format(request.json_body,
request.authenticated_userid))
ui_locales = get_discussion_language(request.matchdict, request.params,
request.session)
db_review = request.validated['db_review']
db_user = request.validated['user']
is_edit_okay = request.validated['is_edit_okay']
main_page = request.application_url
_t = Translator(ui_locales)
dbas.review.opinions.add_review_opinion_for_edit(db_user, main_page,
db_review, is_edit_okay,
_t)
send_request_for_recent_reviewer_socketio(db_user.nickname, main_page,
'edits')
return True
