def __resolve_premisesgroup_attribute(attribute, main_page, db_languages, db_users, tmp):
text = ''
uids = []
if attribute is not None:
text = get_text_for_premisegroup_uid(attribute)
db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=attribute).join(Statement).all()
uids = [premise.statement.uid for premise in db_premises]
tmp.append('{} - {} {}'.format(attribute, text, uids))
def __handle_table_of_review_split(review, length, entry):
oem_fulltext = get_text_for_premisegroup_uid(review.premisegroup_uid)
full_text = oem_fulltext
db_values = DBDiscussionSession.query(ReviewSplitValues).filter_by(review_uid=review.uid).all()
if db_values:
full_text = str([value.content for value in db_values])
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 test_get_text_for_premisegroup_uid(self):
# premise, which is in db_premises and premise_group contains only one premise
self.assertEqual(lib.get_text_for_premisegroup_uid(uid=2), 'cats are very independent')
# premise_group with more than one premises
self.assertNotEqual(lib.get_text_for_premisegroup_uid(uid=13), 'cats are fluffy und cats are small')
val = lib.get_text_for_premisegroup_uid(uid=12)
sol1 = 'cats are fluffy and cats are small'
sol2 = 'cats are small and cats are fluffy'
self.assertIn(val, [sol1, sol2])
# premise, which is not in db_premises
self.assertEqual(lib.get_text_for_premisegroup_uid(uid=0), '')
# negative uid
self.assertEqual(lib.get_text_for_premisegroup_uid(uid=-1), '')
# language is empty string
self.assertEqual(lib.get_text_for_premisegroup_uid(uid=0), '')
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 __merge_premisegroup(review):
"""
Merges a premisegroup into the items, which are mapped with the given review
:param review: ReviewSplit.uid
:return: None
"""
db_values = DBDiscussionSession.query(ReviewMergeValues).filter_by(
review_uid=review.uid).all()
db_old_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=review.premisegroup_uid).all()
db_issue = DBDiscussionSession.query(Issue).get(
db_old_premises[0].issue_uid)
db_first_old_statement = DBDiscussionSession.query(Statement).get(
db_old_premises[0].uid)
discussion_lang = db_first_old_statement.lang
db_user = DBDiscussionSession.query(User).get(review.detector_uid)
if db_values:
logger('review.opinions',
'merge given premisegroup with the mapped, new statements')
texts = [values.content for values in db_values]
translator_discussion = Translator(discussion_lang)
new_text = ' {} '.format(translator_discussion.get(_.aand)).join(texts)
else:
logger('review.opinions', 'just merge the premisegroup')
new_text = get_text_for_premisegroup_uid(review.premisegroup_uid)
# now we have new text as a variable, let's set the statement
new_statement, tmp = set_statement(new_text, db_user,
db_first_old_statement.is_position,
db_issue)
# new premisegroup for the statement
db_new_premisegroup = PremiseGroup(author=db_user.uid)
DBDiscussionSession.add(db_new_premisegroup)
DBDiscussionSession.flush()
# new premise
db_new_premise = Premise(db_new_premisegroup.uid, new_statement.uid, False,
db_user.uid, new_statement.issue_uid)
DBDiscussionSession.add(db_new_premise)
DBDiscussionSession.flush()
logger(
'review.opinions',
'Added new premise {} with pgroup {}'.format(db_new_premise.uid,
db_new_premisegroup.uid))
# swap the premisegroup occurence in every argument
db_arguments = DBDiscussionSession.query(Argument).filter_by(
premisegroup_uid=review.premisegroup_uid).all()
for argument in db_arguments:
logger(
'review.opinions',
'Reset argument {} from pgroup {} to new pgroup {}'.format(
argument.uid, argument.premisegroup_uid,
db_new_premisegroup.uid))
argument.set_premisegroup(db_new_premisegroup.uid)
DBDiscussionSession.add(argument)
DBDiscussionSession.flush()
# add swap to database
DBDiscussionSession.add(
PremiseGroupMerged(review.uid, review.premisegroup_uid,
db_new_premisegroup.uid))
# swap the conclusion in every argument
old_statement_ids = [p.statement_uid for p in db_old_premises]
for old_statement_id in old_statement_ids:
db_arguments = DBDiscussionSession.query(Argument).filter_by(
conclusion_uid=old_statement_id).all()
for argument in db_arguments:
logger(
'review.opinions',
'Reset arguments {} from conclusion {} to new merges statement {}'
.format(argument.uid, argument.conclusion_uid,
new_statement.uid))
argument.set_conclusion(new_statement.uid)
DBDiscussionSession.add(argument)
DBDiscussionSession.add(
StatementReplacementsByPremiseGroupMerge(
review.uid, old_statement_id, new_statement.uid))
DBDiscussionSession.flush()
# finish
DBDiscussionSession.flush()
transaction.commit()
def __get_subpage_dict_for_merges(session, application_url, db_user,
translator):
"""
:param session: session of current webserver request
:param application_url: current url of the app
:param db_user: User
:param translator: Translator
:return:
"""
logger('ReviewSubpagerHelper', 'main')
db_reviews, already_seen, already_reviewed, first_time = __get_all_allowed_reviews_for_user(
session, 'already_seen_merge', db_user, ReviewMerge, LastReviewerMerge)
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(ReviewMerge).filter(
ReviewMerge.is_executed == False,
ReviewMerge.detector_uid != db_user.uid)
if len(already_reviewed) > 0:
logger('ReviewSubpagerHelper', 'everything was seen')
db_reviews = db_reviews.filter(
~ReviewMerge.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)]
premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=rnd_review.premisegroup_uid).all()
text = [premise.get_text() for premise in premises]
db_review_values = DBDiscussionSession.query(ReviewMergeValues).filter_by(
review_uid=rnd_review.uid).all()
discussion_lang = DBDiscussionSession.query(Statement).get(
premises[0].uid).lang
translator_discussion = Translator(discussion_lang)
if db_review_values:
aand = translator_discussion.get(_.aand)
merged_text = ' {} '.format(aand).join(
[rsv.content for rsv in db_review_values])
pgroup_only = False
else:
merged_text = get_text_for_premisegroup_uid(
rnd_review.premisegroup_uid)
pgroup_only = True
issue = DBDiscussionSession.query(Issue).get(premises[0].issue_uid).title
reason = translator.get(_.argumentFlaggedBecauseMerge)
stats = __get_stats_for_review(rnd_review, translator.get_lang(),
application_url)
already_seen.append(rnd_review.uid)
session['already_seen_merge'] = already_seen
return {
'stats': stats,
'text': text,
'merged_text': merged_text,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'pgroup_only': pgroup_only,
'session': session
}