def subscribe_to_topic_with_id():
"""
:param: topic_id -- the id of the topic to be subscribed to.
Subscribe to the topic with the given id
:return: "OK" in case of success
"""
topic_id = int(request.form.get('topic_id', ''))
topic_object = Topic.find_by_id(topic_id)
TopicSubscription.find_or_create(session, flask.g.user, topic_object)
return "OK"
def subscribe_to_topic_with_id():
"""
:param: topic_id -- the id of the topic to be subscribed to.
Subscribe to the topic with the given id
:return: "OK" in case of success
"""
topic_id = int(request.form.get('topic_id', ''))
topic_object = Topic.find_by_id(topic_id)
TopicSubscription.find_or_create(session, flask.g.user, topic_object)
return "OK"
def _reading_preferences_hash(user):
"""
Method to retrieve the hash, as this is done several times.
:param user:
:return: articles_hash: ArticlesHash
"""
user_filter_subscriptions = TopicFilter.all_for_user(user)
filters = [topic_id.topic for topic_id in user_filter_subscriptions]
user_topic_subscriptions = TopicSubscription.all_for_user(user)
topics = [topic_id.topic for topic_id in user_topic_subscriptions]
user_languages = Language.all_reading_for_user(user)
user_search_filters = SearchFilter.all_for_user(user)
search_filters = [search_id.search for search_id in user_search_filters]
user_searches = SearchSubscription.all_for_user(user)
searches = [search_id.search for search_id in user_searches]
articles_hash = ArticlesCache.calculate_hash(
user, topics, filters, searches, search_filters, user_languages
)
return articles_hash
def get_interesting_topics():
"""
Get a list of interesting topics for the given language.
Interesting topics are for now defined as:
- The topic is not followed yet
- The topic is not in the filters list
- There are articles with that topic in the language
:return:
"""
topic_data = []
already_filtered = [each.topic for each in TopicFilter.all_for_user(flask.g.user)]
already_subscribed = [
each.topic for each in TopicSubscription.all_for_user(flask.g.user)
]
reading_languages = Language.all_reading_for_user(flask.g.user)
loc_topics = []
for each in reading_languages:
loc_topics.extend(LocalizedTopic.all_for_language(each))
topics = [each.topic for each in loc_topics]
for topic in topics:
if (topic not in already_filtered) and (topic not in already_subscribed):
topic_data.append(topic.as_dictionary())
return json_result(topic_data)
def get_interesting_topics():
"""
Get a list of interesting topics for the given language.
Interesting topics are for now defined as:
- The topic is not followed yet
- The topic is not in the filters list
:return:
"""
topic_data = []
already_filtered = [each.topic for each in TopicFilter.all_for_user(flask.g.user)]
already_subscribed = [each.topic for each in TopicSubscription.all_for_user(flask.g.user)]
for topic in Topic.get_all_topics():
if (topic not in already_filtered) and (topic not in already_subscribed):
topic_data.append(topic.as_dictionary())
return json_result(topic_data)
def unsubscribe_from_topic():
"""
A user can unsubscribe from the topic with a given ID
:return: "OK" in case of success
"""
topic_id = int(request.form.get('topic_id', ''))
try:
to_delete = TopicSubscription.with_topic_id(topic_id, flask.g.user)
session.delete(to_delete)
session.commit()
except Exception as e:
return "OOPS. FEED AIN'T THERE IT SEEMS (" + str(e) + ")"
return "OK"
def unsubscribe_from_topic():
"""
A user can unsubscribe from the topic with a given ID
:return: "OK" in case of success
"""
topic_id = int(request.form.get('topic_id', ''))
try:
to_delete = TopicSubscription.with_topic_id(topic_id, flask.g.user)
session.delete(to_delete)
session.commit()
except Exception as e:
return "OOPS. FEED AIN'T THERE IT SEEMS (" + str(e) + ")"
return "OK"
def get_subscribed_topics():
"""
A user might be subscribed to multiple topics at once.
This endpoint returns them as a list.
:return: a json list with feeds for which the user is registered;
every feed in this list is a dictionary with the following info:
id = unique id of the topic;
title = <unicode string>
"""
subscriptions = TopicSubscription.all_for_user(flask.g.user)
topic_list = []
for sub in subscriptions:
try:
topic_list.append(sub.topic.as_dictionary())
except Exception as e:
zeeguu_core.log(str(e))
return json_result(topic_list)
def get_subscribed_topics():
"""
A user might be subscribed to multiple topics at once.
This endpoint returns them as a list.
:return: a json list with feeds for which the user is registered;
every feed in this list is a dictionary with the following info:
id = unique id of the topic;
title = <unicode string>
"""
subscriptions = TopicSubscription.all_for_user(flask.g.user)
topic_list = []
for sub in subscriptions:
try:
topic_list.append(sub.topic.as_dictionary())
except Exception as e:
zeeguu_core.log(str(e))
return json_result(topic_list)
def _find_articles_for_user(user):
"""
This method gets all the topic and search subscriptions for a user.
It then returns all the articles that are associated with these.
:param user:
:return:
"""
user_languages = Language.all_reading_for_user(user)
topic_subscriptions = TopicSubscription.all_for_user(user)
search_subscriptions = SearchSubscription.all_for_user(user)
subscribed_articles = _filter_subscribed_articles(
search_subscriptions, topic_subscriptions, user_languages, user
)
return subscribed_articles
def get_interesting_topics():
"""
Get a list of interesting topics for the given language.
Interesting topics are for now defined as:
- The topic is not followed yet
- The topic is not in the filters list
:return:
"""
topic_data = []
already_filtered = [
each.topic for each in TopicFilter.all_for_user(flask.g.user)
]
already_subscribed = [
each.topic for each in TopicSubscription.all_for_user(flask.g.user)
]
for topic in Topic.get_all_topics():
if (topic not in already_filtered) and (topic
not in already_subscribed):
topic_data.append(topic.as_dictionary())
return json_result(topic_data)
def article_search_for_user(user, count, search_terms):
"""
Handles searching.
Find the relational values from the database and use them to search in elasticsearch for relative articles.
:param user:
:param count: max amount of articles to return
:param search_terms: the inputed search string by the user
:return: articles
"""
user_languages = Language.all_reading_for_user(user)
per_language_article_count = count / len(user_languages)
final_article_mix = []
for language in user_languages:
print(f"language: {language}")
# 0. Ensure appropriate difficulty
declared_level_min, declared_level_max = user.levels_for(language)
lower_bounds = declared_level_min * 10
upper_bounds = declared_level_max * 10
# 1. Unwanted user topics
# ==============================
user_search_filters = SearchFilter.all_for_user(user)
unwanted_user_topics = []
for user_search_filter in user_search_filters:
unwanted_user_topics.append(user_search_filter.search.keywords)
print(f"keywords to exclude: {unwanted_user_topics}")
# 2. Topics to exclude / filter out
# =================================
excluded_topics = TopicFilter.all_for_user(user)
topics_to_exclude = [each.topic.title for each in excluded_topics]
print(f"topics to exclude: {topics_to_exclude}")
# 3. Topics subscribed, and thus to include
# =========================================
topic_subscriptions = TopicSubscription.all_for_user(user)
topics_to_include = [
subscription.topic.title
for subscription in TopicSubscription.all_for_user(user)
]
print(f"topics to include: {topic_subscriptions}")
# 4. Wanted user topics
# =========================================
user_subscriptions = SearchSubscription.all_for_user(user)
wanted_user_topics = []
for sub in user_subscriptions:
wanted_user_topics.append(sub.search.keywords)
print(f"keywords to include: {wanted_user_topics}")
# build the query using elastic_query_builder
query_body = build_elastic_query(
per_language_article_count,
search_terms,
_list_to_string(topics_to_include),
_list_to_string(topics_to_exclude),
_list_to_string(wanted_user_topics),
_list_to_string(unwanted_user_topics),
language,
upper_bounds,
lower_bounds,
)
es = Elasticsearch(ES_CONN_STRING)
res = es.search(index=ES_ZINDEX, body=query_body)
hit_list = res["hits"].get("hits")
final_article_mix.extend(_to_articles_from_ES_hits(hit_list))
# convert to article_info and return
return [
UserArticle.user_article_info(user, article)
for article in final_article_mix if article is not None
]