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()