def get_user_with_same_opinion_for_argument(argument_uid, db_user, lang, main_page):
"""
Returns nested dictionary with all kinds of information about the votes of the argument.
:param argument_uid: Argument.uid
:param db_user: User
:param lang: language
:param main_page: url
:return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]}
"""
try:
text = get_text_for_argument_uid(argument_uid, 'de')
LOG.debug("Argument %s: %s", argument_uid, text)
if not text:
return {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None}
except TypeError:
return {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None}
opinions = dict()
all_users = []
_t = Translator(lang)
text = get_text_for_argument_uid(argument_uid, lang)
title = _t.get(_.reactionFor) + ': ' + start_with_capital(text)
db_argument = DBDiscussionSession.query(Argument).get(argument_uid)
if not db_argument:
opinions = {'uid': None, 'text': None, 'message': None, 'users': None, 'seen_by': None}
opinions['uid'] = str(argument_uid)
text = get_text_for_argument_uid(argument_uid, lang)
opinions['text'] = start_with_capital(text)
db_clicks = DBDiscussionSession.query(ClickedArgument).filter(ClickedArgument.argument_uid == argument_uid,
ClickedArgument.is_up_vote == True,
ClickedArgument.is_valid == True,
ClickedArgument.author_uid != db_user.uid).all()
for vote in db_clicks:
voted_user = DBDiscussionSession.query(User).get(vote.author_uid)
users_dict = create_users_dict(voted_user, vote.timestamp, main_page, lang)
all_users.append(users_dict)
opinions['users'] = all_users
opinions['message'] = __get_text_for_clickcount(len(db_clicks), db_user.uid, _t)
db_seen_by = DBDiscussionSession.query(SeenArgument).filter_by(argument_uid=int(argument_uid)).all()
opinions['seen_by'] = len(db_seen_by) if db_seen_by else 0
return {'opinions': opinions, 'title': start_with_capital(title)}
def __get_reviews_from_history_queue(main_page, db_user, translator, is_executed=False):
"""
:param main_page: Host URL
:param db_user: User
:param translator: Translator
:param is_executed: Boolean
:return: dict()
"""
past_decision = []
for key in review_queues:
review_table = get_review_model_by_key(key)
executed_list = __get_executed_reviews_of(key, main_page, review_table, translator, is_executed)
past_decision.append({
'title': start_with_capital(key) + ' Queue',
'icon': reputation_icons[key],
'queue': key,
'content': executed_list,
'has_reason': key in [key_delete],
'has_oem_text': key in [key_edit, key_merge, key_split],
'has_duplicate_text': key in [key_duplicate]
})
return {
'has_access': is_executed and __has_access_to_history(db_user),
'is_history': is_executed,
'past_decision': past_decision
}
def get_user_with_same_opinion_for_premisegroups_of_args(
argument_uids, db_user, lang, main_page):
"""
Returns nested dictionary with all kinds of information about the votes of the premisegroups.
:param argument_uids: [Argument.uid]
:param db_user: User
:param lang: language
:param main_page: url
:return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]}
"""
LOG.debug("Arguments %s", argument_uids)
opinions = []
_t = Translator(lang)
title = _t.get(_.relativePopularityOfStatements)
for arg_uid in argument_uids:
db_argument = DBDiscussionSession.query(Argument).get(arg_uid)
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
if db_premises:
opinions.append(
get_user_with_same_opinion_for_premisegroups_of_arg(
db_argument, db_premises, db_user, lang, main_page))
return {'opinions': opinions, 'title': start_with_capital(title)}
def test_get_text_for_add_premise_container(self):
_t = Translator('en')
for is_supportive in [True, False]:
confrontation = start_with_capital(self.confrontation)
undermine = _t.get(_.itIsFalseThat) + ' ' + self.premise
support = _t.get(_.itIsTrueThat) if is_supportive else _t.get(
_.itIsFalseThat)
support += ' ' + self.conclusion + ' '
support += _t.get(_.hold) if is_supportive else _t.get(
_.doesNotHold)
undercut = confrontation + ', ' + _t.get(
_.butIDoNotBelieveCounterFor).format(self.conclusion)
rebut = confrontation + ' '
rebut += _t.get(_.iAcceptCounterThat) if is_supportive else _t.get(
_.iAcceptArgumentThat)
rebut += ' ' + self.conclusion
results = {
Relations.UNDERMINE: undermine + ' ...',
Relations.SUPPORT: support + ' ...',
Relations.UNDERCUT: undercut + ' ...',
Relations.REBUT: rebut + ' ...',
'': '',
}
for r in results:
self.assertEqual(
results[r],
tg.get_text_for_add_premise_container(
'en', self.confrontation, self.premise, r,
self.conclusion, is_supportive))
def __get_dict_for_argumentation_end(self, argument_uid: int,
user_changed_opinion: bool,
db_user: User) -> dict:
"""
Returns a special dict() when the discussion ends during an argumentation
:param argument_uid: Argument.uid
:param user_changed_opinion: Boolean
:param db_user: User
:return: String, String, String
"""
nickname = db_user.nickname if db_user and db_user.nickname != nick_of_anonymous_user else None
_tn = Translator(self.lang)
text = get_text_for_argument_uid(
argument_uid,
user_changed_opinion=user_changed_opinion,
minimize_on_undercut=True,
nickname=nickname)
user_text = start_with_capital(text)
sys_text = _tn.get(_.otherParticipantsDontHaveCounterForThat) + '.'
trophy = '<i class="fa fa-trophy" aria-hidden="true"></i>'
mid_text = '{} {} {} <br>{}'.format(
trophy, _tn.get(_.congratulation), trophy,
_tn.get(_.discussionCongratulationEnd))
if nickname is not None:
mid_text += _tn.get(_.discussionEndLinkTextWithQueueLoggedIn)
else:
mid_text += _tn.get(_.discussionEndLinkTextWithQueueNotLoggedIn)
return {'user': user_text, 'mid': mid_text, 'sys': sys_text}
def get_system_bubble_text_for_justify_statement(is_supportive, _tn, tag_start,
text, tag_end):
"""
Returns system text for a bubble when the user has to justify a statement and text for the add-position-container
:param is_supportive: Boolean
:param _tn: Translator
:param tag_start: String
:param text: String
:param tag_end: String
:return: String
"""
if _tn.get_lang() == 'de':
if is_supportive:
question = _tn.get(_.whatIsYourMostImportantReasonWhyForInColor)
else:
question = _tn.get(
_.whatIsYourMostImportantReasonWhyAgainstInColor)
else:
question = _tn.get(_.whatIsYourMostImportantReasonWhyFor)
question += ' ' + tag_start + text + tag_end
if _tn.get_lang() != 'de':
question += ' ' + _tn.get(
_.holdsInColor if is_supportive else _.isNotAGoodIdeaInColor)
because = start_with_capital(_tn.get(_.because)) + '...'
question += '? <br>' + because
return question
def pretty_print_options(message):
"""
Some modifications for pretty printing.
Use uppercase for first letter in text and a single dot for the end if there isn't one already.
:param message: String
:return: String
"""
# check for html
if message[0:1] == '<':
pos = message.index('>')
message = message[0:pos + 1] + message[pos + 1:pos +
2].upper() + message[pos + 2:]
else:
message = start_with_capital(message)
# check for html
if message[-1] == '>':
pos = message.rfind('<')
if message[pos - 1] not in ['.', '?', '!']:
message = message[0:pos] + '.' + message[pos:]
elif not message.endswith(tuple(['.', '?', '!'])) and id != 'now':
message += '.'
return message
def get_title_by_key(key: str):
"""
Get the title of a queue page
:param key:
:return:
"""
return _.get_key_by_string(_.queue.value + start_with_capital(key))
def get_user_bubble_text_for_justify_statement(stmt_uid, db_user,
is_supportive, _tn):
"""
Returns user text for a bubble when the user has to justify a statement and text for the add-position-container
:param stmt_uid: Statement.uid
:param db_user: User
:param is_supportive: Boolean
:param _tn: Translator
:return: String, String
"""
LOG.debug("%s is supportive? %s", stmt_uid, is_supportive)
statement = DBDiscussionSession.query(Statement).get(stmt_uid)
text = statement.get_text()
if _tn.get_lang() == 'de':
intro = _tn.get(_.itIsTrueThat if is_supportive else _.itIsFalseThat)
add_premise_text = start_with_capital(intro) + ' ' + text
else:
add_premise_text = start_with_capital(text) + ' ' + _tn.get(
_.holds if is_supportive else _.isNotAGoodIdea).strip()
add_premise_text += ', ...'
is_users_opinion = False
if db_user:
db_marked_statement = DBDiscussionSession.query(
MarkedStatement).filter(
MarkedStatement.statement_uid == stmt_uid,
MarkedStatement.author_uid == db_user.uid).first()
is_users_opinion = db_marked_statement is not None
if is_users_opinion:
intro = _tn.get(_.youHaveTheOpinionThat)
outro = '' if is_supportive else ', ' + _tn.get(_.isNotAGoodIdea)
text = intro.format(text) + outro
return text, add_premise_text
if is_supportive:
intro = _tn.get(_.youAgreeWith) if _tn.get_lang() == 'de' else '{}'
else:
intro = _tn.get(_.youDisagreeWith)
text = intro.format(text)
return text, add_premise_text
def __get_text_for_add_something(nickname, lang, url, keyword, for_html=True):
nl = '<br>' if for_html else '\n'
_t = Translator(lang)
intro = _t.get(keyword).format(nickname)
clickForMore = start_with_capital(_t.get(_.clickForMore))
if for_html:
url = f'{get_global_url()}/discuss{url}'
url = f'<a href="{url}">{clickForMore}</a>'
else:
url = get_global_url() + '/discuss' + url
return f'{intro}{nl}{clickForMore}: {url}'
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_queue_information(self, queue_name: str):
"""
Returns some information of the current queue
:param queue_name: name of the queue
:return:
"""
last_reviewer = get_last_reviewer_by_key(queue_name)
table = get_review_model_by_key(queue_name)
task_count = get_review_count_for(table, last_reviewer, self.db_user)
count, all_rights = get_reputation_of(self.db_user)
visit_key_str = _.get_key_by_string('visit{}Queue'.format(
start_with_capital(queue_name)))
visit_limit_key_str = _.get_key_by_string(
'visit{}QueueLimitation'.format(start_with_capital(queue_name)))
return {
'task_name':
self.translator.get(get_title_by_key(queue_name)),
'id':
queue_name,
'url':
f'{self.application_url}/review/{queue_name}',
'icon':
reputation_icons[queue_name],
'task_count':
task_count,
'is_allowed':
count >= reputation_borders[queue_name] or all_rights,
'is_allowed_text':
self.translator.get(visit_key_str),
'is_not_allowed_text':
self.translator.get(visit_limit_key_str).format(
str(reputation_borders[queue_name])),
'last_reviews':
self.__get_last_reviewer_of(last_reviewer, self.application_url)
}
def get_text_for_add_premise_container(lang, confrontation, premise,
attack_type, conclusion, is_supportive):
"""
Based on the users reaction, text will be build. This text can be used for the container where users can
add their statements
:param lang: ui_locales
:param confrontation: chosen confrontation
:param premise: current premise
:param attack_type: type of the attack
:param conclusion: current conclusion
:param is_supportive: boolean
:return: string
"""
_t = Translator(lang)
while premise[-1] in ['.', ' ']:
premise = premise[:-1]
while conclusion[-1] in ['.', ' ']:
conclusion = premise[:-1]
confrontation = start_with_capital(confrontation)
# different cases
if attack_type == Relations.UNDERMINE:
return '{} {} ...'.format(_t.get(_.itIsFalseThat), premise)
elif attack_type == Relations.SUPPORT:
intro = _t.get(_.itIsFalseThat)
outro = _t.get(_.doesNotHold)
if is_supportive:
intro = _t.get(_.itIsTrueThat)
outro = _t.get(_.hold)
return '{} {} {} ...'.format(intro, conclusion, outro)
elif attack_type == Relations.UNDERCUT:
return '{}, {} ...'.format(
confrontation,
_t.get(_.butIDoNotBelieveCounterFor).format(conclusion))
elif attack_type == Relations.REBUT:
mid = _t.get(_.iAcceptCounterThat) if is_supportive else _t.get(
_.iAcceptArgumentThat)
return '{} {} {} ...'.format(confrontation, mid, conclusion)
else:
return ''
def get_all_infos_about_argument(db_argument: Argument, main_page, db_user,
lang) -> dict:
"""
Returns bunch of information about the given argument
:param db_argument: The argument
:param main_page: url of the application
:param db_user: User
:param lang: Language
:rtype: dict
:return: dictionary with many information or an error
"""
_t = Translator(lang.ui_locales)
return_dict = dict()
db_votes = DBDiscussionSession.query(ClickedArgument).filter(
ClickedArgument.argument_uid == db_argument.uid,
ClickedArgument.is_valid == True,
ClickedStatement.is_up_vote == True).all()
db_author = DBDiscussionSession.query(User).get(db_argument.author_uid)
return_dict['vote_count'] = str(len(db_votes))
return_dict['author'] = db_author.global_nickname
return_dict['author_url'] = main_page + '/user/' + str(db_author.uid)
return_dict['gravatar'] = get_profile_picture(db_author)
return_dict['timestamp'] = sql_timestamp_pretty_print(
db_argument.timestamp, db_argument.lang)
text = get_text_for_argument_uid(db_argument.uid)
return_dict['text'] = start_with_capital(text)
supporters = []
gravatars = dict()
public_page = dict()
for vote in db_votes:
db_author = DBDiscussionSession.query(User).get(vote.author_uid)
name = db_author.global_nickname
if db_user.nickname == db_author.nickname:
name += ' (' + _t.get(_.itsYou) + ')'
supporters.append(name)
gravatars[name] = get_profile_picture(db_author)
public_page[name] = main_page + '/user/' + str(db_author.uid)
return_dict['supporter'] = supporters
return_dict['gravatars'] = gravatars
return_dict['public_page'] = public_page
return return_dict
def get_user_with_opinions_for_attitude(statement_uid, db_user, lang,
main_page):
"""
Returns dictionary with agree- and disagree-votes
:param statement_uid: Statement.uid
:param db_user: User
:param lang: language
:param main_page: url
:return:
"""
LOG.debug("Statement %s", statement_uid)
db_statement = DBDiscussionSession.query(Statement).get(
statement_uid) if statement_uid else None
_t = Translator(lang)
title = _t.get(_.agreeVsDisagree)
if not db_statement:
empty_dict = {'users': [], 'text': None, 'message': ''}
return {
'text': None,
'agree': empty_dict,
'disagree': empty_dict,
'title': title
}
text = db_statement.get_text()
title += ' ' + text
ret_dict = dict()
ret_dict['text'] = start_with_capital(text)
ret_dict['agree'] = None
ret_dict['disagree'] = None
ret_dict['title'] = title
agree_dict = __collect_pro_clicks(statement_uid, db_user.uid, main_page,
_t)
disagree_dict = __collect_con_clicks(statement_uid, db_user.uid, main_page,
_t)
ret_dict['agree'] = agree_dict
ret_dict['disagree'] = disagree_dict
db_seen_by = DBDiscussionSession.query(SeenStatement).filter_by(
statement_uid=int(statement_uid)).all()
ret_dict['seen_by'] = len(db_seen_by) if db_seen_by else 0
return ret_dict
def get_information_of(db_user: User, lang):
"""
Returns public information of the given user
:param db_user: User
:param lang: ui_locales
:return: dict()
"""
if db_user.nickname == nick_of_anonymous_user:
return __get_special_infos(lang)
db_group = DBDiscussionSession.query(Group).get(db_user.group_uid)
ret_dict = dict()
ret_dict['public_nick'] = db_user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
db_user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(
db_user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(
db_user.registered, lang)
ret_dict['group'] = start_with_capital(db_group.name)
ret_dict['is_male'] = db_user.gender == 'm'
ret_dict['is_female'] = db_user.gender == 'f'
ret_dict['is_neutral'] = db_user.gender != 'm' and db_user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(db_user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=db_user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=db_user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=db_user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=db_user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(db_user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(db_user, 120)
ret_dict['discussion_stat_rep'], trash = get_reputation_of(db_user)
return ret_dict
def __build_val_for_jump(db_argument, tag_premise, tag_conclusion, tag_end, _t):
premises = db_argument.get_premisegroup_text()
if premises[-1] != '.':
premises += '.'
conclusion = db_argument.get_conclusion_text()
because = _t.get(_.because).lower()
conclusion = tag_conclusion + conclusion + tag_end
premises = tag_premise + premises + tag_end
intro = (start_con + _t.get(_.isNotRight).lower() + end_tag) if not db_argument.is_supportive else ''
ret_value = '{} {} {} {}'.format(conclusion, intro, because, premises)
if _t.get_lang() == 'de':
intro = _t.get(_.itIsTrueThatAnonymous) if db_argument.is_supportive else _t.get(_.itIsFalseThatAnonymous)
intro = start_with_capital(intro)
intro = (start_pro if db_argument.is_supportive else start_con) + intro + end_tag
ret_value = '{} {}, {} {}'.format(intro, conclusion, because, premises)
return ret_value
def get_information_of(user: User, lang: str) -> Dict[str, Any]:
"""
Returns public information of the given user.
:param user: User whose information is queried.
:param lang: Language-string representing language of the answer.
:return: A dictionary containing the public information.
"""
if user.nickname == nick_of_anonymous_user:
return _get_special_infos(lang)
ret_dict = dict()
ret_dict['public_nick'] = user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(user.registered, lang)
ret_dict['group'] = start_with_capital(user.group.name)
ret_dict['is_male'] = user.gender == 'm'
ret_dict['is_female'] = user.gender == 'f'
ret_dict['is_neutral'] = user.gender != 'm' and user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(user, 120)
ret_dict['discussion_stat_rep'], _ = get_reputation_of(user)
return ret_dict
def __get_add_premise_text_for_justify_argument(self, confrontation,
premise, attack,
conclusion, db_argument,
is_supportive,
user_msg) -> str:
"""
Returns the text fot the add premise container during the justification for an argument
:param confrontation: String
:param premise: String
:param attack: String
:param conclusion: String
:param db_argument: Argument
:param is_supportive: Boolean
:param user_msg: String
:return: String
"""
if attack == Relations.UNDERMINE:
add_premise_text = get_text_for_add_premise_container(
self.lang, confrontation, premise, attack, conclusion,
db_argument.is_supportive)
add_premise_text = start_with_capital(add_premise_text)
elif attack == Relations.SUPPORT:
is_supportive = not is_supportive
# when the user rebuts a system confrontation, he attacks his own negated premise, therefore he supports
# is own premise. so his premise is the conclusion and we need new premises ;-)
add_premise_text = get_text_for_add_premise_container(
self.lang, confrontation, premise, attack, conclusion,
is_supportive)
elif attack == Relations.UNDERCUT:
add_premise_text = user_msg.format('', '') + ', ' + '...'
else:
add_premise_text = get_text_for_add_premise_container(
self.lang, confrontation, premise, attack, conclusion,
db_argument.is_supportive)
return add_premise_text
def get_text_for_message(nickname, lang, path, message_content, for_html=True) -> str:
"""
This method creates a message used for example in mails or messages.
:param nickname: The nickname of the addressed user
:param lang: The language to be used in the email
:param path: The url for the user where he can find the changes
:param message_content: The key variable which will be translated into a message
:param for_html: A boolean to determine if the Message should contain a clickable link
:return: A Message addressed to a user which can contain a clickable or non-clickable link
"""
_t = Translator(lang)
intro = _t.get(message_content).format(nickname)
clickForMore = start_with_capital(_t.get(_.clickForMore))
dbas_url = get_global_url()
message_appendix_auto_generated = _t.get(_.emailBodyText).format(dbas_url)
abs_path = f'{dbas_url}/discuss{path}'
link = f'<a href="{abs_path}">{clickForMore}</a>' if for_html else abs_path
msg = f'{intro}\n\n{link}\n\n---\n\n{message_appendix_auto_generated}'
return msg.replace("\n", "<br>") if for_html else msg
def get_user_with_same_opinion_for_statements(statement_uids, is_supportive, db_user, lang, main_page):
"""
Returns nested dictionary with all kinds of information about the votes of the statements.
:param statement_uids: Statement.uids
:param is_supportive: Boolean
:param db_user: User
:param lang: language
:param main_page: url
:return: {'users':[{nickname1.avatar_url, nickname1.vote_timestamp}*]}
"""
LOG.debug("Statement %s (%s)", statement_uids, is_supportive)
opinions = []
_t = Translator(lang)
title = _t.get(_.relativePopularityOfStatements)
for statement_uid in statement_uids:
statement_dict = __get_opinions_for_uid(statement_uid, is_supportive, db_user, lang, _t, main_page)
opinions.append(statement_dict)
return {'opinions': opinions, 'title': start_with_capital(title)}
def __get_rebuts_for_arguments_conclusion_uid(db_argument):
"""
Returns a list with dict(). They contain id and text of the rebuttal's pgroups
:return argument_uid: UID of the argument
:param db_argument: Argument
:return: [dict()]
"""
return_array = []
given_rebuts = set()
db_arguments = get_enabled_arguments_as_query()
db_rebuts = db_arguments.filter(Argument.is_supportive == (not db_argument.is_supportive),
Argument.conclusion_uid == db_argument.conclusion_uid).all()
for rebut in db_rebuts:
if rebut.premisegroup_uid not in given_rebuts:
given_rebuts.add(rebut.premisegroup_uid)
tmp_dict = dict()
tmp_dict['id'] = rebut.uid
text = rebut.get_premisegroup_text()
tmp_dict['text'] = start_with_capital(text)
return_array.append(tmp_dict)
return return_array
def test_start_with_capital(self):
self.assertEqual(start_with_capital(''), '')
self.assertEqual(start_with_capital('asd'), 'Asd')
self.assertEqual(start_with_capital('Asd'), 'Asd')
self.assertEqual(start_with_capital('ASD'), 'ASD')
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 __build_nested_argument(arg_array: List[Argument], first_arg_by_user,
user_changed_opinion, with_html_tag,
start_with_intro, minimize_on_undercut,
anonymous_style, premisegroup_by_user, _t):
"""
:param arg_array:
:param first_arg_by_user:
:param user_changed_opinion:
:param with_html_tag:
:param start_with_intro:
:param minimize_on_undercut:
:param anonymous_style:
:param premisegroup_by_user:
:param _t:
:return:
"""
# get all pgroups and at last, the conclusion
pgroups = []
supportive = []
arg_array = arg_array[::-1]
local_lang = arg_array[0].lang
# grepping all arguments in the chain
for db_argument in arg_array:
text = db_argument.get_premisegroup_text()
pgroups.append(text)
supportive.append(db_argument.is_supportive)
conclusion = arg_array[0].get_conclusion_text()
# html tags for framing
sb = start_position if with_html_tag else ''
se = end_tag if with_html_tag else ''
because = (', ' if local_lang == 'de' else ' ') + _t.get(
_.because).lower() + ' '
if len(
arg_array
) % 2 == 0 and not first_arg_by_user and not anonymous_style: # system starts
ret_value = _t.get(_.earlierYouArguedThat if user_changed_opinion else
_.otherUsersSaidThat) + ' '
tmp_users_opinion = True # user after system
elif not anonymous_style: # user starts
ret_value = (_t.get(_.soYourOpinionIsThat) +
': ') if start_with_intro else ''
tmp_users_opinion = False # system after user
conclusion = se + start_with_capital(conclusion) # pretty print
else:
ret_value = _t.get(_.someoneArgued) + ' '
tmp_users_opinion = False
tmp = _t.get(_.itFalseIsThat) + ' ' if not supportive[0] else ''
ret_value += tmp + conclusion + because + pgroups[0] + '.'
del pgroups[0]
# just display the last premise group on undercuts, because the story is always saved in all bubbles
if minimize_on_undercut and not user_changed_opinion and len(pgroups) > 2:
return _t.get(
_.butYouCounteredWith).strip() + ' ' + sb + pgroups[len(pgroups) -
1] + se + '.'
for i, pgroup in enumerate(pgroups):
ret_value += ' '
if tmp_users_opinion and not anonymous_style:
tmp = _.butYouCounteredWithArgument if premisegroup_by_user else _.butYouCounteredWithInterest
ret_value += _t.get(_.otherParticipantsConvincedYouThat
if user_changed_opinion else tmp)
elif not anonymous_style:
ret_value += _t.get(_.youAgreeWithThatNow)
else:
ret_value += _t.get(_.otherUsersSaidThat) if i == 0 else _t.get(
_.thenOtherUsersSaidThat)
ret_value += sb + ' ' + pgroups[i] + '.'
tmp_users_opinion = not tmp_users_opinion
return ret_value.replace(' ', ' ')
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]
