def get_history_of(db_user: User, translator: Translator):
"""
Returns the reputation history of an user
:param db_user: User
:param translator: Translator
:return: dict()
"""
db_reputation = DBDiscussionSession.query(ReputationHistory) \
.filter_by(reputator_uid=db_user.uid) \
.join(ReputationReason, ReputationReason.uid == ReputationHistory.reputation_uid) \
.order_by(ReputationHistory.uid.asc()) \
.all()
rep_list = []
for rep in db_reputation:
date = sql_timestamp_pretty_print(rep.timestamp,
translator.get_lang(),
humanize=False)
points_data = ('+' if rep.reputations.points > 0 else '') + str(
rep.reputations.points)
rep_list.append({
'date': date,
'points_data': points_data,
'action': translator.get(rep.reputations.reason),
'points': rep.reputations.points
})
count, all_rights = get_reputation_of(db_user)
return {
'count': count,
'all_rights': all_rights,
'history': list(reversed(rep_list))
}
def get_issue_dict_for(db_issue: Issue, uid: int, lang: str) -> dict:
"""
Creates an dictionary for the issue
:param db_issue: Issue
:param uid: current selected Issue.uid
:param lang: ui_locales
:return: dict()
"""
_um = UrlManager(db_issue.slug)
issue_dict = {
'uid': str(db_issue.uid),
'slug': db_issue.slug,
'title': db_issue.title,
'url': '/' + db_issue.slug,
'review_url':
_um.get_review_url() if str(uid) != str(db_issue.uid) else '',
'info': db_issue.info,
'stat_count': get_number_of_statements(db_issue.uid),
'date': sql_timestamp_pretty_print(db_issue.date, lang),
'author': db_issue.author.public_nickname,
'error': '',
'author_url': '/user/{}'.format(db_issue.author.uid),
'enabled': 'disabled' if str(uid) == str(db_issue.uid) else 'enabled'
}
return issue_dict
def get_latest_news(ui_locales):
"""
Returns the latest news for the carousel
:param ui_locales:
:return: dict()
:return:
"""
logger('NewsHelper', 'main')
db_news = DBDiscussionSession.query(News).order_by(News.date.desc()).all()
ret_news = []
for index, news in enumerate(db_news[:5]):
news_dict = {
'indicatorclass': '',
'blockclass': 'carousel-item',
'title': news.title,
'author': news.author,
'date': sql_timestamp_pretty_print(news.date, ui_locales, False),
'news': news.news,
'id': index
}
ret_news.append(news_dict)
ret_news[0]['indicatorclass'] = 'active'
ret_news[0]['blockclass'] += ' active'
return ret_news
def set_news(title: str, text: str, db_user: User, lang: str,
main_page: str) -> dict():
"""
Sets a new news into the news table
:param title: of the news
:param text: of the news
:param db_user: author of the news
:param lang: ui_locales
:param main_page: url
:return:
"""
logger('NewsHelper', 'def')
author = db_user.firstname
if db_user.firstname != 'admin':
author += ' {}'.format(db_user.surname)
date = arrow.now()
DBDiscussionSession.add(
News(title=title, author=author, date=arrow.now(), news=text))
DBDiscussionSession.flush()
transaction.commit()
return_dict = {
'status': 'success',
'title': title,
'date': sql_timestamp_pretty_print(date, lang, False),
'author': author,
'news': text
}
create_news_rss(main_page, lang)
return return_dict
def get_clicked_elements_of(db_user: User, is_argument: bool, lang: str) -> list:
"""
Returns array with all clicked elements by the user. Each element is a dict with information like the uid,
timestamp, up_Vote, validity, the clicked uid and content of the clicked element.
:param db_user: User
:param is_argument: Boolean
:param lang: ui_locales
:return: [{},...]
"""
return_array = []
db_type = ClickedArgument if is_argument else ClickedStatement
db_clicks = DBDiscussionSession.query(db_type).filter_by(author_uid=db_user.uid).all()
for click in db_clicks:
click_dict = dict()
click_dict['uid'] = click.uid
click_dict['timestamp'] = sql_timestamp_pretty_print(click.timestamp, lang)
click_dict['is_up_vote'] = click.is_up_vote
click_dict['is_valid'] = click.is_valid
if is_argument:
click_dict['argument_uid'] = click.argument_uid
click_dict['content'] = get_text_for_argument_uid(click.argument_uid, lang)
else:
click_dict['statement_uid'] = click.statement_uid
click_dict['content'] = get_text_for_statement_uid(click.statement_uid)
return_array.append(click_dict)
return return_array
def get_marked_elements_of(db_user: User, is_argument: bool, lang: str):
"""
Get all marked arguments/statements of the user
:param db_user: User
:param is_argument: Boolean
:param lang: uid_locales
:return: [{},...]
"""
return_array = []
if is_argument:
db_votes = DBDiscussionSession.query(MarkedArgument).filter_by(author_uid=db_user.uid).all()
else:
db_votes = DBDiscussionSession.query(MarkedStatement).filter_by(author_uid=db_user.uid).all()
for vote in db_votes:
vote_dict = dict()
vote_dict['uid'] = str(vote.uid)
vote_dict['timestamp'] = sql_timestamp_pretty_print(vote.timestamp, lang)
if is_argument:
vote_dict['argument_uid'] = str(vote.argument_uid)
vote_dict['content'] = get_text_for_argument_uid(vote.argument_uid, lang)
else:
vote_dict['statement_uid'] = str(vote.statement_uid)
vote_dict['content'] = get_text_for_statement_uid(vote.statement_uid)
return_array.append(vote_dict)
return return_array
def get_information_of(db_user: User, lang):
"""
Returns public information of the given user
:param db_user: User
:param lang: ui_locales
:return: dict()
"""
if db_user.nickname == nick_of_anonymous_user:
return __get_special_infos(lang)
db_group = DBDiscussionSession.query(Group).get(db_user.group_uid)
ret_dict = dict()
ret_dict['public_nick'] = db_user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
db_user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(
db_user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(
db_user.registered, lang)
ret_dict['group'] = start_with_capital(db_group.name)
ret_dict['is_male'] = db_user.gender == 'm'
ret_dict['is_female'] = db_user.gender == 'f'
ret_dict['is_neutral'] = db_user.gender != 'm' and db_user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(db_user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=db_user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=db_user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=db_user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=db_user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(db_user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(db_user, 120)
ret_dict['discussion_stat_rep'], trash = get_reputation_of(db_user)
return ret_dict
def _get_special_infos(lang: str) -> Dict[str, Any]:
return {
'public_nick': 'Son Goku',
'last_action': sql_timestamp_pretty_print(get_now(), lang),
'last_login': sql_timestamp_pretty_print(get_now(), lang),
'registered': sql_timestamp_pretty_print(get_now(), lang),
'group': 'Saiyajin',
'is_male': True,
'is_female': False,
'is_neutral': False,
'statements_posted': '>9000',
'edits_done': '>9000',
'reviews_proposed': '>9000',
'discussion_arg_votes': '>9000',
'discussion_stat_votes': '>9000',
'avatar_url': '/static/images/goku.jpg',
'discussion_stat_rep': '>9000',
}
def get_information_of(user: User, lang: str) -> Dict[str, Any]:
"""
Returns public information of the given user.
:param user: User whose information is queried.
:param lang: Language-string representing language of the answer.
:return: A dictionary containing the public information.
"""
if user.nickname == nick_of_anonymous_user:
return _get_special_infos(lang)
ret_dict = dict()
ret_dict['public_nick'] = user.global_nickname
ret_dict['last_action'] = sql_timestamp_pretty_print(
user.last_action, lang)
ret_dict['last_login'] = sql_timestamp_pretty_print(user.last_login, lang)
ret_dict['registered'] = sql_timestamp_pretty_print(user.registered, lang)
ret_dict['group'] = start_with_capital(user.group.name)
ret_dict['is_male'] = user.gender == 'm'
ret_dict['is_female'] = user.gender == 'f'
ret_dict['is_neutral'] = user.gender != 'm' and user.gender != 'f'
arg_votes, stat_votes = get_mark_count_of(user, False)
db_reviews_duplicate = DBDiscussionSession.query(
ReviewDuplicate).filter_by(detector_uid=user.uid).all()
db_reviews_edit = DBDiscussionSession.query(ReviewEdit).filter_by(
detector_uid=user.uid).all()
db_reviews_delete = DBDiscussionSession.query(ReviewDelete).filter_by(
detector_uid=user.uid).all()
db_reviews_optimization = DBDiscussionSession.query(
ReviewOptimization).filter_by(detector_uid=user.uid).all()
db_reviews = db_reviews_duplicate + db_reviews_edit + db_reviews_delete + db_reviews_optimization
get_tv_dict = get_textversions(user, lang)
ret_dict['statements_posted'] = len(get_tv_dict.get('statements', []))
ret_dict['edits_done'] = len(get_tv_dict.get('edits', []))
ret_dict['reviews_proposed'] = len(db_reviews)
ret_dict['discussion_arg_votes'] = arg_votes
ret_dict['discussion_stat_votes'] = stat_votes
ret_dict['avatar_url'] = get_profile_picture(user, 120)
ret_dict['discussion_stat_rep'], _ = get_reputation_of(user)
return ret_dict
def get_box_for(db_user, lang, main_page, is_inbox):
"""
Returns all notifications for the user
:param db_user: User
:param lang: ui_locales
:param main_page: URL
:param is_inbox: Boolean
:return: [Notification]
"""
if is_inbox:
db_messages = DBDiscussionSession.query(Message).filter(
Message.to_author_uid == db_user.uid,
Message.is_inbox == is_inbox).order_by(Message.uid.desc()).all()
else:
db_messages = DBDiscussionSession.query(Message).filter(
Message.from_author_uid == db_user.uid,
Message.is_inbox == is_inbox).order_by(Message.uid.desc()).all()
message_array = []
for message in db_messages:
tmp_dict = dict()
if is_inbox:
db_from_user = DBDiscussionSession.query(User).get(
message.from_author_uid)
tmp_dict[
'show_from_author'] = db_from_user.global_nickname != 'admin'
tmp_dict['from_author'] = db_from_user.global_nickname
tmp_dict['from_author_avatar'] = get_profile_picture(db_from_user,
size=30)
tmp_dict['from_author_url'] = main_page + '/user/' + str(
db_from_user.uid)
else:
db_to_user = DBDiscussionSession.query(User).get(
message.to_author_uid)
tmp_dict['to_author'] = db_to_user.global_nickname
tmp_dict['to_author_avatar'] = get_profile_picture(db_to_user,
size=30)
tmp_dict['to_author_url'] = main_page + '/user/' + str(
db_to_user.uid)
tmp_dict['id'] = str(message.uid)
tmp_dict['timestamp'] = sql_timestamp_pretty_print(
message.timestamp, lang)
tmp_dict['read'] = message.read
tmp_dict['topic'] = message.topic
tmp_dict['content'] = message.content
tmp_dict['collapse_link'] = '#collapse' + str(message.uid)
tmp_dict['collapse_id'] = 'collapse' + str(message.uid)
message_array.append(tmp_dict)
return message_array[::-1]
def prepare_json_of_issue(db_issue: Issue, db_user: User) -> dict():
"""
Prepares slug, info, argument count and the date of the issue as dict
:param db_issue: Issue
:param db_user: User
:return: Issue-dict()
"""
slug = slugify(db_issue.title)
title = db_issue.title
info = db_issue.info
long_info = db_issue.long_info
stat_count = get_number_of_statements(db_issue.uid)
lang = db_issue.lang
date_pretty = sql_timestamp_pretty_print(db_issue.date, lang)
duration = (arrow.utcnow() - db_issue.date)
days, seconds = duration.days, duration.seconds
duration = ceil(days * 24 + seconds / 3600)
date_ms = int(db_issue.date.format('X')) * 1000
date = db_issue.date.format('DD.MM.YY')
time = db_issue.date.format('HH:mm')
db_issues = get_visible_issues_for_user_as_query(
db_user.uid).filter(Issue.uid != db_issue.uid).all()
all_array = [
get_issue_dict_for(issue, db_issue.uid, lang) for issue in db_issues
]
_t = Translator(lang)
tooltip = _t.get(_.discussionInfoTooltipSg) if stat_count == 1 else _t.get(
_.discussionInfoTooltipPl)
tooltip = tooltip.format(date, time, stat_count)
return {
'slug': slug,
'lang': lang,
'info': info,
'long_info': long_info,
'title': title,
'uid': db_issue.uid,
'stat_count': stat_count,
'date': date,
'date_ms': date_ms,
'date_pretty': date_pretty,
'all': all_array,
'tooltip': tooltip,
'intro': _t.get(_.currentDiscussion),
'duration': duration,
'read_only': db_issue.is_read_only
}
def __get_executed_review_element_of(table_key, main_page, db_review,
translator,
is_executed) -> Optional[dict]:
"""
:param table_key: Shortcut for the table
:param main_page: Main page of D-BAS
:param db_review: Element
:param translator: current ui_locales
:param is_executed
:return: Element
"""
queue = get_queue_by_key(table_key)
adapter = QueueAdapter(queue=queue(),
application_url=main_page,
translator=translator)
full_text = adapter.get_text_of_element(db_review)
if not full_text:
return None
# pretty print
intro = translator.get(_.otherUsersSaidThat) + ' '
if full_text.startswith(intro):
short_text = full_text[len(intro):len(intro) + 1].upper()
short_text += full_text[len(intro) + 1:len(intro) +
txt_len_history_page]
else:
short_text = full_text[0:txt_len_history_page]
short_text += '...' if len(full_text) > txt_len_history_page else '.'
short_text = f'<span class="text-primary">{short_text}</span>'
pro_list, con_list = adapter.get_all_votes_for(db_review)
# and build up some dict
pdict = __handle_table_of_review_element(table_key, db_review, short_text,
full_text, is_executed)
if not pdict:
return None
pdict['entry_id'] = db_review.uid
pdict['timestamp'] = sql_timestamp_pretty_print(db_review.timestamp,
translator.get_lang())
pdict['votes_pro'] = pro_list
pdict['votes_con'] = con_list
pdict['reporter'] = __get_user_dict_for_review(db_review.detector_uid,
main_page)
return pdict
def create_users_dict(db_user, timestamp, main_page, lang):
"""
Creates dictionary with nickname, url and timestamp
:param db_user: User
:param timestamp: SQL Timestamp
:param main_page: url
:param lang: language
:return: dict()
"""
tmp = db_user.global_nickname
return {'nickname': tmp,
'public_profile_url': main_page + '/user/' + str(db_user.uid),
'avatar_url': get_profile_picture(db_user),
'vote_timestamp': sql_timestamp_pretty_print(timestamp, lang)}
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 get_all_infos_about_argument(db_argument: Argument, main_page, db_user,
lang) -> dict:
"""
Returns bunch of information about the given argument
:param db_argument: The argument
:param main_page: url of the application
:param db_user: User
:param lang: Language
:rtype: dict
:return: dictionary with many information or an error
"""
_t = Translator(lang.ui_locales)
return_dict = dict()
db_votes = DBDiscussionSession.query(ClickedArgument).filter(
ClickedArgument.argument_uid == db_argument.uid,
ClickedArgument.is_valid == True,
ClickedStatement.is_up_vote == True).all()
db_author = DBDiscussionSession.query(User).get(db_argument.author_uid)
return_dict['vote_count'] = str(len(db_votes))
return_dict['author'] = db_author.global_nickname
return_dict['author_url'] = main_page + '/user/' + str(db_author.uid)
return_dict['gravatar'] = get_profile_picture(db_author)
return_dict['timestamp'] = sql_timestamp_pretty_print(
db_argument.timestamp, db_argument.lang)
text = get_text_for_argument_uid(db_argument.uid)
return_dict['text'] = start_with_capital(text)
supporters = []
gravatars = dict()
public_page = dict()
for vote in db_votes:
db_author = DBDiscussionSession.query(User).get(vote.author_uid)
name = db_author.global_nickname
if db_user.nickname == db_author.nickname:
name += ' (' + _t.get(_.itsYou) + ')'
supporters.append(name)
gravatars[name] = get_profile_picture(db_author)
public_page[name] = main_page + '/user/' + str(db_author.uid)
return_dict['supporter'] = supporters
return_dict['gravatars'] = gravatars
return_dict['public_page'] = public_page
return return_dict
def __get_logfile_dict(textversion: TextVersion, main_page: str, lang: str) -> Dict:
"""
Returns dictionary with information about the given textversion
:param textversion: TextVersion
:param main_page: String
:param lang: Language.ui_locales
:return: dict()
"""
db_author = DBDiscussionSession.query(User).get(textversion.author_uid)
corr_dict = dict()
corr_dict['uid'] = str(textversion.uid)
corr_dict['author'] = str(db_author.global_nickname)
corr_dict['author_url'] = main_page + '/user/' + str(db_author.uid)
corr_dict['author_gravatar'] = get_profile_picture(db_author, 20)
corr_dict['date'] = sql_timestamp_pretty_print(textversion.timestamp, lang)
corr_dict['text'] = str(textversion.content)
return corr_dict
def get_reporter_stats_for_review(db_review, ui_locales, main_page):
"""
Get statistics for the current review
:param db_review: Review-Row
:param ui_locales: Language.ui_locales
:param main_page: Host URL
:return: dict()
"""
LOG.debug("Return statistics for review %s", db_review.uid)
db_reporter = DBDiscussionSession.query(User).get(db_review.detector_uid)
return {
'reported': sql_timestamp_pretty_print(db_review.timestamp, ui_locales),
'reporter': db_reporter.global_nickname,
'reporter_gravatar': get_profile_picture(db_reporter, 20),
'reporter_url': main_page + '/user/' + str(db_reporter.uid),
'id': str(db_review.uid)
}
def _clicked_argument_to_dict(clicked_argument: ClickedArgument,
lang: str) -> Dict[str, Any]:
"""
Transforms a single ClickedArgument object into a dictionary representation of itself.
:param clicked_argument: The object that shall be transformed.
:param lang: Language that the answer shall be delivered in.
:return: A dictionary representing `clicked_argument`.
"""
return {
'uid': clicked_argument.uid,
'timestamp': sql_timestamp_pretty_print(clicked_argument.timestamp,
lang),
'is_up_vote': clicked_argument.is_up_vote,
'is_valid': clicked_argument.is_valid,
'argument_uid': clicked_argument.argument_uid,
'content': get_text_for_argument_uid(clicked_argument.argument_uid,
lang)
}
def get_textversions(db_user: User,
lang: str,
timestamp_after=None,
timestamp_before=None):
"""
Returns all textversions, were the user was author
:param db_user: User
:param lang: ui_locales
:param timestamp_after: Arrow or None
:param timestamp_before: Arrow or None
:return: [{},...], [{},...]
"""
statement_array = []
edit_array = []
if not timestamp_after:
timestamp_after = arrow.get('1970-01-01').format('YYYY-MM-DD')
if not timestamp_before:
timestamp_before = arrow.utcnow().replace(days=+1).format('YYYY-MM-DD')
db_edits = DBDiscussionSession.query(TextVersion).filter(
TextVersion.author_uid == db_user.uid,
TextVersion.timestamp >= timestamp_after,
TextVersion.timestamp < timestamp_before).all()
for edit in db_edits:
db_root_version = DBDiscussionSession.query(TextVersion).filter_by(
statement_uid=edit.statement_uid).first()
edit_dict = dict()
edit_dict['uid'] = str(edit.uid)
edit_dict['statement_uid'] = str(edit.statement_uid)
edit_dict['content'] = str(edit.content)
edit_dict['timestamp'] = sql_timestamp_pretty_print(
edit.timestamp, lang)
if db_root_version.uid == edit.uid:
statement_array.append(edit_dict)
else:
edit_array.append(edit_dict)
return {'statements': statement_array, 'edits': edit_array}
def get_textversions(user: User, lang: str, timestamp_after: Arrow = None, timestamp_before: Arrow = None) -> \
Dict[str, List[Dict[str, str]]]:
"""
Returns all textversions, were the user is the author.
:param user: The user who is author of desired textversion objects.
:param lang: The language in which the results shall be delivered.
:param timestamp_after: Set a date if results should only include objects created after the date.
:param timestamp_before: Set a date if results should only include objects created before the date.
:return: Return a dict with all statements and edits that use a textversion where the user is author.
"""
statements = []
edits = []
if not timestamp_after:
timestamp_after = arrow.get('1970-01-01').format('YYYY-MM-DD')
if not timestamp_before:
timestamp_before = arrow.utcnow().replace(days=+1).format('YYYY-MM-DD')
textversions = DBDiscussionSession.query(TextVersion).filter(
TextVersion.author_uid == user.uid,
TextVersion.timestamp >= timestamp_after,
TextVersion.timestamp < timestamp_before).all()
for textversion in textversions:
db_root_version = DBDiscussionSession.query(TextVersion).filter_by(
statement_uid=textversion.statement_uid).first()
edit_dict = dict()
edit_dict['uid'] = str(textversion.uid)
edit_dict['statement_uid'] = str(textversion.statement_uid)
edit_dict['content'] = str(textversion.content)
edit_dict['timestamp'] = sql_timestamp_pretty_print(
textversion.timestamp, lang)
if db_root_version.uid == textversion.uid:
statements.append(edit_dict)
else:
edits.append(edit_dict)
return {'statements': statements, 'edits': edits}
def __get_stats_for_review(review, ui_locales, main_page):
"""
Get statistics for the current review
:param review: Review-Row
:param ui_locales: Language.ui_locales
:param main_page: Host URL
:return: dict()
"""
logger('ReviewSubpagerHelper', 'main')
db_reporter = DBDiscussionSession.query(User).get(review.detector_uid)
stats = dict()
stats['reported'] = sql_timestamp_pretty_print(review.timestamp,
ui_locales)
stats['reporter'] = db_reporter.global_nickname
stats['reporter_gravatar'] = get_profile_picture(db_reporter, 20)
stats['reporter_url'] = main_page + '/user/' + str(db_reporter.uid)
stats['id'] = str(review.uid)
return stats
def get_reputation_history_of(nickname, translator):
"""
Returns the reputation history of an user
:param nickname: User.nickname
:param translator: Translator
:return: dict()
"""
db_user = DBDiscussionSession.query(User).filter_by(nickname=nickname).first()
if not db_user:
return dict()
ret_dict = dict()
count, all_rights = get_reputation_of(nickname)
ret_dict['count'] = count
ret_dict['all_rights'] = all_rights
db_reputation = DBDiscussionSession.query(ReputationHistory) \
.filter_by(reputator_uid=db_user.uid) \
.join(ReputationReason, ReputationReason.uid == ReputationHistory.reputation_uid) \
.order_by(ReputationHistory.uid.asc())\
.all()
rep_list = list()
for rep in db_reputation:
date = sql_timestamp_pretty_print(rep.timestamp, translator.get_lang(), humanize=False)
points_data = ('+' if rep.reputations.points > 0 else '') + str(rep.reputations.points)
points = rep.reputations.points
action = translator.get(rep.reputations.reason)
rep_list.append({'date': date,
'points_data': points_data,
'action': action,
'points': points})
ret_dict['history'] = list(reversed(rep_list))
return ret_dict
def get_news(ui_locales):
"""
Returns all news in an array, sorted by date
:param ui_locales:
:return: dict()
"""
logger('NewsHelper', 'main')
db_news = DBDiscussionSession.query(News).order_by(News.date.desc()).all()
ret_news = []
for news in db_news:
news_dict = {
'title': news.title,
'author': news.author,
'date': sql_timestamp_pretty_print(news.date, ui_locales, False),
'news': news.news,
'title_id': 'news_{}_title'.format(news.uid),
'date_id': 'news_{}_date'.format(news.uid),
'author_id': 'news_{}_author'.format(news.uid),
'uid': 'news_' + str(news.uid)
}
ret_news.append(news_dict)
return ret_news
def send_users_notification(author, recipient, title, text,
ui_locales) -> dict:
"""
Send a notification from user a to user b
:param recipient: User
:param title: Title of the notification
:param text: Text of the notification
:param author: User
:param ui_locales: Current used language
:rtype: dict
:return: prepared collection with status information
"""
db_notification = send_notification(author, recipient, title, text,
author.nickname)
prepared_dict = {
'timestamp':
sql_timestamp_pretty_print(db_notification.timestamp, ui_locales),
'uid':
db_notification.uid,
'recipient_avatar':
get_profile_picture(recipient, 20)
}
return prepared_dict
def __get_executed_review_element_of(table, main_page, review, last_review_type, translator, is_executed):
"""
:param table: Shortcut for the table
:param main_page: Main page of D-BAS
:param review: Element
:param last_review_type: Type of the last reviewer of the table
:param translator: current ui_locales
:param is_executed
:return: Element
"""
length = 35
# getting text
if table == 'duplicates':
full_text = get_text_for_statement_uid(review.duplicate_statement_uid)
elif table in ['splits', 'merges']:
full_text = get_text_for_premisegroup_uid(review.premisegroup_uid)
elif review.statement_uid is None:
full_text = get_text_for_argument_uid(review.argument_uid)
else:
full_text = get_text_for_statement_uid(review.statement_uid)
# pretty print
intro = translator.get(_.otherUsersSaidThat) + ' '
if full_text.startswith(intro):
short_text = full_text[len(intro):len(intro) + 1].upper() + full_text[len(intro) + 1:len(intro) + length]
else:
short_text = full_text[0:length]
short_text += '...' if len(full_text) > length else '.'
short_text = '<span class="text-primary">' + short_text + '</span>'
all_votes = DBDiscussionSession.query(last_review_type).filter_by(review_uid=review.uid)
is_okay = False if table == 'optimizations' else True
if table is 'merges':
pro_votes = all_votes.filter_by(should_merge=is_okay).all()
con_votes = all_votes.filter(last_review_type.should_merge != is_okay).all()
elif table is 'splits':
pro_votes = all_votes.filter_by(should_split=is_okay).all()
con_votes = all_votes.filter(last_review_type.should_split != is_okay).all()
else:
pro_votes = all_votes.filter_by(is_okay=is_okay).all()
con_votes = all_votes.filter(last_review_type.is_okay != is_okay).all()
# getting the users which have voted
pro_list = [__get_user_dict_for_review(pro.reviewer_uid, main_page) for pro in pro_votes]
con_list = [__get_user_dict_for_review(con.reviewer_uid, main_page) for con in con_votes]
if table == 'duplicates':
# switch it, because contra is: it should not be there!
tmp_list = pro_list
pro_list = con_list
con_list = tmp_list
# and build up some dict
entry = dict()
entry['entry_id'] = review.uid
tmp = __handle_table_of_review_element(table, entry, review, short_text, full_text, length, is_executed)
if not tmp:
entry = None
else:
entry.update(tmp)
entry['pro'] = pro_list
entry['con'] = con_list
entry['timestamp'] = sql_timestamp_pretty_print(review.timestamp, translator.get_lang())
entry['votes_pro'] = pro_list
entry['votes_con'] = con_list
entry['reporter'] = __get_user_dict_for_review(review.detector_uid, main_page)
return entry
