def update_badge(): """ Returns the new count for the badge of every table :return: dict(), string """ logger('AdminLib', '') ret_array = [] for t in table_mapper: ret_array.append({ 'name': table_mapper[t]['name'], 'count': DBDiscussionSession.query(table_mapper[t]['table']).count() }) return ret_array
def test_get_author_data(self): db_user, author_string, some_boolean = lib.get_author_data(0) self.assertFalse(some_boolean) self.assertIsNone(db_user) user = DBDiscussionSession.query(User).get(1) _, author_string, some_boolean = lib.get_author_data(1, gravatar_on_right_side=False) self.assertTrue(some_boolean) self.assertIn('{}'.format(user.nickname), author_string) self.assertIn('right', author_string) _, author_string, some_boolean = lib.get_author_data(1, gravatar_on_right_side=True) self.assertTrue(some_boolean) self.assertIn('{}'.format(user.nickname), author_string) self.assertIn('left', author_string)
def test_get_all_arguments_with_text_and_url_by_statement_id_with_color(self): um = UrlManager(slug='slug') results = { 47: '<span data-argumentation-type="position">we should close public swimming pools</span> because our swimming pools are very old and it would take a major investment to repair them', 48: 'Someone argued that <span data-argumentation-type="position">we should close public swimming pools</span> because our swimming pools are very old and it would take a major investment to repair them. Other participants said that schools need the swimming pools for their sports lessons.', 49: '<span data-argumentation-type="position">we should close public swimming pools</span> does not hold, because the rate of non-swimmers is too high' } db_statement = DBDiscussionSession.query(Statement).get(38) res = lib.get_all_arguments_with_text_and_url_by_statement(db_statement, um, color_statement=True) self.assertEqual(3, len(res)) for r in res: self.assertIn(r['uid'], results) self.assertEqual(results[r['uid']], r['text'])
def __return_d3_data(graph_arg_lists, db_issue: Issue): """ :param graph_arg_lists: :param db_issue: :return: """ graph_arg_list = [] for key in graph_arg_lists: graph_arg_list += graph_arg_lists[key] graph_arg_list = [ DBDiscussionSession.query(Argument).get(uid) for uid in list(set(graph_arg_list)) ] graph_stat_list = get_all_statements_for_args(graph_arg_list) graph_stat_list = [ DBDiscussionSession.query(Statement).get(uid) for uid in graph_stat_list ] LOG.debug("Stat_list: %s", [stat.uid for stat in graph_stat_list]) LOG.debug("Arg_list: %s", [arg.uid for arg in graph_arg_list]) return get_d3_data(db_issue, graph_stat_list, graph_arg_list)
def get_references(request: Request): """ Query database to get stored references from site. Generate a list with text versions of references. :param request: request :return: References assigned to the queried URL """ host = request.validated["host"] path = request.validated["path"] LOG.debug("Querying references for host: {}, path: {}".format(host, path)) refs_db: List[StatementReference] = DBDiscussionSession.query(StatementReference).filter_by(host=host, path=path).all() return { "references": [DataReference(ref) for ref in refs_db] }
def __get_clicks_and_marks(argument_uid, statement_uid, db_user): db_clicks = None db_marks = None if argument_uid: db_clicks = DBDiscussionSession.query(ClickedArgument). \ filter(ClickedArgument.argument_uid == argument_uid, ClickedArgument.is_up_vote == True, ClickedArgument.is_valid, ClickedArgument.author_uid != db_user.uid).all() db_marks = DBDiscussionSession.query(MarkedArgument). \ filter(MarkedArgument.argument_uid == argument_uid, MarkedArgument.author_uid != db_user.uid).all() elif statement_uid: db_clicks = DBDiscussionSession.query(ClickedStatement). \ filter(ClickedStatement.statement_uid == statement_uid, ClickedStatement.is_up_vote == True, ClickedStatement.is_valid, ClickedStatement.author_uid != db_user.uid).all() db_marks = DBDiscussionSession.query(MarkedStatement). \ filter(MarkedStatement.statement_uid == statement_uid, MarkedStatement.author_uid != db_user.uid).all() return db_clicks, db_marks
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 test_get_user_with_same_opinion_for_statements(self): lang = 'en' main_page = 'url' db_user = DBDiscussionSession.query(User).filter_by( nickname='Tobias').first() for uid in [1, 2, 3]: response = get_user_with_same_opinion_for_statements( statement_uids=[uid], is_supportive=True, db_user=db_user, lang=lang, main_page=main_page) verify_structure_of_statement_premisgroup_argument_dictionary( self, response)
def main_user(request): """ View configuration for the public user page. :param request: current request of the server :return: dictionary with title and project name as well as a value, weather the user is logged in """ match_dict = request.matchdict logger('main_user', 'request.matchdict: {}'.format(match_dict)) uid = match_dict.get('uid', 0) logger('main_user', 'uid: {}'.format(uid)) if not is_integer(uid): raise HTTPNotFound current_user = DBDiscussionSession.query(User).get(uid) if current_user is None or current_user.nickname == nick_of_anonymous_user: logger('main_user', 'no user: {}'.format(uid), error=True) raise HTTPNotFound() ui_locales = get_language_from_cookie(request) user_dict = user.get_information_of(current_user, ui_locales) db_user_of_request = DBDiscussionSession.query(User).filter_by( nickname=request.authenticated_userid).first() can_send_notification = False if db_user_of_request: can_send_notification = current_user.uid != db_user_of_request.uid prep_dict = __main_dict(request, user_dict['public_nick']) prep_dict.update({ 'user': user_dict, 'can_send_notification': can_send_notification }) return prep_dict
def add_row(table_name, data): """ Updates data of a row in the table :param table_name: Name of the table :param data: Dictionary with data for the update :return: Empty string or error message """ LOG.debug("%s", data) table = table_mapper[table_name.lower()]['table'] try: if 'uid' in data: del data['uid'] new_one = table(**data) DBDiscussionSession.add(new_one) except IntegrityError as e: LOG.error("%s", e) return exception_response(400, error='SQLAlchemy IntegrityError: ' + str(e)) DBDiscussionSession.flush() transaction.commit() return True
def valid_user_as_author_of_statement(request): """ :param request: :return: """ if not has_keywords(('statement_id', int))(request): return False statement_id = request.validated['statement_id'] if valid_user(request): db_user = request.validated['user'] db_textversion = DBDiscussionSession.query(TextVersion) \ .filter_by(statement_uid=statement_id) \ .order_by(TextVersion.uid.asc()).first() if db_textversion and db_textversion.author_uid == db_user.uid: request.validated['statement'] = DBDiscussionSession.query( Statement).get(statement_id) return True else: _tn = Translator(get_language_from_cookie(request)) add_error(request, _tn.get(_.userIsNotAuthorOfStatement)) return False
def __get_dash_dict(name, href): """ Returns dictionary with all attributes :param name: name of current table :param href: link for current table :return: {'count': count, 'name': name, 'href': href} """ count = DBDiscussionSession.query( table_mapper[name.lower()]['table']).count() return { 'name': name, 'href': href, 'count': count, }
def __check_duplicate(db_issue: Issue, text: str) -> Optional[Statement]: """ Check if there is already a textversion with the given text. If true the statement2issue relation will be checked and set and the duplicate (Statement) returned :param db_issue: related Issue :param text: the text :return: """ db_tv = DBDiscussionSession.query(TextVersion).filter( func.lower(TextVersion.content) == text.lower()).first() if not db_tv: return None db_statement2issue = DBDiscussionSession.query(StatementToIssue).filter( StatementToIssue.issue_uid == db_issue.uid, StatementToIssue.statement_uid == db_tv.statement_uid).all() if not db_statement2issue: __add_statement2issue(db_tv.statement_uid, db_issue.uid) db_statement = DBDiscussionSession.query(Statement).get( db_tv.statement_uid) return db_statement
def get_all_references_by_reference_text(ref_text=None): """ Query database for all occurrences of a given reference text. Prepare list with information about used issue, author and a url to the statement. :param ref_text: Reference text :return: list of used references """ if ref_text: refs = list() matched = DBDiscussionSession.query(StatementReferences).filter_by( reference=ref_text).all() for reference in matched: user = DBDiscussionSession.query(User).get(reference.author_uid) issue = DBDiscussionSession.query(Issue).get(reference.issue_uid) textversion = DBDiscussionSession.query(TextVersion).get( reference.statement_uid) statement_url = url_to_statement(issue.uid, reference.statement_uid) refs.append({ "reference": extract_reference_information(reference), "author": extract_author_information(user), "issue": extract_issue_information(issue), "arguments": get_all_arguments_with_text_by_statement_id( reference.statement_uid), "statement": { "uid": reference.statement_uid, "url": statement_url, "text": textversion.content } }) return refs
def __get_references_for_statement(uid, main_page): """ Returns all references for the current given statement :param uid: uid of the statement :param main_page: current overview page :return: dict """ LOG.debug("%s", uid) db_references = DBDiscussionSession.query(StatementReference).filter_by( statement_uid=uid).all() references_array = [ __get_values_of_reference(ref, main_page) for ref in db_references ] return {uid: references_array}
def is_review_locked(self, review_uid): """ Is the OptimizationReviewLocks set? :param review_uid: OptimizationReviewLocks.uid :return: Boolean """ self.tidy_up_optimization_locks() LOG.debug("Check whether review %s is locked.", review_uid) db_lock = DBDiscussionSession.query(OptimizationReviewLocks).filter_by( review_optimization_uid=review_uid).first() if not db_lock: return False return (get_now() - db_lock.locked_since).seconds < max_lock_time_in_sec
def test_set_references(self): self.config.testing_securitypolicy(userid='Tobias', permissive=True) issue_uid = DBDiscussionSession.query(StatementToIssue).filter_by(statement_uid=17).first().issue_uid request = testing.DummyRequest(json_body={ 'statement_id': 17, 'issue': issue_uid, 'text': 'This is a source', 'ref_source': 'http://www.google.de/some_source', }) self.assertTrue(set_references(request)) request = testing.DummyRequest(json_body={ 'uids': [17], 'is_argument': False }) response = get_reference(request) self.assertIsNotNone(response) for uid in response['data']: self.assertTrue(17, uid) self.assertTrue(len(response['data'][uid]) != 0) self.assertTrue(len(response['text'][uid]) != 0) DBDiscussionSession.query(StatementReference).filter_by(statement_uid=17).delete() transaction.commit()
def get_mark_count_of(user: User, only_today: bool = False) -> Tuple[int, int]: """ Returns the count of marked arguments and statements of the specific user. :param user: The user whose arguments are counted. :param only_today: True if only the marked arguments of the current day shall be counted. :return: A tuple containing the count of marked arguments and marked statements. """ if not user: return 0, 0 marked_arguments = DBDiscussionSession.query(MarkedArgument).filter( MarkedArgument.author_uid == user.uid) marked_statements = DBDiscussionSession.query(MarkedStatement).filter( MarkedStatement.author_uid == user.uid) if only_today: today = arrow.utcnow().format('YYYY-MM-DD') marked_arguments = marked_arguments.filter( MarkedArgument.timestamp >= today) marked_statements = marked_statements.filter( MarkedStatement.timestamp >= today) return marked_arguments.count(), marked_statements.count()
def is_author_of_argument(db_user: User, argument_uid: int) -> bool: """ Is the user with given nickname author of the argument? :param db_user: User :param argument_uid: Argument.uid :return: Boolean """ db_user = db_user if db_user and db_user.nickname != nick_of_anonymous_user else None if not db_user: return False db_argument = DBDiscussionSession.query(Argument).filter( Argument.uid == argument_uid, Argument.author_uid == db_user.uid).first() return True if db_argument else False
def get_from_database(db_user: User, lang: str) -> List[dict]: """ Returns history from database :param db_user: User :param lang: ui_locales :return: [String] """ db_history = DBDiscussionSession.query(History).filter_by(author_uid=db_user.uid).all() return_array = [] for history in db_history: return_array.append({'path': history.path, 'timestamp': sql_timestamp_pretty_print(history.timestamp, lang, False, True) + ' GMT'}) return return_array
def __receive_url_for_processing_input_of_multiple_premises_for_arguments(new_argument_uids, attack_type, arg_id, _um, supportive) -> str: """ Return the 'choose' url, when the user entered more than one premise for an argument :param new_argument_uids: [Argument.uid] :param attack_type: String :param arg_id: Argument.uid :param _um: UrlManager :param supportive: Boolean :return: String """ pgroups = [] url = '' for uid in new_argument_uids: pgroups.append(DBDiscussionSession.query(Argument).get(uid).premisegroup_uid) current_argument = DBDiscussionSession.query(Argument).get(arg_id) # relation to the arguments premise group if attack_type == Relations.UNDERMINE or attack_type == Relations.SUPPORT: db_premise = DBDiscussionSession.query(Premise).filter_by( premisegroup_uid=current_argument.premisegroup_uid).first() # TODO what happens with |pgroups| > 1? db_statement = DBDiscussionSession.query(Statement).get(db_premise.statement_uid) url = _um.get_url_for_choosing_premisegroup(False, supportive, db_statement.uid, pgroups) # relation to the arguments relation elif attack_type == Relations.UNDERCUT: url = _um.get_url_for_choosing_premisegroup(True, supportive, arg_id, pgroups) # relation to the arguments conclusion elif attack_type == Relations.REBUT: is_argument = current_argument.conclusion_uid is not None uid = current_argument.argument_uid if is_argument else current_argument.conclusion_uid url = _um.get_url_for_choosing_premisegroup(False, is_argument, supportive, uid, pgroups) return url
def test_user_login(self): db_user = DBDiscussionSession.query(User).filter_by( nickname='Tobias').first() db_user.password = get_hashed_password('tobias') transaction.commit() from dbas.views import user_login as ajax request = testing.DummyRequest(json_body={ 'user': '******', 'password': '******', 'keep_login': False, 'url': '' }, mailer=DummyMailer) response = ajax(request) self.assertTrue(type(response) is HTTPFound)
def test_set_new_premises_for_argument(self): self.config.testing_securitypolicy(userid='Tobias', permissive=True) db_arg1 = DBDiscussionSession.query(Argument).filter_by( conclusion_uid=2).count() db_pgroups1 = DBDiscussionSession.query(PremiseGroup).count() request = testing.DummyRequest(json_body={ 'premisegroups': [['some new reason for an argument']], 'argument_id': 2, 'attack_type': Relations.SUPPORT.value, 'issue': 2 }, mailer=DummyMailer) response = set_new_premises_for_argument(request) db_arg2 = DBDiscussionSession.query(Argument).filter_by( conclusion_uid=2).count() db_pgroups2 = DBDiscussionSession.query(PremiseGroup).count() self.assertIsNotNone(response) self.assertNotIsInstance(response, HTTPError, response) self.assertEqual(db_arg1 + 1, db_arg2) self.assertEqual(db_pgroups1 + 1, db_pgroups2) self.delete_last_argument_by_conclusion_uid(2)
def add_edit_reviews(self, db_user: User, uid: int, text: str): """ Setup a new ReviewEdit row :param db_user: User :param uid: Statement.uid :param text: New content for statement :return: -1 if the statement of the element does not exists, -2 if this edit already exists, 1 on success, 0 otherwise """ db_statement = DBDiscussionSession.query(Statement).get(uid) if not db_statement: LOG.warning("Statement %s not found (return %s)", uid, Code.DOESNT_EXISTS) return Code.DOESNT_EXISTS # already set an correction for this? if self.is_statement_in_edit_queue( uid): # if we already have an edit, skip this LOG.warning("Statement %s already got an edit (return %s)", uid, Code.DUPLICATE) return Code.DUPLICATE # is text different? db_tv = DBDiscussionSession.query(TextVersion).get( db_statement.textversion_uid) if len(text) > 0 and db_tv.content.lower().strip() != text.lower( ).strip(): LOG.debug("Added review element for %s. (return %s)", uid, Code.SUCCESS) DBDiscussionSession.add( ReviewEdit(detector=db_user.uid, statement=uid)) return Code.SUCCESS LOG.debug("No case for %s (return %s)", uid, Code.ERROR) return Code.ERROR
def get_reference_usages(request: Request): """ Return a JSON object containing all information about the stored reference and its usages. :param request: :return: JSON with all information about the stored reference :rtype: list """ ref_uid = request.validated["ref_uid"] LOG.debug("Retrieving reference usages for ref_uid {}".format(ref_uid)) db_ref: StatementReference = DBDiscussionSession.query( StatementReference).get(ref_uid) if db_ref: return get_all_references_by_reference_text(db_ref.text) return error("Reference could not be found")
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 get_queue_information(self, db_user: User, session: Session, application_url: str, translator: Translator): """ Setup the subpage for the delete queue :param db_user: User :param session: session of current webserver request :param application_url: current url of the app :param translator: Translator :return: dict() """ LOG.debug("Entering setup for subpage of deletion queue") all_rev_dict = get_all_allowed_reviews_for_user(session, f'already_seen_{self.key}', db_user, ReviewDelete, LastReviewerDelete) rev_dict = get_base_subpage_dict(ReviewDelete, all_rev_dict['reviews'], all_rev_dict['already_seen_reviews'], all_rev_dict['first_time'], db_user, all_rev_dict['already_voted_reviews']) if not rev_dict['rnd_review']: return { 'stats': None, 'text': None, 'reason': None, 'issue_titles': None, 'extra_info': None, 'session': session } db_reason = DBDiscussionSession.query(ReviewDeleteReason).get(rev_dict['rnd_review'].reason_uid) stats = get_reporter_stats_for_review(rev_dict['rnd_review'], translator.get_lang(), application_url) reason = '' if db_reason.reason == 'offtopic': reason = translator.get(_.argumentFlaggedBecauseOfftopic) if db_reason.reason == 'spam': reason = translator.get(_.argumentFlaggedBecauseSpam) if db_reason.reason == 'harmful': reason = translator.get(_.argumentFlaggedBecauseHarmful) rev_dict['already_seen_reviews'].append(rev_dict['rnd_review'].uid) session[f'already_seen_{self.key}'] = rev_dict['already_seen_reviews'] return { 'stats': stats, 'text': rev_dict['text'], 'reason': reason, 'issue_titles': rev_dict['issue_titles'], 'extra_info': rev_dict['extra_info'], 'session': session }
def get_issue_based_on_header(request): """ :param request: :return: """ # logger('IssueHelper', 'get_issue_based_on_header', 'no saved issue found') ui_locales = get_language_from_header(request) db_issues = get_enabled_issues_as_query() db_lang = DBDiscussionSession.query(Language).filter_by( ui_locales=ui_locales).first() db_issue = db_issues.filter_by(lang_uid=db_lang.uid).first() if not db_issue: db_issue = db_issues.first() return db_issue.uid
def valid_statement_or_argument(request): is_argument = request.json_body.get('is_argument') t = Argument if is_argument else Statement uid = request.json_body.get('uid') if uid: db_arg_or_stmt = DBDiscussionSession.query(t).get(uid) else: add_error(request, 'Missing uid for ' + t.__name__) return False if db_arg_or_stmt: request.validated['arg_or_stmt'] = db_arg_or_stmt return True else: add_error(request, t.__name__ + ' is invalid') return False
def valid_any_issue_by_id(request): """ Query issue from database and put it into the request, even if it is disabled :param request: :return: """ issue_id = issue_handler.get_issue_id(request) if issue_id: db_issue: Issue = DBDiscussionSession.query(Issue).get(issue_id) request.validated['issue'] = db_issue return True add_error(request, 'Invalid issue {}'.format(issue_id)) return False