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 test_delete_user_history(self):
self.config.testing_securitypolicy(userid='Tobias', permissive=True)
DBDiscussionSession.add(
History(author_uid=3,
path='http://localhost:4284/discuss/cat-or-dog'))
transaction.commit()
request = construct_dummy_request()
response = delete_user_history(request)
transaction.commit()
self.assertTrue(response)
db_his = DBDiscussionSession.query(History).filter_by(
author_uid=2).count()
self.assertEqual(db_his, 0)
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 __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 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 test_get_reviews_of(self):
engelbert = DBDiscussionSession.query(User).filter_by(
nickname='Engelbert').first()
self.assertGreaterEqual(user.number_of_reviews(engelbert, True), 0)
self.assertGreaterEqual(user.number_of_reviews(engelbert, False), 0)
rv = ReviewEdit(self.user_tobi.uid, 1, 1)
yesterday = date.today() - timedelta(1)
rv.timestamp = arrow.get(yesterday.strftime('%Y-%m-%d'))
DBDiscussionSession.add(rv)
transaction.commit()
self.assertGreaterEqual(user.number_of_reviews(self.user_tobi, True),
0)
self.assertGreaterEqual(user.number_of_reviews(self.user_tobi, False),
0)
def send_add_argument_notification(url, attacked_argument_uid, user, mailer):
"""
Sends an notification because an argument was added
:param url: String
:param attacked_argument_uid: Argument.uid
:param user: User
:param mailer: Instance of pyramid mailer
:return:
"""
# getting current argument, arguments author, current user and some settings
db_argument = DBDiscussionSession.query(Argument).get(
attacked_argument_uid)
db_author = DBDiscussionSession.query(User).get(db_argument.author_uid)
db_current_user = DBDiscussionSession.query(User).filter_by(
nickname=user).first()
if db_author == db_current_user:
return None
db_author_settings = db_author.settings
user_lang = DBDiscussionSession.query(Language).get(
db_author_settings.lang_uid).ui_locales
# send notification via websocket to last author
_t_user = Translator(user_lang)
if db_author_settings.should_send_notifications:
send_request_for_info_popup_to_socketio(db_author.nickname,
_t_user.get(_.argumentAdded),
url)
# send mail to last author
if db_author_settings.should_send_mails:
email_helper.send_mail_due_to_added_text(user_lang, url, db_author,
mailer)
# find admin
db_admin = DBDiscussionSession.query(User).filter_by(
nickname=nick_of_admin).first()
topic = _t_user.get(_.argumentAdded)
content = get_text_for_add_argument_message(db_author.firstname, user_lang,
url, True)
DBDiscussionSession.add(
Message(from_author_uid=db_admin.uid,
to_author_uid=db_author.uid,
topic=topic,
content=content,
is_inbox=True))
transaction.commit()
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 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 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
"""
logger('StatementsHelper', 'user: '******', statement: ' + str([s.uid for s in statements]) + ', issue: ' + str(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_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 test_update_last_action(self):
user.update_last_action(self.user_tobi)
self.assertFalse(user.update_last_action(self.user_tobi))
old_ts = arrow.get(2016, 5, 5)
self.user_tobi.last_action = old_ts
self.user_tobi.last_login = old_ts
DBDiscussionSession.add(self.user_tobi)
settings = self.user_tobi.settings
settings.should_hold_the_login(False)
DBDiscussionSession.add(settings)
transaction.commit()
self.assertTrue(user.update_last_action(self.user_tobi))
self.assertFalse(user.update_last_action(self.user_tobi))
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 __store_origin(origin: DataOrigin,
statement_uid: int) -> Optional[StatementOrigins]:
"""
Extract origin of an entity, e.g. a statement, from api_data and store it into the database.
"""
log.debug("Storing origin from %s by %s for statement %d",
str(origin.aggregate_id), str(origin.author), statement_uid)
db_origin: StatementOrigins = StatementOrigins(origin.entity_id,
origin.aggregate_id,
origin.version,
origin.author.nickname,
statement_uid)
if db_origin:
DBDiscussionSession.add(db_origin)
return db_origin
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, ui_locales, oauth_provider='', oauth_provider_id=''):
"""
Insert a new user row
:param user: dict with every information for a user needed
:param ui_locales: Language.ui_locales
:param oauth_provider: String
:param oauth_provider_id: String
:return: String, String, User
"""
success = ''
info = ''
_t = Translator(ui_locales)
# creating a new user with hashed password
logger('User', 'Adding user ' + user['nickname'])
hashed_password = password_handler.get_hashed_password(user['password'])
newuser = User(firstname=user['firstname'],
surname=user['lastname'],
email=user['email'],
nickname=user['nickname'],
password=hashed_password,
gender=user['gender'],
group_uid=user['db_group_uid'],
oauth_provider=oauth_provider,
oauth_provider_id=oauth_provider_id)
DBDiscussionSession.add(newuser)
transaction.commit()
db_user = DBDiscussionSession.query(User).filter_by(nickname=user['nickname']).first()
settings = Settings(author_uid=db_user.uid,
send_mails=False,
send_notifications=True,
should_show_public_nickname=True)
DBDiscussionSession.add(settings)
transaction.commit()
# sanity check, whether the user exists
db_user = DBDiscussionSession.query(User).filter_by(nickname=user['nickname']).first()
if db_user:
logger('User', 'New data was added with uid ' + str(db_user.uid))
success = _t.get(_.accountWasAdded).format(user['nickname'])
else:
logger('User', 'New data was not added')
info = _t.get(_.accoutErrorTryLateOrContant)
return success, info, db_user
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 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))
return new_statement
def __create_argument_by_uids(db_user: User, premisegroup_uid, conclusion_uid, argument_uid, is_supportive,
db_issue: Issue) -> Union[Argument, None]:
"""
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:
"""
logger('StatementsHelper', 'main with user: '******', premisegroup_uid: ' + str(premisegroup_uid) +
', conclusion_uid: ' + str(conclusion_uid) +
', argument_uid: ' + str(argument_uid) +
', is_supportive: ' + str(is_supportive) +
', issue: ' + str(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()
# TODO This should be redundant code! new_argument should be the new argument
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:
logger('StatementsHelper', 'argument was inserted')
return new_argument
else:
logger('StatementsHelper', 'argument was not inserted')
return None
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
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_author_of_argument_content(db_argument: Argument, db_user: User):
"""
Revokes the argument - e.g. the user is not the author anymore
:param db_argument: Argument
:param db_user: User
:return:
"""
LOG.debug(
"Entering revoke_author_of_argument_content for argument with id %s",
db_argument.uid)
# get element, which should be revoked
db_element = __revoke_argument(db_argument, db_user)
DBDiscussionSession.add(
RevokedContent(db_user.uid, argument=db_element.uid))
DBDiscussionSession.flush()
return True
def send_welcome_notification(user, translator):
"""
Creates and send the welcome message to a new user.
:param user: User.uid
:param translator: translator
:return: None
"""
topic = translator.get(_.welcome)
content = translator.get(_.welcomeMessage)
notification = Message(from_author_uid=1,
to_author_uid=user,
topic=topic,
content=content,
is_inbox=True)
DBDiscussionSession.add(notification)
DBDiscussionSession.flush()
transaction.commit()
def __statement_seen_by_user(db_user, statement_uid):
"""
Adds a reference for a seen statement
:param db_user: current user
:param statement_uid: uid of the statement
:return: True if the statement was not seen by the user (until now), false otherwise
"""
db_seen_by = DBDiscussionSession.query(SeenStatement).filter(
SeenStatement.statement_uid == statement_uid,
SeenStatement.user_uid == db_user.uid).first()
if not db_seen_by:
DBDiscussionSession.add(
SeenStatement(statement_uid=statement_uid, user_uid=db_user.uid))
DBDiscussionSession.flush()
return True
return False
def set_statement(text: str, db_user: User, is_start: bool, db_issue: Issue) -> Tuple[Statement, bool]:
"""
Saves statement for user
:param text: given statement
:param db_user: User of given user
:param is_start: if it is a start statement
:param db_issue: Issue
:return: Statement, is_duplicate or -1, False on error
"""
logger('StatementsHelper', 'user: '******', user_id: ' + str(db_user.uid) +
', text: ' + str(text) + ', issue: ' + str(db_issue.uid))
# escaping and cleaning
text = text.strip()
text = ' '.join(text.split())
text = escape_string(text)
_tn = Translator(db_issue.lang)
if text.startswith(_tn.get(_.because).lower() + ' '):
text = text[len(_tn.get(_.because) + ' '):]
while text.endswith(('.', '?', '!', ',')):
text = text[:-1]
# check, if the text already exists
db_duplicate = DBDiscussionSession.query(TextVersion).filter(
func.lower(TextVersion.content) == text.lower()).first()
if db_duplicate:
db_statement = DBDiscussionSession.query(Statement).filter(Statement.uid == db_duplicate.statement_uid,
Statement.issue_uid == db_issue.uid).one()
return db_statement, True
# add text
statement = Statement(is_position=is_start, issue=db_issue.uid)
DBDiscussionSession.add(statement)
DBDiscussionSession.flush()
# add textversion
textversion = TextVersion(content=text, author=db_user.uid, statement_uid=statement.uid)
DBDiscussionSession.add(textversion)
DBDiscussionSession.flush()
transaction.commit()
return statement, False
def lock_optimization_review(self, db_user: User,
db_review: ReviewOptimization,
translator: Translator):
"""
Locks a ReviewOptimization
:param db_user:
:param db_review:
:param translator:
:return:
"""
LOG.debug("Lock an Optimization-Review")
# check if author locked an item and maybe tidy up old locks
db_locks = DBDiscussionSession.query(
OptimizationReviewLocks).filter_by(author_uid=db_user.uid).first()
if db_locks:
if self.is_review_locked(db_locks.review_optimization_uid):
LOG.debug("Review was already locked")
return {
'success': '',
'info': translator.get(_.dataAlreadyLockedByYou),
'is_locked': True
}
else:
DBDiscussionSession.query(OptimizationReviewLocks).filter_by(
author_uid=db_user.uid).delete()
# is already locked?
if self.is_review_locked(db_review.uid):
LOG.warning("Already locked case")
return {
'success': '',
'info': translator.get(_.dataAlreadyLockedByOthers),
'is_locked': True
}
DBDiscussionSession.add(
OptimizationReviewLocks(db_user.uid, db_review.uid))
DBDiscussionSession.flush()
transaction.commit()
success = translator.get(_.dataAlreadyLockedByYou)
LOG.debug("Review locked")
return {'success': success, 'info': '', 'is_locked': True}
def lock_optimization_review(db_user: User, db_review: ReviewOptimization,
translator: Translator):
"""
Locks a ReviewOptimization
:param db_user:
:param db_review:
:param translator:
:return:
"""
logger('ReviewQueues', 'main')
# check if author locked an item and maybe tidy up old locks
db_locks = DBDiscussionSession.query(OptimizationReviewLocks).filter_by(
author_uid=db_user.uid).first()
if db_locks:
if is_review_locked(db_locks.review_optimization_uid):
logger('ReviewQueues', 'review already locked')
return {
'success': '',
'info': translator.get(_.dataAlreadyLockedByYou),
'is_locked': True
}
else:
DBDiscussionSession.query(OptimizationReviewLocks).filter_by(
author_uid=db_user.uid).delete()
# is already locked?
if is_review_locked(db_review.uid):
logger('ReviewQueues', 'already locked', warning=True)
return {
'success': '',
'info': translator.get(_.dataAlreadyLockedByOthers),
'is_locked': True
}
DBDiscussionSession.add(OptimizationReviewLocks(db_user.uid,
db_review.uid))
DBDiscussionSession.flush()
transaction.commit()
success = translator.get(_.dataAlreadyLockedByYou)
logger('ReviewQueues', 'review locked')
return {'success': success, 'info': '', 'is_locked': 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
"""
logger(
'FlagingHelper',
'Flag argument/statement {}/{} by user {} for optimization'.format(
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 setUp(self):
self.config = testing.setUp()
self.config.include('pyramid_chameleon')
clear_clicks_of('Tobias')
clear_seen_by_of('Tobias')
self.db_tobias = DBDiscussionSession.query(User).filter_by(
nickname='Tobias').first()
self.last_login_of_tobias = self.db_tobias.last_login
self.db_tobias.last_login = get_now()
DBDiscussionSession.add(self.db_tobias)
DBDiscussionSession.flush()
transaction.commit()
clear_clicks_of('Tobias')
clear_seen_by_of('Tobias')
self.db_tobias.last_login = self.last_login_of_tobias
DBDiscussionSession.add(self.db_tobias)
DBDiscussionSession.flush()
transaction.commit()
