def __get_text_parts_of_argument(argument):
"""
Get all parts of ana rgument as string
:param argument: Argument.uid
:return: list of strings
"""
logger('ReviewSubpagerHelper', 'main')
ret_list = list()
# get premise of current argument
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=argument.premisegroup_uid).all()
premises_uids = [premise.uid for premise in db_premises]
for uid in premises_uids:
logger('ReviewSubpagerHelper',
'add premise of argument ' + str(argument.uid))
text = get_text_for_statement_uid(uid)
ret_list.append(__get_part_dict('premise', text, argument.uid, uid))
if argument.argument_uid is None: # get conclusion of current argument
conclusion = argument.get_conclusion_text()
logger('ReviewSubpagerHelper',
'add statement of argument ' + str(argument.uid))
ret_list.append(
__get_part_dict('conclusion', conclusion, argument.uid,
argument.conclusion_uid))
else: # or get the conclusions argument
db_conclusions_argument = DBDiscussionSession.query(Argument).get(
argument.argument_uid)
while db_conclusions_argument.argument_uid is not None: # get further conclusions arguments
# get premise of conclusions arguments
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=argument.premisegroup_uid).all()
premises_uids = [premise.uid for premise in db_premises]
for uid in premises_uids:
text = get_text_for_statement_uid(uid)
logger(
'ReviewSubpagerHelper', 'add premise of argument ' +
str(db_conclusions_argument.uid))
ret_list.append(
__get_part_dict('premise', text,
db_conclusions_argument.uid, uid))
db_conclusions_argument = DBDiscussionSession.query(Argument).get(
db_conclusions_argument.argument_uid)
# get the last conclusion of the chain
conclusion = db_conclusions_argument.get_conclusion_text()
logger('ReviewSubpagerHelper',
'add statement of argument ' + str(db_conclusions_argument.uid))
ret_list.append(
__get_part_dict('conclusion', conclusion,
db_conclusions_argument.uid,
db_conclusions_argument.conclusion_uid))
return ret_list[::-1]
def test_get_text_for_statement_uid(self):
# id for no statement
self.assertIsNone(lib.get_text_for_statement_uid(uid=0))
# id for statement, which ends with '.'
self.assertEqual(lib.get_text_for_statement_uid(uid=3), 'we should get a dog')
# id for statement, which ends with '!'
self.assertEqual(lib.get_text_for_statement_uid(uid=31), 'it is important, that pets are small and fluffy')
# negative uid
self.assertIsNone(lib.get_text_for_statement_uid(uid=-30))
def __validate_reference_data(self, uids, ddict):
for key in ddict:
self.assertIn(key, uids)
refs = ddict[key]
for ref in refs:
self.assertIn('uid', ref)
self.assertIn('statement_text', ref)
self.assertEquals(ref['statement_text'],
get_text_for_statement_uid(key))
db_ref = DBDiscussionSession.query(StatementReference).get(
ref['uid'])
self.assertEquals(
ref['statement_text'],
get_text_for_statement_uid(db_ref.statement_uid))
def get_logfile_for_statements(uids, lang, main_page):
"""
Returns the logfile for the given statement uid
:param uids: requested statement uid
:param lang: ui_locales ui_locales
:param main_page: URL
:return: dictionary with the logfile-rows
"""
logger('StatementsHelper', 'def with uid: ' + str(uids))
main_dict = dict()
for uid in uids:
db_textversions = DBDiscussionSession.query(TextVersion).filter_by(statement_uid=uid).order_by(
TextVersion.uid.asc()).all() # TODO #432
if len(db_textversions) == 0:
continue
return_dict = dict()
content_dict = dict()
# add all corrections
for index, version in enumerate(db_textversions):
content_dict[str(index)] = __get_logfile_dict(version, main_page, lang)
return_dict['content'] = content_dict
main_dict[get_text_for_statement_uid(uid)] = return_dict
return main_dict
def __handle_table_of_review_duplicate(review, length, entry):
text = get_text_for_statement_uid(review.original_statement_uid)
if text is None:
text = '...'
entry['statement_duplicate_shorttext'] = text[0:length] + ('...' if len(text) > length else '')
entry['statement_duplicate_fulltext'] = text
return entry
def get_marked_elements_of(db_user: User, is_argument: bool, lang: str):
"""
Get all marked arguments/statements of the user
:param db_user: User
:param is_argument: Boolean
:param lang: uid_locales
:return: [{},...]
"""
return_array = []
if is_argument:
db_votes = DBDiscussionSession.query(MarkedArgument).filter_by(author_uid=db_user.uid).all()
else:
db_votes = DBDiscussionSession.query(MarkedStatement).filter_by(author_uid=db_user.uid).all()
for vote in db_votes:
vote_dict = dict()
vote_dict['uid'] = str(vote.uid)
vote_dict['timestamp'] = sql_timestamp_pretty_print(vote.timestamp, lang)
if is_argument:
vote_dict['argument_uid'] = str(vote.argument_uid)
vote_dict['content'] = get_text_for_argument_uid(vote.argument_uid, lang)
else:
vote_dict['statement_uid'] = str(vote.statement_uid)
vote_dict['content'] = get_text_for_statement_uid(vote.statement_uid)
return_array.append(vote_dict)
return return_array
def insert_as_statement(text: str, db_user: User, db_issue: Issue, is_start=False) -> Statement:
"""
Inserts the given text as statement and returns the uid
:param text: String
:param db_user: User
:param db_issue: Issue
:param is_start: Boolean
:return: Statement
"""
new_statement, is_duplicate = set_statement(text, db_user, is_start, db_issue)
# add marked statement
DBDiscussionSession.add(MarkedStatement(statement=new_statement.uid, user=db_user.uid))
DBDiscussionSession.add(SeenStatement(statement_uid=new_statement.uid, user_uid=db_user.uid))
DBDiscussionSession.flush()
_tn = Translator(db_issue.lang)
_um = UrlManager(db_issue.slug)
append_action_to_issue_rss(db_issue=db_issue, db_author=db_user,
title=_tn.get(_.positionAdded if is_start else _.statementAdded),
description='...' + get_text_for_statement_uid(new_statement.uid) + '...',
url=_um.get_url_for_statement_attitude(new_statement.uid))
return new_statement
def get_clicked_elements_of(db_user: User, is_argument: bool, lang: str) -> list:
"""
Returns array with all clicked elements by the user. Each element is a dict with information like the uid,
timestamp, up_Vote, validity, the clicked uid and content of the clicked element.
:param db_user: User
:param is_argument: Boolean
:param lang: ui_locales
:return: [{},...]
"""
return_array = []
db_type = ClickedArgument if is_argument else ClickedStatement
db_clicks = DBDiscussionSession.query(db_type).filter_by(author_uid=db_user.uid).all()
for click in db_clicks:
click_dict = dict()
click_dict['uid'] = click.uid
click_dict['timestamp'] = sql_timestamp_pretty_print(click.timestamp, lang)
click_dict['is_up_vote'] = click.is_up_vote
click_dict['is_valid'] = click.is_valid
if is_argument:
click_dict['argument_uid'] = click.argument_uid
click_dict['content'] = get_text_for_argument_uid(click.argument_uid, lang)
else:
click_dict['statement_uid'] = click.statement_uid
click_dict['content'] = get_text_for_statement_uid(click.statement_uid)
return_array.append(click_dict)
return return_array
def get_dict_for_choosing(self, uid, is_uid_argument,
is_supportive) -> dict:
"""
Prepares the discussion dict with all bubbles for the choosing an premise,
when the user inserted more than one new premise.
:param uid: Argument.uid
:param is_uid_argument: Boolean
:param is_supportive: Boolean
:return:
"""
_tn = Translator(self.lang)
bubbles_array = history_helper.create_bubbles_from_history(
self.history, self.nickname, self.lang, self.slug)
add_premise_text = ''
save_statement_url = 'set_new_start_statement'
logger('DictionaryHelper', 'at_choosing')
a = _tn.get(_.soYouEnteredMultipleReasons)
c = get_text_for_argument_uid(
uid) if is_uid_argument else get_text_for_statement_uid(uid)
if is_supportive:
if is_uid_argument:
b = _tn.get(_.whatIsYourMostImportantReasonForArgument)
else:
b = _tn.get(_.whatIsYourMostImportantReasonForStatement)
else:
if is_uid_argument:
b = _tn.get(_.whatIsYourMostImportantReasonAgainstArgument)
else:
b = _tn.get(_.whatIsYourMostImportantReasonAgainstStatement)
b = b.replace('{}', '')
text = '{}. {}: {}?<br>{}...'.format(a, b, c, _tn.get(_.because))
self.__append_now_bubble(bubbles_array)
question_bubble = create_speechbubble_dict(BubbleTypes.SYSTEM,
uid='question-bubble',
content=text,
omit_bubble_url=True,
lang=self.lang)
if not bubbles_already_last_in_list(bubbles_array, question_bubble):
bubbles_array.append(question_bubble)
return {
'bubbles': bubbles_array,
'add_premise_text': add_premise_text,
'save_statement_url': save_statement_url,
'mode': '',
'broke_limit': self.broke_limit
}
def __handle_table_of_review_merge(review, length, entry):
db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=review.premisegroup_uid).all()
oem_fulltext = str([get_text_for_statement_uid(p.statement_uid) for p in db_premises])
full_text = oem_fulltext
db_values = DBDiscussionSession.query(ReviewMergeValues).filter_by(review_uid=review.uid).all()
if db_values:
full_text = str([value.content for value in db_values])
full_text = ' and '.join(full_text)
entry['argument_oem_shorttext'] = oem_fulltext[0:length] + '...' if len(oem_fulltext) > length else oem_fulltext
entry['argument_oem_fulltext'] = oem_fulltext
entry['argument_shorttext'] = full_text[0:length] + '...' if len(full_text) > length else full_text
entry['argument_fulltext'] = full_text
return entry
def get_references_for_statements(uids, main_page):
"""
Returns all references for the current given statements
:param uid: uids of the statement
:param main_page: current main page
:return: dict
"""
data = {}
text = {}
for uid in uids:
references_array = __get_references_for_statement(uid, main_page)[uid]
data[uid] = references_array
text[uid] = get_text_for_statement_uid(uid)
return data, text
def __get_opinions_for_uid(uid, is_supportive, db_user, lang, _t, main_page):
none_dict = {
'uid': None,
'text': None,
'message': None,
'users': None,
'seen_by': None
}
statement_dict = dict()
all_users = []
db_statement = DBDiscussionSession.query(Statement).get(uid)
if not db_statement:
statement_dict.update(none_dict)
statement_dict['uid'] = str(uid)
text = get_text_for_statement_uid(uid)
try:
if db_statement.is_position and lang == 'de':
text = _t.get(_.statementIsAbout) + ' ' + text
statement_dict['text'] = text
except TypeError:
statement_dict.update(none_dict)
is_supportive = (True if str(is_supportive) == 'True' else
False) if is_supportive is not None else False
db_votes = DBDiscussionSession.query(ClickedStatement).filter(
ClickedStatement.statement_uid == uid,
ClickedStatement.is_up_vote == is_supportive,
ClickedStatement.is_valid == True,
ClickedStatement.author_uid != db_user.uid).all()
for vote in db_votes:
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)
statement_dict['users'] = all_users
statement_dict['message'] = __get_text_for_clickcount(
len(db_votes), db_user.uid, _t)
db_seen_by = DBDiscussionSession.query(SeenStatement).filter_by(
statement_uid=int(uid)).all()
statement_dict['seen_by'] = len(db_seen_by) if db_seen_by else 0
return statement_dict
def get_references_for_argument(uid, main_page):
"""
Returns all references for the premises group of given argument
:param uid: uid of the argument
:param main_page: current main page
:return: dict
"""
logger('ReferenceHelper', str(uid))
if not is_integer(uid):
return {}, {}
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter_by(uid=uid).first()
if not db_argument:
return {}, {}
db_premises = get_enabled_premises_as_query()
db_premises = db_premises.filter_by(
premisegroup_uid=db_argument.premisegroup_uid).all()
data = {}
text = {}
for premise in db_premises:
tmp_uid = premise.statement_uid
references_array = __get_references_for_statement(tmp_uid,
main_page)[tmp_uid]
data[premise.statement_uid] = references_array
text[premise.statement_uid] = premise.get_text()
if db_argument.conclusion_uid is not None:
tmp_uid = db_argument.conclusion_uid
references_array = __get_references_for_statement(tmp_uid,
main_page)[tmp_uid]
data[tmp_uid] = references_array
text[tmp_uid] = get_text_for_statement_uid(tmp_uid)
else:
d, t = get_references_for_argument(db_argument.argument_uid, main_page)
data.update(d)
text.update(t)
return data, text
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-premise-container
:param stmt_uid: Statement.uid
:param db_user: User
:param is_supportive: Boolean
:param _tn: Translator
:return: String, String
"""
logger('BubbleHelper', '{} {}'.format(stmt_uid, is_supportive))
text = get_text_for_statement_uid(stmt_uid)
if _tn.get_lang() == 'de':
intro = _tn.get(_.itIsTrueThat if is_supportive else _.itIsFalseThat)
add_premise_text = intro[0:1].upper() + intro[1:] + ' ' + text
else:
add_premise_text = 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_bubble_from_attitude_step(step, nickname, lang, url):
"""
Creates bubbles for the attitude-keyword for an statement.
:param step: String
:param nickname: User.nickname
:param lang: ui_locales
:param url: String
:return: [dict()]
"""
logger('history_handler', 'def')
steps = step.split('/')
uid = int(steps[1])
text = get_text_for_statement_uid(uid)
if lang != 'de':
text = text[0:1].upper() + text[1:]
bubble = create_speechbubble_dict(BubbleTypes.USER, content=text, omit_bubble_url=False, statement_uid=uid,
nickname=nickname,
lang=lang, bubble_url=url)
return [bubble]
def __get_executed_review_element_of(table, main_page, review, last_review_type, translator, is_executed):
"""
:param table: Shortcut for the table
:param main_page: Main page of D-BAS
:param review: Element
:param last_review_type: Type of the last reviewer of the table
:param translator: current ui_locales
:param is_executed
:return: Element
"""
length = 35
# getting text
if table == 'duplicates':
full_text = get_text_for_statement_uid(review.duplicate_statement_uid)
elif table in ['splits', 'merges']:
full_text = get_text_for_premisegroup_uid(review.premisegroup_uid)
elif review.statement_uid is None:
full_text = get_text_for_argument_uid(review.argument_uid)
else:
full_text = get_text_for_statement_uid(review.statement_uid)
# pretty print
intro = translator.get(_.otherUsersSaidThat) + ' '
if full_text.startswith(intro):
short_text = full_text[len(intro):len(intro) + 1].upper() + full_text[len(intro) + 1:len(intro) + length]
else:
short_text = full_text[0:length]
short_text += '...' if len(full_text) > length else '.'
short_text = '<span class="text-primary">' + short_text + '</span>'
all_votes = DBDiscussionSession.query(last_review_type).filter_by(review_uid=review.uid)
is_okay = False if table == 'optimizations' else True
if table is 'merges':
pro_votes = all_votes.filter_by(should_merge=is_okay).all()
con_votes = all_votes.filter(last_review_type.should_merge != is_okay).all()
elif table is 'splits':
pro_votes = all_votes.filter_by(should_split=is_okay).all()
con_votes = all_votes.filter(last_review_type.should_split != is_okay).all()
else:
pro_votes = all_votes.filter_by(is_okay=is_okay).all()
con_votes = all_votes.filter(last_review_type.is_okay != is_okay).all()
# getting the users which have voted
pro_list = [__get_user_dict_for_review(pro.reviewer_uid, main_page) for pro in pro_votes]
con_list = [__get_user_dict_for_review(con.reviewer_uid, main_page) for con in con_votes]
if table == 'duplicates':
# switch it, because contra is: it should not be there!
tmp_list = pro_list
pro_list = con_list
con_list = tmp_list
# and build up some dict
entry = dict()
entry['entry_id'] = review.uid
tmp = __handle_table_of_review_element(table, entry, review, short_text, full_text, length, is_executed)
if not tmp:
entry = None
else:
entry.update(tmp)
entry['pro'] = pro_list
entry['con'] = con_list
entry['timestamp'] = sql_timestamp_pretty_print(review.timestamp, translator.get_lang())
entry['votes_pro'] = pro_list
entry['votes_con'] = con_list
entry['reporter'] = __get_user_dict_for_review(review.detector_uid, main_page)
return entry
def __get_subpage_dict_for_duplicates(session, application_url, db_user,
translator):
"""
Setup the subpage for the duplicates queue
:param session: session of current webserver request
:param application_url: current url of the app
:param db_user: User
:param translator: Translator
:return: dict()
"""
logger('ReviewSubpagerHelper', 'main')
db_reviews, already_seen, already_reviewed, first_time = __get_all_allowed_reviews_for_user(
session, 'already_seen_duplicate', db_user, ReviewDuplicate,
LastReviewerDuplicate)
extra_info = ''
# if we have no reviews, try again with fewer restrictions
if not db_reviews:
logger('ReviewSubpagerHelper', 'no unseen reviews')
already_seen = list()
extra_info = 'already_seen' if not first_time else ''
db_reviews = DBDiscussionSession.query(ReviewDuplicate).filter(
ReviewDuplicate.is_executed == False,
ReviewDuplicate.detector_uid != db_user.uid)
if len(already_reviewed) > 0:
logger('ReviewSubpagerHelper', 'everything was seen')
db_reviews = db_reviews.filter(
~ReviewDuplicate.uid.in_(already_reviewed))
db_reviews = db_reviews.all()
if not db_reviews:
logger('ReviewSubpagerHelper', 'no reviews')
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'extra_info': None,
'session': session
}
rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)]
db_statement = DBDiscussionSession.query(Statement).get(
rnd_review.duplicate_statement_uid)
text = db_statement.get_text()
issue = DBDiscussionSession.query(Issue).get(db_statement.issue_uid).title
reason = translator.get(_.argumentFlaggedBecauseDuplicate)
duplicate_of_text = get_text_for_statement_uid(
rnd_review.original_statement_uid)
stats = __get_stats_for_review(rnd_review, translator.get_lang(),
application_url)
already_seen.append(rnd_review.uid)
session['already_seen_duplicate'] = already_seen
return {
'stats': stats,
'text': text,
'duplicate_of': duplicate_of_text,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'session': session
}
def __validate_reference_text(self, uids, ddict):
for key in ddict:
self.assertIn(key, uids)
self.assertEquals(ddict[key], get_text_for_statement_uid(key))
def __resolve_statement_attribute(attribute, main_page, db_languages, db_users, tmp):
text = get_text_for_statement_uid(attribute) if attribute is not None else 'None'
tmp.append(str(attribute) + ' - ' + str(text))
