def __get_choose_array_for_pgroup(self, is_argument: bool, is_supportive: bool, conclusion_uid: int,
argument_uid: int, db_user: User, group_id: int, _um: UrlManager):
db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=group_id).all()
premise_array = []
for premise in db_premises:
text = premise.get_text()
premise_array.append({'title': text, 'id': premise.statement_uid})
if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible
add_seen_statement(premise.statement_uid, db_user)
# get attack for each premise, so the urls will be unique
db_argument = DBDiscussionSession.query(Argument).filter(Argument.premisegroup_uid == group_id,
Argument.is_supportive == is_supportive)
if conclusion_uid and not is_argument:
db_argument = db_argument.filter_by(conclusion_uid=conclusion_uid).first()
else:
db_argument = db_argument.filter_by(argument_uid=argument_uid).first()
if not db_argument:
return None
attacking_arg_uids = get_all_attacking_arg_uids_from_history(self.path)
arg_id_sys, attack = attacks.get_attack_for_argument(db_argument.uid,
restrictive_arg_uids=attacking_arg_uids)
url = _um.get_url_for_reaction_on_argument(db_argument.uid, attack, arg_id_sys)
if is_argument:
is_author = is_author_of_argument(db_user, argument_uid)
else:
is_author = is_author_of_statement(db_user, conclusion_uid)
return self.__create_answer_dict(str(db_argument.uid), premise_array, 'choose', url,
is_markable=True, is_editable=True, is_author=is_author)
def test_add_seen_statement_anonymous_user_is_not_tracked(self):
self.clear_every_vote()
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 0, 0)
db_anon = DBDiscussionSession.query(User).get(1)
val = add_seen_statement(1, db_anon)
self.assertFalse(val)
def test_add_seen_statement(self):
self.clear_every_vote()
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 0, 0)
val = add_seen_statement(1, self.user)
self.assertTrue(val)
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 1, 0)
val = add_seen_statement(2, self.user)
self.assertTrue(val)
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 2, 0)
val = add_seen_statement(2, self.user)
self.assertFalse(val)
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 2, 0)
self.clear_every_vote()
self.check_tables_of_user_for_n_rows(self.user, 0, 0, 0, 0)
def set_seen_statements(uids, path, db_user) -> dict:
"""
Marks several statements as already seen.
:param uids: Uids of statements which should be marked as seen
:param path: Current path of the user
:param db_user: User
:rtype: dict
:return: Dictionary with an error field
"""
# are the statements connected to an argument?
if 'justify' in path:
url = path[path.index('justify/') + len('justify/'):]
additional_argument = int(url[:url.index('/')])
add_seen_argument(additional_argument, db_user)
for uid in uids:
# we get the premise group id's only
if is_integer(uid):
add_seen_statement(uid, db_user)
return {'status': 'success'}
def get_array_for_choosing(self, argument_or_statement_id, pgroup_ids,
is_argument, is_supportive, nickname):
"""
Prepares the dict with all items for the choosing an premise, when the user inserted more than one new premise.
:param argument_or_statement_id: Argument.uid or Statement.uid
:param pgroup_ids: PremiseGroups.uid
:param is_argument: Boolean
:param is_supportive: Boolean
:param nickname:
:return: dict()
"""
logger('ItemDictHelper', 'def')
statements_array = []
slug = self.db_issue.slug
_um = UrlManager(slug, history=self.path)
conclusion_uid = argument_or_statement_id if not is_argument else None
argument_uid = argument_or_statement_id if is_argument else None
db_user = DBDiscussionSession.query(User).filter_by(
nickname=nickname).first()
for group_id in pgroup_ids:
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=group_id).all()
premise_array = []
for premise in db_premises:
text = premise.get_text()
premise_array.append({
'title': text,
'id': premise.statement_uid
})
if db_user and db_user.nickname != nick_of_anonymous_user: # add seen by if the statement is visible
add_seen_statement(premise.statement_uid, db_user)
# get attack for each premise, so the urls will be unique
db_argument = DBDiscussionSession.query(Argument).filter(
Argument.premisegroup_uid == group_id,
Argument.is_supportive == is_supportive)
if conclusion_uid and not is_argument:
db_argument = db_argument.filter_by(
conclusion_uid=conclusion_uid).first()
else:
db_argument = db_argument.filter_by(
argument_uid=argument_uid).first()
if not db_argument:
print(group_id)
return {
'elements': statements_array,
'extras': {
'cropped_list': False
}
}
attacking_arg_uids = get_all_attacking_arg_uids_from_history(
self.path)
arg_id_sys, attack = attacks.get_attack_for_argument(
db_argument.uid, restrictive_arg_uids=attacking_arg_uids)
url = _um.get_url_for_reaction_on_argument(db_argument.uid, attack,
arg_id_sys)
if is_argument:
is_author = is_author_of_argument(db_user, argument_uid)
else:
is_author = is_author_of_statement(db_user, conclusion_uid)
statements_array.append(
self.__create_answer_dict(str(db_argument.uid),
premise_array,
'choose',
url,
is_markable=True,
is_editable=True,
is_author=is_author))
return {
'elements': statements_array,
'extras': {
'cropped_list': False
}
}
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:
"""
logger('ItemDictHelper', 'def user: {}'.format(db_user.nickname))
db_statements = DBDiscussionSession.query(Statement) \
.filter(Statement.is_disabled == False,
Statement.is_position == True,
Statement.issue_uid == self.db_issue.uid).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)
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)
statements_array.append(
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 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))
_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)
}
}
