def get_user_and_opinions_for_argument(argument_uid, db_user, lang, main_page,
path):
"""
Returns nested dictionary with all kinds of attacks for the argument as well as the users who are supporting
these attacks.
:param argument_uid: Argument.uid
:param db_user: User
:param lang: current language
:param main_page: main_page
:param path: path
:return: { 'attack_type': { 'message': 'string', 'users': [{'nickname': 'string', 'avatar_url': 'url'
'vote_timestamp': 'string' ], ... }],...}
"""
LOG.debug("Argument %s, nickname %s", argument_uid, db_user.nickname)
# preparation
_t = Translator(lang)
title = _t.get(_.attitudesOfOpinions)
# getting uids of all reactions
arg_uids_for_reactions = [
get_undermines_for_argument_uid(argument_uid),
get_supports_for_argument_uid(argument_uid),
get_undercuts_for_argument_uid(argument_uid),
get_rebuts_for_argument_uid(argument_uid)
]
# get gender of counter use
db_supporter = get_author_or_first_supporter_of_element(
argument_uid, db_user.uid, True)
gender = 'n'
if db_supporter:
gender = db_supporter.gender
if re.search(r'/%s/?$' % Attitudes.DONT_KNOW, path.split('?')[0]):
relation_text = get_relation_text_dict_with_substitution(
lang, False, is_dont_know=True, gender=gender)
else:
relation_text = get_relation_text_dict_with_substitution(lang,
True,
gender=gender)
# getting votes for every reaction
ret_list = __get_clicks_for_reactions(arg_uids_for_reactions,
relation_text, db_supporter, _t,
main_page)
return {'opinions': ret_list, 'title': start_with_capital(title)}
def get_user_and_opinions_for_argument(argument_uid, db_user, lang, main_page,
path):
"""
Returns nested dictionary with all kinds of attacks for the argument as well as the users who are supporting
these attacks.
:param argument_uid: Argument.uid
:param db_user: User
:param lang: current language
:param main_page: main_page
:param path: path
:return: { 'attack_type': { 'message': 'string', 'users': [{'nickname': 'string', 'avatar_url': 'url' 'vote_timestamp': 'string' ], ... }],...}
"""
logger(
'OpinionHandler', 'Argument ' + str(argument_uid) + ', nickname ' +
str(db_user.nickname))
# preparation
_t = Translator(lang)
title = _t.get(_.attitudesOfOpinions)
# getting uids of all reactions
arg_uids_for_reactions = [
get_undermines_for_argument_uid(argument_uid),
get_supports_for_argument_uid(argument_uid),
get_undercuts_for_argument_uid(argument_uid),
get_rebuts_for_argument_uid(argument_uid)
]
# get gender of counter use
db_user = get_author_or_first_supporter_of_element(argument_uid,
db_user.uid, True)
gender = db_user.gender if db_user else 'n'
if '/d' in path.split('?')[0]:
relation_text = get_relation_text_dict_with_substitution(
lang, False, is_dont_know=True, gender=gender)
else:
relation_text = get_relation_text_dict_with_substitution(lang,
True,
gender=gender)
# getting votes for every reaction
ret_list = __get_clicks_for_reactions(arg_uids_for_reactions,
relation_text, db_user, _t,
main_page)
return {'opinions': ret_list, 'title': title[0:1].upper() + title[1:]}
def get_array_for_dont_know_reaction(self, argument_uid, db_user, gender):
"""
Prepares the dict with all items for the third step, where a supportive argument will be presented.
:param argument_uid: Argument.uid
:param db_user: User
:param gender: m, f or n
:return:
"""
LOG.debug("Entering get_array_for_dont_know_reaction")
slug = self.db_issue.slug
statements_array = []
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(uid=argument_uid).first()
if not db_argument:
return {'elements': statements_array, 'extras': {'cropped_list': False}}
# set real argument in history
tmp_path = self.path.replace('/justify/{}/d'.format(db_argument.conclusion_uid),
'/justify/{}/d'.format(argument_uid))
_um = UrlManager(slug, history=tmp_path)
if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible
add_seen_argument(argument_uid, db_user)
rel_dict = get_relation_text_dict_with_substitution(self.lang, False, is_dont_know=True, gender=gender)
relation = Relations.UNDERMINE.value
url = self.__get_dont_know_item_for_undermine(db_argument, Attitudes.DISAGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.SUPPORT.value
url = self.__get_dont_know_item_for_support(argument_uid, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.UNDERCUT.value
url = self.__get_dont_know_item_for_undercut(argument_uid, Attitudes.AGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
relation = Relations.REBUT.value
url = self.__get_dont_know_item_for_rebut(db_argument, Attitudes.DISAGREE, _um)
d = self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url)
statements_array.append(d)
return {'elements': statements_array, 'extras': {'cropped_list': False}}
def get_array_for_reaction(self, argument_uid_sys, argument_uid_user, is_supportive, attack, gender):
"""
Prepares the dict with all items for the argumentation window.
:param argument_uid_sys: Argument.uid
:param argument_uid_user: Argument.uid
:param is_supportive: Boolean
:param attack: String
:param gender: Gender of the author of the attack
:return:
"""
LOG.debug("Entering get_array_for_reaction")
slug = self.db_issue.slug
db_sys_argument = DBDiscussionSession.query(Argument).get(argument_uid_sys)
db_user_argument = DBDiscussionSession.query(Argument).get(argument_uid_user)
statements_array = []
if not db_sys_argument or not db_user_argument:
return {'elements': statements_array, 'extras': {'cropped_list': False}}
rel_dict = get_relation_text_dict_with_substitution(self.lang, True, attack_type=attack, gender=gender)
mode = Attitudes.AGREE if is_supportive else Attitudes.DISAGREE
_um = UrlManager(slug, history=self.path)
relations = [relation for relation in Relations]
for relation in relations:
url = self.__get_url_based_on_relation(relation, attack, _um, mode, db_user_argument, db_sys_argument)
d = {'title': rel_dict[relation.value + '_text'], 'id': relation.value}
tmp = self.__create_answer_dict(relation.value, [d], relation.value, url)
statements_array.append(tmp)
# last item is the change attack button or step back, if we have bno other attack
attacking_arg_uids = get_all_attacking_arg_uids_from_history(self.path)
attacking_arg_uids.append(argument_uid_sys)
arg_id_sys, new_attack = attacks.get_attack_for_argument(argument_uid_user,
restrictive_arg_uids=attacking_arg_uids,
history=self.path)
if not new_attack:
url = _um.get_last_valid_url_before_reaction()
relation = 'step_back'
else:
relation = 'no_opinion'
url = _um.get_url_for_reaction_on_argument(argument_uid_user, new_attack, arg_id_sys)
statements_array.append(
self.__create_answer_dict(relation, [{'title': rel_dict[relation + '_text'], 'id': relation}], relation,
url))
return {'elements': statements_array, 'extras': {'cropped_list': False}}
def test_get_relation_text_dict_with_substitution(self):
with_no_opinion_text = False
is_dont_know = False
attack_type = ''
gender = 'f'
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
results = {
'undermine_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is wrong and I would like to argue against it.',
'support_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct and it convinced me.',
'undercut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct, but it does not support <span data-argumentation-type="argument">my argument</span>.',
'rebut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct and it supports <span data-argumentation-type="argument">my argument</span>. However I want to defend <span data-argumentation-type="position">my point of view</span>.'
}
self.assertEqual(len(res), 4)
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
with_no_opinion_text = True
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
results.update({
'step_back_text':
'Go one step back. (The system has no other counter-argument)',
'no_opinion_text': 'Show me another argument.'
})
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
is_dont_know = True
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
results.update({
'undermine_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is wrong and I would like to argue against it.',
'support_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct and it convinced me.',
'undercut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct, but it is not supported by the <span data-argumentation-type="argument">reason</span>.',
'rebut_text':
'In my opinion, <span data-argumentation-type="argument">her opinion</span> is wrong and I would like to argue against it.'
})
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
attack_type = Relations.UNDERCUT
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
attack_type = Relations.UNDERMINE
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
attack_type = Relations.REBUT
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
is_dont_know = False
attack_type = Relations.UNDERCUT
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
results.update({
'undercut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct, but it does not support <span data-argumentation-type="argument">my argument</span>.',
'rebut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct and it supports <span data-argumentation-type="argument">my argument</span>. However I want to defend <span data-argumentation-type="position">my point of view</span>.'
})
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
attack_type = Relations.UNDERMINE
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertEqual(len(res), 6)
results.update({
'undercut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct, but it does not support <span data-argumentation-type="argument">her point of view</span>.',
'rebut_text':
'In my opinion, <span data-argumentation-type="attack">her statement</span> is correct and it supports <span data-argumentation-type="argument">her point of view</span>. However I want to defend <span data-argumentation-type="position">my point of view</span>.',
})
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})
attack_type = Relations.REBUT
res = tg.get_relation_text_dict_with_substitution(
'en', with_no_opinion_text, is_dont_know, attack_type, gender)
self.assertTrue(
{k: self.assertEqual(res[k], v)
for k, v in results.items()})