def get_header_for_users_confrontation_response(db_argument, lang, premise, attack_type, conclusion, start_lower_case,
is_supportive, is_logged_in, redirect_from_jump=False):
"""
Based on the users reaction, text will be build. This text can be used for the speech bubbles where users
justify an argument they have chosen.
:param db_argument: Argument
:param lang: ui_locales
:param premise: current premise
:param attack_type: type of the attack
:param conclusion: current conclusion
:param start_lower_case: boolean
:param is_supportive: boolean
:param is_logged_in: boolean
:param redirect_from_jump: boolean
:return: string
"""
_t = Translator(lang)
if premise[-1] == '.':
premise = premise[:-1]
if conclusion[-1] == '.':
conclusion = conclusion[:-1]
# pretty print
r = _t.get(_.right)[0:1].upper()
f = _t.get(_.itIsFalseThat)[0:1].upper()
t = _t.get(_.itIsTrueThat)[0:1].upper()
if start_lower_case:
r = _t.get(_.right)[0:1].lower()
f = _t.get(_.itIsFalseThat)[0:1].lower()
t = _t.get(_.itIsTrueThat)[0:1].lower()
r += _t.get(_.right)[1:] + ', '
f += _t.get(_.itIsFalseThat)[1:]
t += _t.get(_.itIsTrueThat)[1:]
if lang == 'de':
r += start_with_small(_t.get(_.itIsTrueThat)) + ' '
f = _t.get(_.wrong) + ', ' + start_with_small(_t.get(_.itIsFalseThat)) + ' '
if redirect_from_jump:
r = _t.get(_.maybeItIsTrueThat) + ' '
# different cases
user_msg = __get_user_msg_for_users_confrontation_response(db_argument, attack_type, premise, conclusion, f, t, r,
is_supportive, _t)
if not user_msg:
user_msg = ''
# is logged in?
if is_logged_in:
return user_msg, _t.get(_.canYouGiveAReasonForThat)
else:
return user_msg, ''
def get_dict_for_dont_know_reaction(self, uid, nickname) -> dict:
"""
Prepares the discussion dict with all bubbles for the third step,
where an supportive argument will be presented.
:param uid: Argument.uid
:param nickname:
:return: dict()
"""
LOG.debug("Entering get_dict_for_dont_know_reaction")
_tn = Translator(self.lang)
bubbles_array = history_handler.create_bubbles(self.history,
self.nickname,
self.lang, self.slug)
add_premise_text = ''
save_statement_url = 'set_new_start_statement'
gender = ''
b = '<' + tag_type + '>'
e = '</' + tag_type + '>'
statement_list = list()
if int(uid) != 0:
text = get_text_for_argument_uid(uid,
rearrange_intro=True,
attack_type='dont_know',
with_html_tag=True,
start_with_intro=True)
db_argument = DBDiscussionSession.query(Argument).get(uid)
if not db_argument:
text = ''
data = get_name_link_of_arguments_author(db_argument, nickname)
gender = data['gender']
if data['is_valid']:
intro = data['link'] + ' ' + b + _tn.get(_.thinksThat) + e
else:
intro = b + _tn.get(_.otherParticipantsThinkThat) + e
sys_text = intro + ' ' + start_with_small(text) + '. '
sys_text += '<br><br> ' + b + _tn.get(
_.whatDoYouThinkAboutThat) + '?' + e
bubble_sys = create_speechbubble_dict(BubbleTypes.SYSTEM,
is_markable=True,
uid=uid,
content=sys_text,
other_author=data['user'])
if not bubbles_already_last_in_list(bubbles_array, bubble_sys):
bubbles_array.append(bubble_sys)
# add statements of discussion to report them
statement_list = self.__get_all_statement_texts_by_argument(
db_argument)
return {
'bubbles': bubbles_array,
'add_premise_text': add_premise_text,
'save_statement_url': save_statement_url,
'mode': '',
'extras': statement_list,
'gender': gender,
'broke_limit': self.broke_limit
}
def __get_bubble_from_dont_know_step(step: str, db_user: User, lang: str) -> List[dict]:
"""
Creates bubbles for the don't-know-reaction for a statement.
:param step: String
:param db_user: User
:param lang: ui_locales
:return: [dict()]
"""
steps = step.split('/')
uid = int(steps[1])
text = get_text_for_argument_uid(uid, rearrange_intro=True, attack_type='dont_know', with_html_tag=False,
start_with_intro=True)
db_argument = DBDiscussionSession.query(Argument).get(uid)
if not db_argument:
text = ''
from dbas.strings.text_generator import get_name_link_of_arguments_author
_tn = Translator(lang)
data = get_name_link_of_arguments_author(db_argument, db_user.nickname, False)
if data['is_valid']:
intro = data['link'] + ' ' + _tn.get(_.thinksThat)
else:
intro = _tn.get(_.otherParticipantsThinkThat)
sys_text = intro + ' ' + start_with_small(text) + '. '
sys_text += '<br><br>' + _tn.get(_.whatDoYouThinkAboutThat) + '?'
sys_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM, content=sys_text, db_user=db_user,
other_author=data['user'])
text = _tn.get(_.showMeAnArgumentFor) + (' ' if lang == 'de' else ': ') + get_text_for_conclusion(db_argument)
user_bubble = create_speechbubble_dict(BubbleTypes.USER, content=text, db_user=db_user)
return [user_bubble, sys_bubble]
def __build_single_argument(db_argument: Argument, rearrange_intro: bool, with_html_tag: bool, colored_position: bool,
attack_type: str, _t: Translator, start_with_intro: bool, is_users_opinion: bool,
anonymous_style: bool, support_counter_argument: bool = False, author_uid=None):
"""
Build up argument text for a single argument
Please, do not touch this!
:param rearrange_intro: Boolean
:param with_html_tag: Boolean
:param colored_position: Boolean
:param attack_type: String
:param _t: Translator
:param start_with_intro: Boolean
:param is_users_opinion: Boolean
:param anonymous_style: Boolean
:param support_counter_argument: Boolean
:param author_uid: User.uid
:return: String
"""
premises_text = db_argument.get_premisegroup_text()
conclusion_text = db_argument.get_conclusion_text()
lang = db_argument.lang
if lang != 'de':
premises_text = start_with_small(premises_text)
tag_dict = __get_tags_for_building_single_argument(with_html_tag, attack_type, colored_position, premises_text,
conclusion_text)
premises_text = tag_dict['premise']
conclusion_text = tag_dict['conclusion']
sb = tag_dict['tag_begin']
sb_none = tag_dict['tag_none']
se = tag_dict['tag_end']
marked_element = False
if author_uid:
db_marked = DBDiscussionSession.query(MarkedArgument).filter(MarkedArgument.argument_uid == db_argument.uid,
MarkedArgument.author_uid == author_uid).first()
marked_element = db_marked is not None
you_have_the_opinion_that = _t.get(_.youHaveTheOpinionThat).format('').strip()
if lang == 'de':
ret_value = __build_single_argument_for_de(_t, sb, se, you_have_the_opinion_that, start_with_intro,
anonymous_style, rearrange_intro, db_argument, attack_type, sb_none,
marked_element, lang, premises_text, conclusion_text,
is_users_opinion,
support_counter_argument)
else:
ret_value = __build_single_argument_for_en(_t, sb, se, you_have_the_opinion_that, marked_element,
conclusion_text,
premises_text, db_argument)
return ret_value.replace(' ', ' ')
def __get_dict_for_argumentation(self, user_arg: Argument,
confrontation_arg_uid: int, history: str,
attack: Relations, nickname: str,
is_supportive: bool) -> dict:
"""
Returns dict() for the reaction step
:param user_arg: Argument
:param confrontation_arg_uid: Argument.uid
:param history: String
:param attack: String
:param nickname: User.nickname
:param is_supportive: Boolean
:return: dict()
"""
premise = user_arg.get_premisegroup_text()
conclusion = get_text_for_conclusion(user_arg)
db_confrontation = DBDiscussionSession.query(Argument).get(
confrontation_arg_uid)
confr = db_confrontation.get_premisegroup_text()
sys_conclusion = (db_confrontation.get_conclusion_text())
if attack == Relations.UNDERMINE:
if db_confrontation.conclusion_uid != 0:
premise = db_confrontation.get_conclusion_text()
else:
premise = get_text_for_argument_uid(
db_confrontation.argument_uid,
True,
colored_position=True,
attack_type=attack)
# did the user changed his opinion?
history = history_handler.split(history)
user_changed_opinion = len(history) > 1 and '/undercut/' in history[-2]
# argumentation is a reply for an argument, if the arguments conclusion of the user is no position
conclusion_uid = user_arg.conclusion_uid
tmp_arg = user_arg
while not conclusion_uid:
tmp_arg = DBDiscussionSession.query(Argument).get(
tmp_arg.argument_uid)
conclusion_uid = tmp_arg.conclusion_uid
db_statement = DBDiscussionSession.query(Statement).get(conclusion_uid)
reply_for_argument = not (db_statement and db_statement.is_position)
support_counter_argument = 'reaction' in self.history.split('-')[-1]
current_argument = get_text_for_argument_uid(
user_arg.uid,
nickname=nickname,
with_html_tag=True,
colored_position=True,
user_changed_opinion=user_changed_opinion,
attack_type=attack,
minimize_on_undercut=True,
support_counter_argument=support_counter_argument)
current_argument = start_with_capital(current_argument)
if self.lang != 'de':
premise = start_with_small(premise)
# check for support and build text
_tn = Translator(self.lang)
user_text = (_tn.get(_.otherParticipantsConvincedYouThat) +
': ') if user_changed_opinion else ''
user_text += current_argument if current_argument != '' else premise
sys_text, gender = get_text_for_confrontation(
self.lang, nickname, premise, conclusion, sys_conclusion,
is_supportive, attack, confr, reply_for_argument,
not user_arg.is_supportive, user_arg, db_confrontation)
gender_of_counter_arg = gender
return {
'user': user_text,
'sys': sys_text,
'gender': gender_of_counter_arg,
'confrontation': db_confrontation
}
def get_dict_for_justify_argument(self, uid, is_supportive, attack):
"""
Prepares the discussion dict with all bubbles for a step in discussion,
where the user justifies his attack she has done.
:param uid: Argument.uid
:param is_supportive: Boolean
:param attack: String (undermine, support, undercut, rebut, ...)
:return: dict()
"""
LOG.debug("Entering get_dict_for_justify_argument")
_tn = Translator(self.lang)
bubbles_array = history_handler.create_bubbles(self.history,
self.nickname,
self.lang, self.slug)
add_premise_text = ''
save_statement_url = 'set_new_premises_for_argument'
db_argument = DBDiscussionSession.query(Argument).get(uid)
if not db_argument:
return {
'bubbles': bubbles_array,
'add_premise_text': add_premise_text,
'save_statement_url': save_statement_url,
'mode': '',
'broke_limit': self.broke_limit
}
confrontation = get_text_for_argument_uid(uid)
premise = db_argument.get_premisegroup_text()
conclusion = get_text_for_conclusion(db_argument,
is_users_opinion=False)
if db_argument.conclusion_uid is None:
conclusion = start_with_small(conclusion)
while premise.endswith(('.', '?', '!')):
premise = premise[:-1]
while conclusion.endswith(('.', '?', '!')):
conclusion = premise[:-1]
redirect_from_jump = 'jump/' in self.history.split('-')[-1]
user_msg, sys_msg = get_header_for_users_confrontation_response(
db_argument,
self.lang,
premise,
attack,
conclusion,
False,
is_supportive,
self.nickname,
redirect_from_jump=redirect_from_jump)
add_premise_text = self.__get_add_premise_text_for_justify_argument(
confrontation, premise, attack, conclusion, db_argument,
is_supportive, user_msg)
start = '<{} data-argumentation-type="position">'.format(tag_type)
end = '</{}>'.format(tag_type)
user_msg = user_msg.format(start, end)
pro_tag = '<{} class="text-success">'.format(tag_type)
con_tag = '<{} class="text-danger">'.format(tag_type)
end_tag = '</{}>'.format(tag_type)
if attack == Relations.UNDERCUT:
sys_msg = _tn.get(
_.whatIsYourMostImportantReasonForArgument).rstrip().format(
pro_tag, end_tag) + ': '
dot = '.'
else:
dot = '?'
if attack == Relations.UNDERMINE:
sys_msg = _tn.get(
_.whatIsYourMostImportantReasonAgainstStatement).rstrip(
).format(con_tag, end_tag)
sys_msg += ', ' if self.lang == 'de' else ' '
else:
sys_msg = _tn.get(_.whatIsYourMostImportantReasonForStatement
).rstrip().format(pro_tag, end_tag) + ': '
sys_msg += user_msg + dot + '<br>' + _tn.get(_.because) + '...'
self.__append_now_bubble(bubbles_array)
sys_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM,
content=sys_msg,
omit_bubble_url=True,
lang=self.lang)
if not bubbles_already_last_in_list(bubbles_array, sys_bubble):
bubbles_array.append(sys_bubble)
return {
'bubbles': bubbles_array,
'add_premise_text': add_premise_text,
'save_statement_url': save_statement_url,
'mode': '',
'attack_type': attack,
'arg_uid': uid,
'broke_limit': self.broke_limit
}
def __create_reaction_history_bubbles(step: str, db_user: User, lang: str,
split_history: list, url: str,
color_steps: bool, uid: int,
additional_uid: int, attack) -> list:
is_supportive = DBDiscussionSession.query(Argument).get(uid).is_supportive
last_relation = get_last_relation(split_history)
user_changed_opinion = len(
split_history) > 1 and '/undercut/' in split_history[-2]
support_counter_argument = False
if step in split_history:
index = split_history.index(step)
try:
support_counter_argument = 'reaction' in split_history[index - 1]
except IndexError:
support_counter_argument = False
color_steps = color_steps and attack != Relations.SUPPORT # special case for the support round
current_arg = get_text_for_argument_uid(
uid,
user_changed_opinion=user_changed_opinion,
support_counter_argument=support_counter_argument,
colored_position=color_steps,
nickname=db_user.nickname,
with_html_tag=color_steps)
db_argument = DBDiscussionSession.query(Argument).get(uid)
db_confrontation = DBDiscussionSession.query(Argument).get(additional_uid)
reply_for_argument = True
if db_argument.conclusion_uid is not None:
db_statement = DBDiscussionSession.query(Statement).get(
db_argument.conclusion_uid)
reply_for_argument = not (db_statement and db_statement.is_position)
premise = db_argument.get_premisegroup_text()
conclusion = get_text_for_conclusion(db_argument)
sys_conclusion = get_text_for_conclusion(db_confrontation)
confr = db_confrontation.get_premisegroup_text()
user_is_attacking = not db_argument.is_supportive
if lang != 'de':
current_arg = start_with_capital(current_arg)
if current_arg.startswith('<'):
pos = current_arg.index('>')
current_arg = current_arg[0:pos] + current_arg[pos:pos + 1].upper(
) + current_arg[pos + 1:]
premise = start_with_small(premise)
_tn = Translator(lang)
user_text = ''
if last_relation == Relations.SUPPORT:
user_text = _tn.get(_.otherParticipantsConvincedYouThat) + ': '
user_text += '<{}>{}</{}>'.format(
tag_type, current_arg if current_arg != '' else premise, tag_type)
sys_text, tmp = get_text_for_confrontation(lang,
db_user.nickname,
premise,
conclusion,
sys_conclusion,
is_supportive,
attack,
confr,
reply_for_argument,
user_is_attacking,
db_argument,
db_confrontation,
color_html=False)
bubble_user = create_speechbubble_dict(BubbleTypes.USER,
bubble_url=url,
content=user_text,
omit_bubble_url=False,
argument_uid=uid,
is_supportive=is_supportive,
db_user=db_user,
lang=lang)
db_tmp = DBDiscussionSession.query(User).get(db_confrontation.author_uid)
if not attack:
bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM,
content=sys_text,
omit_bubble_url=True,
db_user=db_user,
lang=lang,
other_author=db_tmp)
else:
bubble_syst = create_speechbubble_dict(BubbleTypes.SYSTEM,
uid='question-bubble-' +
str(additional_uid),
content=sys_text,
omit_bubble_url=True,
db_user=db_user,
lang=lang,
other_author=db_tmp)
return [bubble_user, bubble_syst]
def test_start_with_small(self):
self.assertEqual(start_with_small(''), '')
self.assertEqual(start_with_small('asd'), 'asd')
self.assertEqual(start_with_small('aSD'), 'aSD')
self.assertEqual(start_with_small('Asd'), 'asd')
self.assertEqual(start_with_small('ASD'), 'aSD')
