def collection_get(self):
return DBDiscussionSession.query(Issue).filter(Issue.is_disabled == False,
Issue.is_private == False).all()
def add_review_opinion_for_merge(db_user, main_page, db_review, should_merge,
_t):
"""
Adds row to the merge review
:param request: Pyramids request object
:param review_uid: ReviewMerge
:param should_merge: True, if it should be merged
:param _t: Translator
:return: String
"""
logger('review.opinions', 'main {}'.format(db_review.uid))
db_user_created_flag = DBDiscussionSession.query(User).get(
db_review.detector_uid)
# add new vote
__add_vote_for(db_user, db_review, should_merge, LastReviewerMerge)
broke_limit = False
# get all keep and delete votes
count_of_keep, count_of_reset = __get_review_count(LastReviewerMerge,
db_review.uid)
logger('review.opinions',
'result ' + str(count_of_keep) + ':' + str(count_of_reset))
# do we reached any limit?
reached_max = max(count_of_keep, count_of_reset) >= max_votes
if reached_max:
if count_of_keep > count_of_reset: # split pgroup
logger('review.opinions',
'max reached for review {}'.format(db_review.uid))
__merge_premisegroup(db_review)
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_success_flag)
else: # just close the review
logger(
'review.opinions',
'max reached / forget about review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_reset - count_of_keep >= min_difference: # just close the review
logger('review.opinions',
'vote says forget about review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_keep - count_of_reset >= min_difference: # split pgroup
logger('review.opinions',
'vote says merge for review {}'.format(db_review.uid))
__merge_premisegroup(db_review)
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_success_flag)
db_review.set_executed(True)
db_review.update_timestamp()
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
if broke_limit:
send_request_for_info_popup_to_socketio(
db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow),
main_page + '/review')
return ''
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_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 add_review_opinion_for_duplicate(db_user, main_page, db_review,
is_duplicate, _t):
"""
Adds row to the duplicate review
:param request: Pyramids request object
:param is_duplicate: Boolean
:param review_uid: ReviewDuplicate.uid
:param _t: Translator
:return: String
"""
logger('review.opinions',
'main {}, duplicate {}'.format(db_review.uid, is_duplicate))
db_user_created_flag = DBDiscussionSession.query(User).get(
db_review.detector_uid)
# add new vote
__add_vote_for(db_user, db_review, not is_duplicate, LastReviewerDuplicate)
broke_limit = False
# get all keep and delete votes
count_of_keep, count_of_reset = __get_review_count(LastReviewerDuplicate,
db_review.uid)
logger('review.opinions',
'result ' + str(count_of_keep) + ':' + str(count_of_reset))
# do we reached any limit?
reached_max = max(count_of_keep, count_of_reset) >= max_votes
if reached_max:
if count_of_reset > count_of_keep: # disable the flagged part
logger('review.opinions',
'max reached / bend for review {}'.format(db_review.uid))
__bend_objects_of_duplicate_review(db_review)
add_rep, broke_limit = add_reputation_for(
db_user_created_flag, rep_reason_success_duplicate)
else: # just close the review
logger(
'review.opinions',
'max reached / forget about review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(
db_user_created_flag, rep_reason_bad_duplicate)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_keep - count_of_reset >= min_difference: # just close the review
logger('review.opinions',
'vote says forget about review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_bad_duplicate)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_reset - count_of_keep >= min_difference: # disable the flagged part
logger('review.opinions',
'vote says bend for review {}'.format(db_review.uid))
__bend_objects_of_duplicate_review(db_review)
add_rep, broke_limit = add_reputation_for(
db_user_created_flag, rep_reason_success_duplicate)
db_review.set_executed(True)
db_review.update_timestamp()
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
if broke_limit:
send_request_for_info_popup_to_socketio(
db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow),
main_page + '/review')
return True
def setUp(self):
self.config = testing.setUp()
self.user = DBDiscussionSession.query(User).filter_by(
nickname='Tobias').first()
def __get_subpage_dict_for_optimization(session, application_url, db_user,
translator):
"""
Setup the subpage for the optimization 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_optimization', db_user, ReviewOptimization,
LastReviewerOptimization)
extra_info = ''
# if we have no reviews, try again with fewer restrictions
if not db_reviews:
already_seen = list()
extra_info = 'already_seen' if not first_time else ''
db_reviews = DBDiscussionSession.query(ReviewOptimization).filter(
ReviewOptimization.is_executed == False,
ReviewOptimization.detector_uid != db_user.uid)
if len(already_reviewed) > 0:
db_reviews = db_reviews.filter(
~ReviewOptimization.uid.in_(already_reviewed))
db_reviews = db_reviews.all()
if not db_reviews:
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'context': [],
'extra_info': None,
'session': session
}
rnd_review = db_reviews[random.randint(0, len(db_reviews) - 1)]
if rnd_review.statement_uid is None:
db_argument = DBDiscussionSession.query(Argument).get(
rnd_review.argument_uid)
text = get_text_for_argument_uid(db_argument.uid)
issue = DBDiscussionSession.query(Issue).get(
db_argument.issue_uid).title
parts = __get_text_parts_of_argument(db_argument)
context = [text]
else:
db_statement = DBDiscussionSession.query(Statement).get(
rnd_review.statement_uid)
text = db_statement.get_text()
issue = DBDiscussionSession.query(Issue).get(
db_statement.issue_uid).title
parts = [
__get_part_dict('statement', text, 0, rnd_review.statement_uid)
]
context = []
args = get_all_arguments_by_statement(rnd_review.statement_uid)
if args:
context = [
get_text_for_argument_uid(arg.uid).replace(
text, '<span class="text-info"><strong>{}</strong></span>'.
format(text)) for arg in args
]
reason = translator.get(_.argumentFlaggedBecauseOptimization)
stats = __get_stats_for_review(rnd_review, translator.get_lang(),
application_url)
already_seen.append(rnd_review.uid)
session['already_seen_optimization'] = already_seen
return {
'stats': stats,
'text': text,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'context': context,
'parts': parts,
'session': session
}
def test_get_public_profile_picture(self):
user = DBDiscussionSession.query(User).get(1)
self.assertIn('gravatar.com', lib.get_profile_picture(user))
self.assertIn('80', lib.get_profile_picture(user))
self.assertIn('gravatar.com', lib.get_profile_picture(user, size=120))
self.assertIn('120', lib.get_profile_picture(user, size=120))
def test_get_enabled_issues_as_query(self):
query_len = get_enabled_issues_as_query().count()
res_len = DBDiscussionSession.query(Issue).filter_by(is_disabled=False).count()
self.assertEqual(res_len, query_len)
def test_is_user_author_or_admin(self):
db_user1 = DBDiscussionSession.query(User).filter_by(nickname='Tobias').first()
db_user2 = DBDiscussionSession.query(User).filter_by(nickname='Pascal').first()
self.assertTrue(db_user1.is_admin() or db_user1.is_author())
self.assertFalse(db_user2.is_admin() or db_user2.is_author())
def test_is_user_admin(self):
self.assertTrue(DBDiscussionSession.query(User).filter_by(nickname='Tobias').first().is_admin())
self.assertFalse(DBDiscussionSession.query(User).filter_by(nickname='Pascal').first().is_admin())
def test_get_user_by_case_insensitive_public_nickname(self):
user = DBDiscussionSession.query(User).get(2)
self.assertIsNotNone(lib.get_user_by_case_insensitive_public_nickname(user.public_nickname.lower()))
self.assertIsNotNone(lib.get_user_by_case_insensitive_public_nickname(user.public_nickname.upper()))
self.assertIsNone(lib.get_user_by_case_insensitive_public_nickname('puh_der_bär'))
def get_queue_information(self, db_user: User, session: Session,
application_url: str, translator: Translator):
"""
Setup the sub-page for the split queue
:param db_user: User
:param session: session of current web-server request
:param application_url: current url of the app
:param translator: Translator
:return: dict()
"""
LOG.debug("Setting up the sub-page for the split queue")
all_rev_dict = get_all_allowed_reviews_for_user(
session, f'already_seen_{self.key}', db_user, ReviewSplit,
LastReviewerSplit)
extra_info = ''
# if we have no reviews, try again with fewer restrictions
if not all_rev_dict['reviews']:
LOG.debug("No unseen reviews")
all_rev_dict['already_seen_reviews'] = list()
extra_info = 'already_seen' if not all_rev_dict[
'first_time'] else ''
db_reviews = DBDiscussionSession.query(ReviewSplit).filter(
ReviewSplit.is_executed == False,
ReviewSplit.detector_uid != db_user.uid)
if len(all_rev_dict['already_voted_reviews']) > 0:
LOG.debug("Everything was seen")
db_reviews = db_reviews.filter(~ReviewSplit.uid.in_(
all_rev_dict['already_voted_reviews']))
all_rev_dict['reviews'] = db_reviews.all()
if not all_rev_dict['reviews']:
LOG.debug("No reviews available")
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'extra_info': None,
'issue_titles': [],
'session': session
}
rnd_review = random.choice(all_rev_dict['reviews'])
premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=rnd_review.premisegroup_uid).all()
text = DBDiscussionSession.query(PremiseGroup).get(
rnd_review.premisegroup_uid).get_text()
db_review_values = DBDiscussionSession.query(
ReviewSplitValues).filter_by(review_uid=rnd_review.uid).all()
if db_review_values:
splitted_text = [rsv.content for rsv in db_review_values]
pgroup_only = False
else:
splitted_text = [premise.get_text() for premise in premises]
pgroup_only = True
issue = DBDiscussionSession.query(Issue).get(
premises[0].issue_uid).title
reason = translator.get(_.argumentFlaggedBecauseSplit)
statement_uids = [p.statement_uid for p in premises]
issue_titles = [
issue.title
for issue in get_issues_for_statement_uids(statement_uids)
]
stats = get_reporter_stats_for_review(rnd_review,
translator.get_lang(),
application_url)
all_rev_dict['already_seen_reviews'].append(rnd_review.uid)
session[f'already_seen_{self.key}'] = all_rev_dict[
'already_seen_reviews']
return {
'stats': stats,
'text': text,
'splitted_text': splitted_text,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'pgroup_only': pgroup_only,
'issue_titles': issue_titles,
'session': session
}
def collection_get():
db_users: List[User] = DBDiscussionSession.query(User).all()
return [ApiUser.external_view(db_user) for db_user in db_users]
def tearDown(self):
testing.tearDown()
DBDiscussionSession.query(Argument).get(1).set_disabled(False)
transaction.commit()
def test_is_argument_disabled_due_to_disabled_statements(self):
arg1 = DBDiscussionSession.query(Argument).get(1)
arg2 = DBDiscussionSession.query(Argument).get(2)
self.assertFalse(lib.is_argument_disabled_due_to_disabled_statements(arg2))
self.assertTrue(lib.is_argument_disabled_due_to_disabled_statements(arg1))
def get_array_for_start(self, db_user: User) -> dict:
"""
Prepares the dict with all items for the first step in discussion, where the user chooses a position.
:param db_user: User
:return:
"""
LOG.debug("Entering get_array_for_start with user: %s", db_user.nickname)
statements = [el.statement_uid for el in
DBDiscussionSession.query(StatementToIssue).filter_by(issue_uid=self.db_issue.uid).all()]
db_statements = DBDiscussionSession.query(Statement) \
.filter(Statement.is_disabled == False,
Statement.is_position == True,
Statement.uid.in_(statements)).all()
uids = [element.uid for element in db_statements if db_statements]
slug = self.db_issue.slug
statements_array = []
_um = UrlManager(slug, history=self.path)
ed = EditQueue()
for statement in db_statements:
if statement.uid in uids: # add seen by if the statement is visible
add_seen_statement(statement.uid, db_user)
position_dict = self.__create_answer_dict(statement.uid,
[{
'title': statement.get_text(),
'id': statement.uid
}],
'start',
_um.get_url_for_statement_attitude(statement.uid),
is_editable=not ed.is_statement_in_edit_queue(
statement.uid),
is_markable=True,
is_author=is_author_of_statement(db_user, statement.uid),
is_visible=statement.uid in uids)
if self.db_issue.decision_process:
position_dict['cost'] = DBDiscussionSession.query(PositionCost).get(statement.uid).cost
statements_array.append(position_dict)
_tn = Translator(self.lang)
shuffle_list_by_user(db_user, statements_array)
if not self.issue_read_only:
if db_user.nickname == nick_of_anonymous_user:
statements_array.append(self.__create_answer_dict('login',
[{
'id': '0',
'title': _tn.get(_.wantToStateNewPosition)
}],
'justify',
'login'))
else:
title = _tn.get(_.newConclusionRadioButtonText) if len(db_statements) > 0 else _tn.get(
_.newConclusionRadioButtonTextNewIdea)
statements_array.append(self.__create_answer_dict('start_statement',
[{'title': title, 'id': 0}],
'start',
'add'))
return {'elements': statements_array, 'extras': {'cropped_list': len(uids) < len(db_statements)}}
def test_unlock_optimization_review(self):
_tn = Translator('en')
db_review = DBDiscussionSession.query(ReviewOptimization).get(2)
rqh.unlock_optimization_review(db_review, _tn)
self.assertFalse(rqh.is_review_locked(db_review.uid))
def get_subpage_elements_for(nickname, session, application_url, subpage_name,
translator):
"""
Returns subpage for a specific review queue
:param nickname: current nickname in the request
:param session: current session in the request
:param application_url: current application_url in the request
:param subpage_name: String
:param translator: Translator
:return: dict()
"""
logger('ReviewSubpagerHelper', subpage_name)
db_user = DBDiscussionSession.query(User).filter_by(
nickname=nickname).first()
user_has_access = False
no_arguments_to_review = False
button_set = {
'is_delete': False,
'is_optimize': False,
'is_edit': False,
'is_duplicate': False,
'is_split': False,
'is_merge': False
}
# does the subpage exists
if subpage_name not in review_queues and subpage_name != 'history':
logger('ReviewSubpagerHelper', 'No page found', error=True)
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
rep_count, all_rights = get_reputation_of(nickname)
user_has_access = rep_count >= reputation_borders[
subpage_name] or all_rights
# does the user exists and does he has the rights for this queue?
if not db_user or not user_has_access:
logger('ReviewSubpagerHelper', 'No user found', error=True)
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
ret_dict = {'page_name': subpage_name}
text = translator.get(_.internalError)
issue = translator.get(_.internalError)
reason = ''
stats = ''
if subpage_name == 'deletes':
subpage_dict = __get_subpage_dict_for_deletes(session, application_url,
db_user, translator)
button_set['is_delete'] = True
elif subpage_name == 'optimizations':
subpage_dict = __get_subpage_dict_for_optimization(
session, application_url, db_user, translator)
button_set['is_optimize'] = True
elif subpage_name == 'edits':
subpage_dict = __get_subpage_dict_for_edits(session, application_url,
db_user, translator)
button_set['is_edit'] = True
elif subpage_name == 'duplicates':
subpage_dict = __get_subpage_dict_for_duplicates(
session, application_url, db_user, translator)
button_set['is_duplicate'] = True
elif subpage_name == 'splits':
subpage_dict = __get_subpage_dict_for_splits(session, application_url,
db_user, translator)
button_set['is_split'] = True
elif subpage_name == 'merges':
subpage_dict = __get_subpage_dict_for_merges(session, application_url,
db_user, translator)
button_set['is_merge'] = True
else:
subpage_dict = {
'stats': stats,
'text': text,
'reason': reason,
'issue': issue,
'session': {}
}
# logger('ReviewSubpagerHelper', 'get_subpage_elements_for', 'subpage_dict ' + str(subpage_dict))
ret_dict['reviewed_element'] = subpage_dict
ret_dict['session'] = subpage_dict['session']
if subpage_dict['text'] is None and subpage_dict[
'reason'] is None and subpage_dict['stats'] is None:
no_arguments_to_review = True
return __get_subpage_dict(None, user_has_access,
no_arguments_to_review, button_set)
return __get_subpage_dict(ret_dict, True, no_arguments_to_review,
button_set)
def test_get_complete_review_count(self):
u1 = DBDiscussionSession.query(User).get(1)
u2 = DBDiscussionSession.query(User).get(2)
self.assertEqual(0, rqh.get_complete_review_count(u1))
self.assertLess(0, rqh.get_complete_review_count(u2))
def __get_subpage_dict_for_edits(session, application_url, db_user,
translator):
"""
Setup the subpage for the edits 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_edit', db_user, ReviewEdit, LastReviewerEdit)
rnd_review, already_seen, extra_info, text, issue = __get_base_subpage_dict(
ReviewEdit, db_reviews, already_seen, first_time, db_user,
already_reviewed)
if not rnd_review:
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'extra_info': None,
'session': session
}
reason = translator.get(_.argumentFlaggedBecauseEdit)
# build correction
db_edit_value = DBDiscussionSession.query(ReviewEditValue).filter_by(
review_edit_uid=rnd_review.uid).first()
stats = __get_stats_for_review(rnd_review, translator.get_lang(),
application_url)
if not db_edit_value:
logger('ReviewSubpagerHelper',
'ReviewEdit {} has no edit value!'.format(rnd_review.uid),
error=True)
# get all valid reviews
db_allowed_reviews = DBDiscussionSession.query(ReviewEdit).filter(
ReviewEdit.uid.in_(
DBDiscussionSession.query(
ReviewEditValue.review_edit_uid))).all()
if len(db_allowed_reviews) > 0:
return __get_subpage_dict_for_edits(session, db_user, translator,
application_url)
else:
return {
'stats': None,
'text': None,
'reason': None,
'issue': None,
'extra_info': None,
'session': session
}
correction_list = [char for char in text]
__difference_between_string(text, db_edit_value.content, correction_list)
correction = ''.join(correction_list)
already_seen.append(rnd_review.uid)
session['already_seen_edit'] = already_seen
return {
'stats': stats,
'text': text,
'corrected_version': db_edit_value.content,
'corrections': correction,
'reason': reason,
'issue': issue,
'extra_info': extra_info,
'session': session
}
def __create_reaction_history_bubbles(step: str, db_user: User, lang: str, splitted_history: list, url: str,
color_steps: list, uid: int, additional_uid: int,
attack) -> list:
is_supportive = DBDiscussionSession.query(Argument).get(uid).is_supportive
last_relation = splitted_history[-1].split('/')[2] if len(splitted_history) > 1 else ''
user_changed_opinion = len(splitted_history) > 1 and '/undercut/' in splitted_history[-2]
support_counter_argument = False
if step in splitted_history:
index = splitted_history.index(step)
try:
support_counter_argument = 'reaction' in splitted_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 __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
}
def get_text_for_argument_uid(uid, nickname=None, with_html_tag=False, start_with_intro=False, first_arg_by_user=False,
user_changed_opinion=False, rearrange_intro=False, colored_position=False,
attack_type=None, minimize_on_undercut=False, is_users_opinion=True,
anonymous_style=False, support_counter_argument=False):
"""
Returns current argument as string like "conclusion, because premise1 and premise2"
:param uid: Integer
:param nickname: String
:param with_html_tag: Boolean
:param start_with_intro: Boolean
:param first_arg_by_user: Boolean
:param user_changed_opinion: Boolean
:param rearrange_intro: Boolean
:param colored_position: Boolean
:param attack_type: String
:param minimize_on_undercut: Boolean
:param anonymous_style: Boolean
:param support_counter_argument: Boolean
:param is_users_opinion: Boolean
:return: String
"""
LOG.debug("main %s", uid)
db_argument = DBDiscussionSession.query(Argument).get(uid)
if not db_argument:
return None
lang = db_argument.lang
_t = Translator(lang)
premisegroup_by_user = False
author_uid = None
db_user = DBDiscussionSession.query(User).filter_by(nickname=str(nickname)).first()
if db_user:
author_uid = db_user.uid
pgroup = DBDiscussionSession.query(PremiseGroup).get(db_argument.premisegroup_uid)
marked_argument = DBDiscussionSession.query(MarkedArgument).filter_by(
argument_uid=uid,
author_uid=db_user.uid).first()
premisegroup_by_user = pgroup.author_uid == db_user.uid or marked_argument is not None
# getting all argument id
arg_array = [db_argument]
while db_argument.argument_uid:
db_argument = DBDiscussionSession.query(Argument).get(db_argument.argument_uid)
arg_array.append(db_argument)
if attack_type == 'jump':
return __build_argument_for_jump(arg_array, with_html_tag)
if len(arg_array) == 1:
# build one argument only
return __build_single_argument(arg_array[0], rearrange_intro, with_html_tag, colored_position, attack_type, _t,
start_with_intro, is_users_opinion, anonymous_style, support_counter_argument,
author_uid)
else:
# get all pgroups and at last, the conclusion
return __build_nested_argument(arg_array, first_arg_by_user, user_changed_opinion, with_html_tag,
start_with_intro, minimize_on_undercut, anonymous_style, premisegroup_by_user,
_t)
def add_review_opinion_for_delete(db_user, main_page, db_review, should_delete,
_t):
"""
:param db_user:
:param main_page:
:param review_uid:
:param should_delete:
:param _t:
:return:
"""
logger('review.opinions', 'main')
db_user_created_flag = DBDiscussionSession.query(User).get(
db_review.detector_uid)
# add new vote
__add_vote_for(db_user, db_review, not should_delete, LastReviewerDelete)
broke_limit = False
# get all keep and delete votes
count_of_keep, count_of_delete = __get_review_count(
LastReviewerDelete, db_review.uid)
logger('review.opinions',
'result ' + str(count_of_keep) + ':' + str(count_of_delete))
# do we reached any limit?
reached_max = max(count_of_keep, count_of_delete) >= max_votes
if reached_max:
if count_of_delete > count_of_keep: # disable the flagged part
logger('review.opinions',
'max reached / delete for review {}'.format(db_review.uid))
set_able_object_of_review(db_review, True)
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_success_flag)
else: # just close the review
logger('review.opinions',
'max reached / keep for review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_keep - count_of_delete >= min_difference: # just close the review
logger('review.opinions',
'vote says keep for review {}'.format(db_review.uid))
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_delete - count_of_keep >= min_difference: # disable the flagged part
logger('review.opinions',
'vote says delete for review {}'.format(db_review.uid))
set_able_object_of_review(db_review, True)
add_rep, broke_limit = add_reputation_for(db_user_created_flag,
rep_reason_success_flag)
db_review.set_executed(True)
db_review.update_timestamp()
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
if broke_limit:
send_request_for_info_popup_to_socketio(
db_user_created_flag.nickname, _t.get(_.youAreAbleToReviewNow),
main_page + '/review')
return True
def create_speechbubble_dict(bubble_type: BubbleTypes, is_markable: bool = False, is_author: bool = False,
uid: str = '', bubble_url: str = '', content: str = '', omit_bubble_url: bool = False,
omit_vote_info: bool = False, argument_uid: int = None, statement_uid: int = None,
is_supportive: bool = False, db_user: User = None, lang: str = 'en',
is_users_opinion: bool = False, other_author: User = None):
"""
Creates an dictionary which includes every information needed for a bubble.
:param bubble_type: BubbleTypes
:param is_markable: True if the content itself could be flagged
:param is_author: True if the current user is author of the content
:param uid: Identifier for the bubble
:param bubble_url: URL for the click event of the bubble
:param content: Text of the bubble
:param omit_bubble_url: True if the bubble should have a link
:param omit_vote_info: True if the bubble have the little, grey information text
:param argument_uid: Argument.uid
:param statement_uid: Statement.uid
:param is_supportive: Boolean
:param db_user: current
:param omit_bubble_url: Boolean
:param lang: is_users_opinion
:param is_users_opinion: Boolean
:param other_author:
:return: dict()
"""
gravatar_link = get_global_url() + '/static/images/icon.png'
profile = None
is_enemy_user = {
'admin': False,
'author': False,
'special': False
}
if uid != 'now':
content = pretty_print_options(content)
if bubble_type is BubbleTypes.SYSTEM and other_author is not None:
gravatar_link = get_profile_picture(other_author, 25)
profile = '/user/{}'.format(other_author.uid),
is_enemy_user['admin'] = other_author.is_admin()
is_enemy_user['author'] = other_author.is_author()
is_enemy_user['special'] = other_author.is_special()
# check for users opinion
if bubble_type is BubbleTypes.USER and db_user and db_user.nickname != nick_of_anonymous_user:
db_marked = None
gravatar_link = get_profile_picture(db_user, 25)
if argument_uid is not None and db_user is not None:
db_marked = DBDiscussionSession.query(MarkedArgument).filter(
MarkedArgument.argument_uid == argument_uid,
MarkedArgument.author_uid == db_user.uid).first()
if statement_uid is not None and db_user is not None:
db_marked = DBDiscussionSession.query(MarkedStatement).filter(
MarkedStatement.statement_uid == statement_uid,
MarkedStatement.author_uid == db_user.uid).first()
is_users_opinion = db_marked is not None
speech = {
'is_user': bubble_type is BubbleTypes.USER,
'is_system': bubble_type is BubbleTypes.SYSTEM,
'is_status': bubble_type is BubbleTypes.STATUS,
'is_info': bubble_type is BubbleTypes.INFO,
'is_markable': is_markable,
'is_author': is_author,
'is_enemy_user': is_enemy_user,
'id': uid if len(str(uid)) > 0 else uuid4().hex,
'bubble_url': bubble_url,
'message': content,
'omit_bubble_url': omit_bubble_url,
'omit_vote_info': omit_vote_info,
'data_type': 'argument' if argument_uid else 'statement' if statement_uid else 'None',
'data_argument_uid': argument_uid,
'data_statement_uid': statement_uid,
'data_is_supportive': is_supportive,
'is_users_opinion': is_users_opinion,
'enemy': {
'avatar': gravatar_link,
'profile': profile,
'available': profile is not None
}
}
votecount_keys = __get_text_for_click_and_mark_count(db_user, bubble_type is BubbleTypes.USER, argument_uid,
statement_uid, speech, lang)
speech['votecounts_message'] = votecount_keys[speech['votecounts']]
return speech
def __proposal_for_the_element(db_review, data, db_user):
"""
Adds proposal for the ReviewEdit
:param db_review: ReviewEdit
:param data: String
:param db_user: User
:return: None
"""
# sort the new edits by argument uid
argument_dict, statement_dict = __prepare_dicts_for_proposals(data)
logger(
'review.opinions', 'detector {}, statements {}, arguments {}'.format(
db_user.uid, statement_dict, argument_dict))
# add reviews
new_edits = list()
for argument_uid in argument_dict:
DBDiscussionSession.add(
ReviewEdit(detector=db_user.uid, argument=argument_uid))
DBDiscussionSession.flush()
transaction.commit()
db_review_edit = DBDiscussionSession.query(ReviewEdit).filter(
ReviewEdit.detector_uid == db_user.uid,
ReviewEdit.argument_uid == argument_uid).order_by(
ReviewEdit.uid.desc()).first()
logger(
'review.opinions', 'New ReviewEdit with uid ' +
str(db_review_edit.uid) + ' (argument)')
for edit in argument_dict[argument_uid]:
new_edits.append(
ReviewEditValue(review_edit=db_review_edit.uid,
statement=edit['uid'],
typeof=edit['type'],
content=edit['val']))
for statement_uid in statement_dict:
DBDiscussionSession.add(
ReviewEdit(detector=db_user.uid, statement=statement_uid))
DBDiscussionSession.flush()
transaction.commit()
db_review_edit = DBDiscussionSession.query(ReviewEdit).filter(
ReviewEdit.detector_uid == db_user.uid,
ReviewEdit.statement_uid == statement_uid).order_by(
ReviewEdit.uid.desc()).first()
logger(
'review.opinions', 'New ReviewEdit with uid ' +
str(db_review_edit.uid) + ' (statement)')
for edit in statement_dict[statement_uid]:
new_edits.append(
ReviewEditValue(review_edit=db_review_edit.uid,
statement=statement_uid,
typeof=edit['type'],
content=edit['val']))
if len(new_edits) > 0:
DBDiscussionSession.add_all(new_edits)
# edit given, so this review is executed
db_review.set_executed(True)
db_review.update_timestamp()
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
def setUp(self):
self.config = testing.setUp()
self.config.include('pyramid_chameleon')
self.issue_disabled: Issue = DBDiscussionSession.query(Issue).get(6)
self.issue_read_only: Issue = DBDiscussionSession.query(Issue).get(7)
self.issue_cat_or_dog: Issue = DBDiscussionSession.query(Issue).get(2)
self.issue_town: Issue = DBDiscussionSession.query(Issue).get(1)
self.position_cat_or_dog: Statement = DBDiscussionSession.query(
Statement).get(2)
self.position_town: Statement = DBDiscussionSession.query(
Statement).get(36)
self.statement_cat_or_dog: Statement = DBDiscussionSession.query(
Statement).get(5)
self.statement_town: Statement = DBDiscussionSession.query(
Statement).get(40)
self.statement_argument_town: Statement = DBDiscussionSession.query(
Statement).get(39)
self.argument_town: Argument = DBDiscussionSession.query(Argument).get(
34)
self.argument_cat_or_dog: Argument = DBDiscussionSession.query(
Argument).get(2)
self.user_anonymous: User = DBDiscussionSession.query(User).get(1)
self.user_tobi: User = DBDiscussionSession.query(User).get(2)
self.user_christian: User = DBDiscussionSession.query(User).get(3)
self.user_bjoern: User = DBDiscussionSession.query(User).get(4)
DBDiscussionSession.query(Argument).get(1).set_disabled(True)
transaction.commit()
def __split_premisegroup(review):
"""
Splits a premisegroup into the items, which are mapped with the given review
:param review: ReviewSplit.uid
:return: None
"""
db_values = DBDiscussionSession.query(ReviewSplitValues).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_old_statement_ids = [p.statement_uid for p in db_old_premises]
db_first_old_statement = DBDiscussionSession.query(Statement).get(
db_old_premises[0].uid)
db_user = DBDiscussionSession.query(User).get(review.detector_uid)
if db_values:
logger('review.opinions',
'split given premisegroup into the mapped, new statements')
db_statements = []
for value in db_values:
new_statement, tmp = set_statement(
value.content, db_user, db_first_old_statement.is_position,
db_issue)
db_statements.append(new_statement)
else:
logger('review.opinions', 'just split the premisegroup')
db_statements = DBDiscussionSession.query(Statement).filter(
Statement.uid.in_(db_old_statement_ids)).all()
# new premisegroups, for each statement a new one
new_premisegroup_ids = []
new_premise_ids = []
for statement in db_statements:
db_new_premisegroup = PremiseGroup(author=db_user.uid)
DBDiscussionSession.add(db_new_premisegroup)
DBDiscussionSession.flush()
new_premisegroup_ids.append(db_new_premisegroup.uid)
db_new_premise = Premise(db_new_premisegroup.uid, statement.uid, False,
db_user.uid, statement.issue_uid)
DBDiscussionSession.add(db_new_premise)
DBDiscussionSession.flush()
new_premise_ids.append(db_new_premise.uid)
# note new added pgroup
DBDiscussionSession.add(
PremiseGroupSplitted(review.uid, review.premisegroup_uid,
db_new_premisegroup.uid))
# swap the premisegroup occurence in every argument and add new arguments for the new premises
db_arguments = DBDiscussionSession.query(Argument).filter_by(
premisegroup_uid=review.premisegroup_uid).all()
for argument in db_arguments:
argument.set_premisegroup(new_premisegroup_ids[0])
DBDiscussionSession.add(argument)
for uid in new_premisegroup_ids[1:]:
argument = Argument(uid, argument.is_supportive,
argument.author_uid, argument.issue_uid,
argument.conclusion_uid, argument.argument_uid,
argument.is_disabled)
DBDiscussionSession.add(argument)
DBDiscussionSession.flush()
DBDiscussionSession.add(
ArgumentsAddedByPremiseGroupSplit(review.uid, argument.uid))
# swap the conclusion in every argument
new_statements_uids = [s.uid for s in db_statements]
for old_statement_uid in db_old_statement_ids:
db_arguments = DBDiscussionSession.query(Argument).filter_by(
conclusion_uid=old_statement_uid).all()
for argument in db_arguments:
argument.set_conclusion(new_statements_uids[0])
DBDiscussionSession.add(argument)
DBDiscussionSession.add(
StatementReplacementsByPremiseGroupSplit(
review.uid, old_statement_uid, new_statements_uids[0]))
DBDiscussionSession.flush()
for statement_uid in new_statements_uids[1:]:
db_argument = Argument(argument.premisegroup_uid,
argument.is_supportive,
argument.author_uid, argument.issue_uid,
statement_uid, argument.argument_uid,
argument.is_disabled)
DBDiscussionSession.add(db_argument)
DBDiscussionSession.add(
StatementReplacementsByPremiseGroupSplit(
review.uid, old_statement_uid, statement_uid))
DBDiscussionSession.flush()
# finish
DBDiscussionSession.flush()
transaction.commit()
def update_last_action(event: NewResponse):
user = DBDiscussionSession.query(User).filter_by(
nickname=event.request.authenticated_userid).first()
if user is not None:
user.update_last_action()
