def delete_splits(uid):
tmp = DBDiscussionSession.query(ReviewSplit).filter_by(
premisegroup_uid=uid).first()
if tmp:
DBDiscussionSession.query(ReviewSplitValues).filter_by(
review_uid=uid).delete()
DBDiscussionSession.query(ReviewSplit).filter_by(
premisegroup_uid=uid).delete()
DBDiscussionSession.flush()
transaction.commit()
def delete_in_database(db_user: User) -> True:
"""
Deletes history from database
:param db_user: User
:return: [String]
"""
DBDiscussionSession.query(History).filter_by(author_uid=db_user.uid).delete()
DBDiscussionSession.flush()
return True
def set_statements_as_new_premisegroup(statements: List[Statement],
db_user: User, db_issue: Issue):
"""
Set the given statements together as new premise group
:param statements: [Statement]
:param db_user: User
:param db_issue: Issue
:return: PremiseGroup.uid
"""
LOG.debug("User: %s, statement: %s, issue: %s", db_user.uid,
[s.uid for s in statements], db_issue.uid)
# check for duplicate
all_groups = []
for statement in statements:
# get the premise
db_premise = DBDiscussionSession.query(Premise).filter_by(
statement_uid=statement.uid).first()
if db_premise:
# getting all groups, where the premise is member
db_premisegroup = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=db_premise.premisegroup_uid).all()
groups = set()
for group in db_premisegroup:
groups.add(group.premisegroup_uid)
all_groups.append(groups)
# if every set in this array has one common member, they are all in the same group
if len(all_groups) > 0:
intersec = set.intersection(*all_groups)
for group in intersec:
db_premise = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=group).all()
if len(db_premise) == len(statements):
return DBDiscussionSession.query(PremiseGroup).get(group)
premise_group = PremiseGroup(author=db_user.uid)
DBDiscussionSession.add(premise_group)
DBDiscussionSession.flush()
premise_list = []
for statement in statements:
premise = Premise(premisesgroup=premise_group.uid,
statement=statement.uid,
is_negated=False,
author=db_user.uid,
issue=db_issue.uid)
premise_list.append(premise)
DBDiscussionSession.add_all(premise_list)
DBDiscussionSession.flush()
db_premisegroup = DBDiscussionSession.query(PremiseGroup).filter_by(
author_uid=db_user.uid).order_by(PremiseGroup.uid.desc()).first()
return db_premisegroup
def add_vote(self, db_user: User, db_review: ReviewDelete, is_okay: bool, application_url: str,
translator: Translator,
**kwargs):
"""
Adds an vote for this queue. If any (positive or negative) limit is reached, the flagged element will be
disabled
:param db_user: current user who votes
:param db_review: the review, which is voted vor
:param is_okay: True, if the element is rightly flagged
:param application_url: the app url
:param translator: a instance of a translator
:param kwargs: optional, keyworded arguments
:return:
"""
LOG.debug("Entering function to add a vote for review with id %s", db_review.uid)
db_user_created_flag = DBDiscussionSession.query(User).get(db_review.detector_uid)
rep_reason = None
# add new vote
add_vote_for(db_user, db_review, is_okay, LastReviewerDelete)
# get all keep and delete votes
count_of_delete, count_of_keep = self.get_review_count(db_review.uid)
# 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
set_able_object_of_review(db_review, True)
rep_reason = get_reason_by_action(ReputationReasons.success_flag)
else: # just close the review
rep_reason = get_reason_by_action(ReputationReasons.bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_keep - count_of_delete >= min_difference: # just close the review
rep_reason = get_reason_by_action(ReputationReasons.bad_flag)
db_review.set_executed(True)
db_review.update_timestamp()
elif count_of_delete - count_of_keep >= min_difference: # disable the flagged part
set_able_object_of_review(db_review, True)
rep_reason = get_reason_by_action(ReputationReasons.success_flag)
db_review.set_executed(True)
db_review.update_timestamp()
if rep_reason:
add_reputation_and_send_popup(db_user_created_flag, rep_reason, application_url, translator)
DBDiscussionSession.add(db_review)
DBDiscussionSession.flush()
transaction.commit()
return True
def __add_statement(is_position: bool) -> Statement:
"""
Adds a new statement to the database
:param is_position: True if the statement should be a position
:return: New statement object
"""
db_statement = Statement(is_position=is_position)
DBDiscussionSession.add(db_statement)
DBDiscussionSession.flush()
return db_statement
def setUp(self):
super().setUp()
self.first_issue = DBDiscussionSession.query(Issue).filter_by(
is_disabled=False).first()
self.last_issue = DBDiscussionSession.query(Issue).filter_by(
is_disabled=False).order_by(Issue.uid.desc()).first()
self.history = '/attitude/2-/justify/2/t-/reaction/12/undercut/13'
settings = self.user_tobi.settings
settings.set_last_topic_uid(self.first_issue.uid)
DBDiscussionSession.add(settings)
DBDiscussionSession.flush()
def __bend_objects_of_review(db_review):
"""
If an argument is a duplicate, we have to bend the objects of argument, which are no duplicates
:param db_review: Review
:return: None
"""
LOG.debug("Review %s with duplicate %s and Original %s", db_review.uid, db_review.duplicate_statement_uid,
db_review.original_statement_uid)
db_statement = DBDiscussionSession.query(Statement).get(db_review.duplicate_statement_uid)
db_statement.set_disabled(True)
DBDiscussionSession.add(db_statement)
# do we need a new position
db_dupl_statement = DBDiscussionSession.query(Statement).get(db_review.duplicate_statement_uid)
db_orig_statement = DBDiscussionSession.query(Statement).get(db_review.original_statement_uid)
if db_dupl_statement.is_position and not db_orig_statement.is_position:
LOG.debug("Duplicate is startpoint, but original one is not")
DBDiscussionSession.add(
RevokedDuplicate(review=db_review.uid, bend_position=True, statement=db_orig_statement.uid))
db_orig_statement.set_position(True)
# getting all argument where the duplicated statement is used
all_arguments = get_all_arguments_by_statement(db_review.duplicate_statement_uid, True)
for argument in all_arguments:
text = 'Statement {db_review.duplicate_statement_uid} was used in argument {argument.uid}'
used = False
# recalibrate conclusion
if argument.conclusion_uid == db_review.duplicate_statement_uid:
LOG.debug("%s, bend conclusion from %s to %s", text, argument.conclusion_uid,
db_review.original_statement_uid)
argument.set_conclusion(db_review.original_statement_uid)
DBDiscussionSession.add(argument)
DBDiscussionSession.add(RevokedDuplicate(review=db_review.uid, conclusion_of_argument=argument.uid))
used = True
# recalibrate premises
db_premises = DBDiscussionSession.query(Premise).filter_by(premisegroup_uid=argument.premisegroup_uid).all()
for premise in db_premises:
if premise.statement_uid == db_review.duplicate_statement_uid:
LOG.debug("%s, bend premise %s from %s to %s", text, premise.uid, premise.statement_uid,
db_review.original_statement_uid)
premise.set_statement(db_review.original_statement_uid)
DBDiscussionSession.add(premise)
DBDiscussionSession.add(RevokedDuplicate(review=db_review.uid, premise=premise.uid))
used = True
if not used:
LOG.warning("Nothing was bend - undercut from %s to %s", argument.uid, argument.argument_uid)
DBDiscussionSession.flush()
transaction.commit()
def test_set_reference(self):
db_user = DBDiscussionSession.query(User).get(2)
db_statement = DBDiscussionSession.query(Statement).get(3)
val = set_reference('some_reference#42',
'http://www.fortschrittskolleg.de/', db_user,
db_statement, db_statement.issue_uid)
self.assertTrue(val)
DBDiscussionSession.query(StatementReferences).filter_by(
reference='some_reference#42').delete()
DBDiscussionSession.flush()
transaction.commit()
def __disable_arguments_by_id(argument_uids):
"""
Disbale the list of argument by their id
:param Argument_uids: list of argument.uid
:return: None
"""
for uid in argument_uids:
db_arg = DBDiscussionSession.query(Argument).get(uid)
db_arg.set_disabled(True)
DBDiscussionSession.add(db_arg)
DBDiscussionSession.flush()
def __add_statement2issue(statement_uid: int, issue_uid: int) -> StatementToIssue:
"""
Adds a new statement to issue link to the database
:param statement_uid: id of the related statement
:param issue_uid: id of the related issue
:return: New statement to issue object
"""
db_statement2issue = StatementToIssue(statement=statement_uid, issue=issue_uid)
DBDiscussionSession.add(db_statement2issue)
DBDiscussionSession.flush()
return db_statement2issue
def set_correction_of_statement(elements, db_user, translator) -> dict:
"""
Adds a proposal for a statements correction and returns info if the proposal could be set
:param elements: List of dicts with text and uids for proposals of edits for new statements
:param db_user: User
:param translator: Translator
:rtype: dict
:return: Dictionary with info and/or error
"""
review_count = len(elements)
added_reviews = [EditQueue().add_edit_reviews(db_user, el['uid'], el['text']) for el in elements]
if added_reviews.count(Code.SUCCESS) == 0: # no edits set
if added_reviews.count(Code.DOESNT_EXISTS) > 0:
LOG.debug("Internal Key Error")
return {
'info': translator.get(_.internalKeyError),
'error': True
}
if added_reviews.count(Code.DUPLICATE) > 0:
LOG.debug("Already edit proposals")
return {
'info': translator.get(_.alreadyEditProposals),
'error': True
}
LOG.debug("No corrections given")
return {
'info': translator.get(_.noCorrections),
'error': True
}
DBDiscussionSession.flush()
transaction.commit()
added_values = [EditQueue().add_edit_values_review(db_user, el['uid'], el['text']) for el in elements]
if Code.SUCCESS not in added_values:
return {
'info': translator.get(_.alreadyEditProposals),
'error': True
}
DBDiscussionSession.flush()
transaction.commit()
msg = ''
if review_count > added_values.count(Code.SUCCESS) \
or added_reviews.count(Code.SUCCESS) != added_values.count(Code.SUCCESS):
msg = translator.get(_.alreadyEditProposals)
return {
'error': False,
'info': msg
}
def add_reputation_for(user: User, reason):
"""
Add reputation for the given nickname with the reason only iff the reason can be added. For example all reputation
for 'first' things cannot be given twice.
Anonymous user is not eligible to receive reputation.
:param user: User in refactored fns, else nickname
:param reason: reason as string, as given in reputation.py
:return: True, if the user gained reputation and an additional boolean that is true, when the user reached 30points
"""
logger('ReputationPointHelper', 'main ' + reason)
db_reason = DBDiscussionSession.query(ReputationReason).filter_by(reason=reason).first()
if isinstance(user, str): # TODO remove this check after refactoring
db_user = DBDiscussionSession.query(User).filter_by(nickname=user).first()
else:
db_user = user
if not db_user:
logger('ReputationPointHelper', 'The nickname \'{}\' could not be found in our database'.format(user))
return False, False
if db_user.nickname == nick_of_anonymous_user:
logger('ReputationPointHelper', '{} is not eligible to receive reputation'.format(db_user.nickname))
return False, False
if not db_reason or not db_user:
logger('ReputationPointHelper', 'no reason or no user')
return False, False
logger('ReputationPointHelper', 'user ' + str(db_user.uid))
# special case:
if '_first_' in reason:
db_already_farmed = DBDiscussionSession.query(ReputationHistory).filter(
ReputationHistory.reputation_uid == db_reason.uid,
ReputationHistory.reputator_uid == db_user.uid).first()
if db_already_farmed:
logger('ReputationPointHelper', 'karma already farmed')
return False, False
logger('ReputationPointHelper', 'add ' + str(db_reason.points) + ' for ' + db_user.nickname)
db_old_points = __collect_points(
DBDiscussionSession.query(ReputationHistory).filter_by(reputator_uid=db_user.uid).join(ReputationReason).all())
new_rep = ReputationHistory(reputator=db_user.uid, reputation=db_reason.uid)
DBDiscussionSession.add(new_rep)
DBDiscussionSession.flush()
transaction.commit()
db_new_points = db_old_points + db_reason.points
return True, db_old_points < 30 <= db_new_points
def __add_textversion(text: str, user_uid: int, statement_uid: int) -> TextVersion:
"""
Adds a new statement to the database
:param text: content of the textversion
:param user_uid: uid of the author
:param statement_uid: id of the related statement
:return: New textversion object
"""
db_textversion = TextVersion(content=text, author=user_uid, statement_uid=statement_uid)
DBDiscussionSession.add(db_textversion)
DBDiscussionSession.flush()
return db_textversion
def set_new_undermine_or_support_for_pgroup(premisegroup_uid: int,
current_argument: Argument,
is_supportive: bool, db_user: User,
db_issue: Issue):
"""
Inserts a new undermine or support with the given parameters.
:param premisegroup_uid: premisegroup_uid
:param current_argument: Argument
:param is_supportive: Boolean
:param db_user: User
:param issue: Issue.uid
:return: Argument, Boolean if the argument is a duplicate
"""
already_in = []
# all premises out of current pgroup
db_premises = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=current_argument.premisegroup_uid).all()
for premise in db_premises:
new_arguments = []
db_arguments = get_enabled_arguments_as_query()
db_argument = db_arguments.filter(
Argument.premisegroup_uid == premisegroup_uid,
Argument.is_supportive == True,
Argument.conclusion_uid == premise.statement_uid).first()
if db_argument:
continue
db_tmp = DBDiscussionSession.query(Premise).filter_by(
premisegroup_uid=premisegroup_uid).all()
if any([p.statement_uid == premise.statement_uid for p in db_tmp]):
return False
new_arguments.append(
Argument(premisegroup=premisegroup_uid,
is_supportive=is_supportive,
author=db_user.uid,
issue=db_issue.uid,
conclusion=premise.statement_uid))
if len(new_arguments) > 0:
DBDiscussionSession.add_all(new_arguments)
DBDiscussionSession.flush()
transaction.commit()
already_in += new_arguments
rnd = random.randint(0, len(already_in) - 1)
return already_in[rnd]
def tearDown(self):
for uid in [
arg.uid
for arg in DBDiscussionSession.query(Argument).filter_by(
author_uid=self.db_user.uid).all()
]:
DBDiscussionSession.query(ClickedArgument).filter_by(
argument_uid=uid).delete()
DBDiscussionSession.query(SeenArgument).filter_by(
argument_uid=uid).delete()
DBDiscussionSession.query(Argument).filter_by(
author_uid=self.db_user.uid).delete()
DBDiscussionSession.flush()
transaction.commit()
def setUp(self):
self.config = testing.setUp()
self.user = DBDiscussionSession.query(User).filter_by(
nickname='Tobias').first()
self.first_issue = DBDiscussionSession.query(Issue).filter_by(
is_disabled=False).first()
self.last_issue = DBDiscussionSession.query(Issue).filter_by(
is_disabled=False).order_by(Issue.uid.desc()).first()
self.history = '/attitude/2-/justify/2/t-/reaction/12/undercut/13'
settings = self.user.settings
settings.set_last_topic_uid(self.first_issue.uid)
DBDiscussionSession.add(settings)
DBDiscussionSession.flush()
transaction.commit()
def revoke_ballot(self, db_user: User, db_review: ReviewDelete):
"""
Revokes/Undo the implications of any successfull reviewed element
:param db_user:
:param db_review:
:return:
"""
revoke_decision_and_implications(ReviewDelete, LastReviewerDelete, db_review.uid)
db_review_canceled = ReviewCanceled(author=db_user.uid, review_data={key_delete: db_review.uid})
DBDiscussionSession.add(db_review_canceled)
DBDiscussionSession.flush()
transaction.commit()
return True
def __add_optimization_review(argument_uid, statement_uid, user_uid):
"""
Adds a ReviewOptimization row
:param argument_uid: Argument.uid
:param statement_uid: Statement.uid
:param user_uid: User.uid
:return: None
"""
LOG.debug("Flag argument/statement %s/%s by user %s for optimization", argument_uid, statement_uid, user_uid)
review_optimization = ReviewOptimization(detector=user_uid, argument=argument_uid, statement=statement_uid)
DBDiscussionSession.add(review_optimization)
DBDiscussionSession.flush()
transaction.commit()
def __create_argument_by_uids(db_user: User, premisegroup_uid, conclusion_uid,
argument_uid, is_supportive,
db_issue: Issue) -> Optional[Argument]:
"""
Connects the given id's to a new argument
:param db_user: User.nickname
:param premisegroup_uid: PremiseGroup.uid
:param conclusion_uid: Statement.uid
:param argument_uid: Argument.uid
:param is_supportive: Boolean
:param db_issue: Issue
:return:
"""
LOG.debug(
"Entering __create_argument_by_uids with user: %s, premisegroup_uid: %s, conclusion_uid :%s, "
"argument_uid: %s, is_supportive: %s, issue: %s", db_user.nickname,
premisegroup_uid, conclusion_uid, argument_uid, is_supportive,
db_issue.uid)
new_argument = DBDiscussionSession.query(Argument).filter(
Argument.premisegroup_uid == premisegroup_uid,
Argument.is_supportive == is_supportive,
Argument.conclusion_uid == conclusion_uid,
Argument.issue_uid == db_issue.uid).first()
if not new_argument:
new_argument = Argument(premisegroup=premisegroup_uid,
is_supportive=is_supportive,
author=db_user.uid,
issue=db_issue.uid,
conclusion=conclusion_uid)
new_argument.set_conclusions_argument(argument_uid)
DBDiscussionSession.add(new_argument)
DBDiscussionSession.flush()
new_argument = DBDiscussionSession.query(Argument).filter(
Argument.premisegroup_uid == premisegroup_uid,
Argument.is_supportive == is_supportive,
Argument.author_uid == db_user.uid,
Argument.conclusion_uid == conclusion_uid,
Argument.argument_uid == argument_uid,
Argument.issue_uid == db_issue.uid).first()
transaction.commit()
if new_argument:
LOG.debug("Argument was inserted")
return new_argument
else:
LOG.debug("Argument was not inserted")
return None
def test_set_issue(self):
db_user = DBDiscussionSession.query(User).filter_by(
nickname='Tobias').first()
db_lang = DBDiscussionSession.query(Language).filter_by(
ui_locales='en').first()
info = 'infoinfoinfo'
long_info = 'long_infolong_infolong_info'
title = 'titletitletitle'
response = ih.set_issue(db_user, info, long_info, title, db_lang,
False, False)
self.assertTrue(len(response['issue']) >= 0)
DBDiscussionSession.query(Issue).filter_by(title=title).delete()
DBDiscussionSession.flush()
transaction.commit()
def __add_delete_review(argument_uid, statement_uid, user_uid, reason_uid):
"""
Adds a ReviewDelete row
:param argument_uid: Argument.uid
:param statement_uid: Statement.uid
:param user_uid: User.uid
:param reason_uid: ReviewDeleteReason.uid
:return: None
"""
LOG.debug("Flag argument/statement %s/%s by user %s for delete", argument_uid, statement_uid, user_uid)
review_delete = ReviewDelete(detector=user_uid, argument=argument_uid, statement=statement_uid, reason=reason_uid)
DBDiscussionSession.add(review_delete)
DBDiscussionSession.flush()
transaction.commit()
def __add_duplication_review(duplicate_statement_uid, original_statement_uid, user_uid):
"""
Adds a ReviewDuplicate row
:param duplicate_statement_uid: Statement.uid
:param original_statement_uid: Statement.uid
:param user_uid: User.uid
:return: None
"""
LOG.debug("Flag statement %s by user %s as duplicate of %s", duplicate_statement_uid, user_uid,
original_statement_uid)
review_duplication = ReviewDuplicate(detector=user_uid, duplicate_statement=duplicate_statement_uid,
original_statement=original_statement_uid)
DBDiscussionSession.add(review_duplication)
DBDiscussionSession.flush()
transaction.commit()
def downgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column(
'statements',
sa.Column('issue_uid',
sa.Integer(),
server_default='1',
nullable=False))
for db_statement in DBDiscussionSession.query(Statement).all():
db_statement2issue = DBDiscussionSession.query(
StatementToIssue).filter_by(
statement_uid=db_statement.uid).first()
db_statement.issue_uid = db_statement2issue.issue_uid
DBDiscussionSession.flush()
transaction.commit()
op.drop_table('statement_to_issue')
def test_add_reputation_for(self):
DBDiscussionSession.query(ReputationHistory).filter_by(
reputator_uid=9).delete()
for reason in ReputationReasons:
db_reason = get_reason_by_action(reason)
self.assertTrue(add_reputation_for(self.user_torben, db_reason))
db_reason = get_reason_by_action(
ReputationReasons.first_argument_click)
self.assertFalse(add_reputation_for(self.user_torben, db_reason))
DBDiscussionSession.query(ReputationHistory).filter_by(
reputator_uid=9).delete()
DBDiscussionSession.flush()
transaction.commit()
def revoke_ballot(self, db_user: User, db_review: ReviewDuplicate):
"""
Revokes/Undo the implications of any successfull reviewed element
:param db_user:
:param db_review:
:return:
"""
db_review = DBDiscussionSession.query(ReviewDuplicate).get(db_review.uid)
db_review.set_revoked(True)
self.__rebend_objects_of_review(db_review)
db_review_canceled = ReviewCanceled(author=db_user.uid, review_data={key_duplicate: db_review.uid})
DBDiscussionSession.add(db_review_canceled)
DBDiscussionSession.flush()
transaction.commit()
return True
def __create_new_user(user_info: Dict[str, Any],
ui_locales: str,
oauth_provider: str = '',
oauth_provider_id: str = '') -> Tuple[str, str, User]:
"""
Create a new user.
:param user_info: A dictionary containing information about the desired user.
:param ui_locales: Language which shall be used for messaging.
:param oauth_provider: If applicable: Which oauth-provider is referring the user.
:param oauth_provider_id: If applicable: The ID of the oauth-provider.
:return: Returns a tuple containing a success message, a information message and the freshly created user.
"""
success = ''
info = ''
_t = Translator(ui_locales)
# creating a new user_info with hashed password
LOG.debug("Adding user_info for %s", user_info['nickname'])
hashed_password = password_handler.get_hashed_password(
user_info['password'])
new_user = User(firstname=user_info['firstname'],
surname=user_info['lastname'],
email=user_info['email'],
nickname=user_info['nickname'],
password=hashed_password,
gender=user_info['gender'],
group_uid=user_info['db_group_uid'],
oauth_provider=oauth_provider,
oauth_provider_id=oauth_provider_id)
DBDiscussionSession.add(new_user)
DBDiscussionSession.flush()
settings = Settings(author_uid=new_user.uid,
send_mails=False,
send_notifications=True,
should_show_public_nickname=True)
DBDiscussionSession.add(settings)
if new_user:
LOG.debug("New data was added with uid %s", new_user.uid)
success = _t.get(Keywords.accountWasAdded).format(
user_info['nickname'])
else:
LOG.debug("New data was not added")
info = _t.get(Keywords.accoutErrorTryLateOrContant)
return success, info, new_user
def __disable_textversions(statement_uid, author_uid):
"""
Disables the textversions of the given statement
:param statement_uid: Statement.uid
:param author_uid: User.uid
:return: None
"""
db_textversion = DBDiscussionSession.query(TextVersion).filter(
TextVersion.statement_uid == statement_uid,
TextVersion.author_uid == author_uid).all()
for textversion in db_textversion:
LOG.debug("Disabling: %s", textversion.uid)
textversion.set_disabled(True)
DBDiscussionSession.add(textversion)
DBDiscussionSession.flush()
def revoke_decision_and_implications(ttype, reviewer_type, uid):
"""
Revokes the old decision and the implications
:param ttype: table of Review
:param reviewer_type: Table of LastReviewer
:param uid: Review.uid
:return: None
"""
DBDiscussionSession.query(reviewer_type).filter_by(review_uid=uid).delete()
db_review = DBDiscussionSession.query(ttype).get(uid)
db_review.set_revoked(True)
set_able_object_of_review(db_review, False)
DBDiscussionSession.flush()
transaction.commit()
def revoke_author_of_argument_content(argument, db_user):
"""
Revokes the argument - e.g. the user is not the author anymore
:param argument: Argument
:param db_user: User
:return:
"""
logger('QueryHelper', str(argument.uid))
# get element, which should be revoked
db_element = __revoke_argument(db_user, argument)
DBDiscussionSession.add(
RevokedContent(db_user.uid, argument=db_element.uid))
DBDiscussionSession.flush()
transaction.commit()
return True
def cancel_ballot(self, db_user: User, db_review: ReviewDelete):
"""
Cancels any ongoing vote
:param db_user: current user
:param db_review: any element from a review queue
:return:
"""
DBDiscussionSession.query(ReviewDelete).get(db_review.uid).set_revoked(True)
DBDiscussionSession.query(LastReviewerDelete).filter_by(review_uid=db_review.uid).delete()
db_review_canceled = ReviewCanceled(author=db_user.uid, review_data={key_delete: db_review.uid},
was_ongoing=True)
DBDiscussionSession.add(db_review_canceled)
DBDiscussionSession.flush()
transaction.commit()
return True
