def get_user_voiceover_applications(
cls,
author_id: str,
status: Optional[str] = None
) -> List['GeneralVoiceoverApplicationModel']:
"""Returns a list of voiceover application submitted by the given user.
Args:
author_id: str. The id of the user created the voiceover
application.
status: str|None. The status of the voiceover application.
If the status is None, the query will fetch all the
voiceover applications.
Returns:
list(GeneralVoiceoverApplicationModel). The list of voiceover
applications submitted by the given user.
"""
if status in STATUS_CHOICES:
voiceover_application_query = cls.query(
datastore_services.all_of(cls.author_id == author_id,
cls.status == status))
else:
voiceover_application_query = cls.query(cls.author_id == author_id)
return cast(List[GeneralVoiceoverApplicationModel],
voiceover_application_query.fetch())
def get_suggestions_waiting_too_long_for_review(
cls) -> Sequence[GeneralSuggestionModel]:
"""Returns a list of suggestions that have been waiting for a review
longer than SUGGESTION_REVIEW_WAIT_TIME_THRESHOLD_IN_DAYS days on the
Contributor Dashboard. MAX_NUMBER_OF_SUGGESTIONS_TO_EMAIL_ADMIN
suggestions are returned, sorted in descending order by their review
wait time.
Returns:
list(GeneralSuggestionModel). A list of suggestions, sorted in
descending order by their review wait time.
Raises:
Exception. If there are no suggestion types offered on the
Contributor Dashboard.
"""
if not feconf.CONTRIBUTOR_DASHBOARD_SUGGESTION_TYPES:
raise Exception(
'Expected the suggestion types offered on the Contributor '
'Dashboard to be nonempty.')
threshold_time = (datetime.datetime.utcnow() - datetime.timedelta(
days=SUGGESTION_REVIEW_WAIT_TIME_THRESHOLD_IN_DAYS))
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW,
cls.last_updated < threshold_time,
cls.suggestion_type.IN(
feconf.CONTRIBUTOR_DASHBOARD_SUGGESTION_TYPES))).order(
cls.last_updated).fetch(
MAX_NUMBER_OF_SUGGESTIONS_TO_EMAIL_ADMIN)
def query_new_and_pending_training_jobs(
cls, offset: int
) -> Tuple[Sequence['ClassifierTrainingJobModel'], int]:
"""Gets the next 10 jobs which are either in status "new" or "pending",
ordered by their next_scheduled_check_time attribute.
Args:
offset: int. Number of query results to skip.
Returns:
tuple(list(ClassifierTrainingJobModel), int).
A tuple containing the list of the ClassifierTrainingJobModels
with status new or pending and the offset value.
"""
query = (
cls.get_all()
.filter(
datastore_services.all_of(
cls.status.IN([
feconf.TRAINING_JOB_STATUS_NEW,
feconf.TRAINING_JOB_STATUS_PENDING
]),
cls.next_scheduled_check_time <= datetime.datetime.utcnow()
)
)
.order(cls.next_scheduled_check_time)
)
classifier_job_models: Sequence[ClassifierTrainingJobModel] = (
query.fetch(
NEW_AND_PENDING_TRAINING_JOBS_FETCH_LIMIT, offset=offset))
offset = offset + len(classifier_job_models)
return classifier_job_models, offset
def get_in_review_suggestions_in_score_categories(
cls, score_categories: List[str],
user_id: str) -> Sequence[GeneralSuggestionModel]:
"""Gets all suggestions which are in review in the given
score_categories.
Args:
score_categories: list(str). List of score categories to query for.
user_id: str. The id of the user trying to make this query.
As a user cannot review their own suggestions, suggestions
authored by the user will be excluded.
Returns:
list(SuggestionModel). A list of suggestions that are in the given
score categories, which are in review, but not created by the
given user.
Raises:
Exception. Given list of score categories is empty.
"""
if len(score_categories) == 0:
raise Exception('Received empty list of score categories')
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW,
cls.score_category.IN(score_categories),
cls.author_id != user_id)).fetch(
feconf.DEFAULT_SUGGESTION_QUERY_LIMIT)
def get_translation_suggestion_ids_with_exp_ids(
cls, exp_ids: List[str]) -> List[str]:
"""Gets the ids of translation suggestions corresponding to
explorations with the given exploration ids.
Args:
exp_ids: list(str). List of exploration ids to query for.
Returns:
list(str). A list of translation suggestion ids that
correspond to the given exploration ids. Note: it is not
guaranteed that the suggestion ids returned are ordered by the
exploration ids in exp_ids.
"""
query = cls.get_all().filter(
datastore_services.all_of(
cls.suggestion_type ==
feconf.SUGGESTION_TYPE_TRANSLATE_CONTENT,
cls.target_id.IN(exp_ids)))
suggestion_models: List[GeneralSuggestionModel] = []
offset, more = (0, True)
while more:
results: Sequence[GeneralSuggestionModel] = (query.fetch(
feconf.DEFAULT_SUGGESTION_QUERY_LIMIT, offset=offset))
if len(results):
offset = offset + len(results)
suggestion_models.extend(results)
else:
more = False
return [suggestion_model.id for suggestion_model in suggestion_models]
def test_query_with_range_like_filter(self) -> None:
query = datastore_services.Query(filters=datastore_services.all_of(
BarModel.prop >= 3, BarModel.prop < 6))
beam_query = job_utils.get_beam_query_from_ndb_query(query)
self.assertEqual(beam_query.filters,
(('prop', '>=', 3), ('prop', '<', 6)))
def get_by_url_fragment(cls, url_fragment: str) -> Optional[BlogPostModel]:
"""Gets BlogPostModel by url_fragment. Returns None if the blog post
with the given url_fragment doesn't exist.
Args:
url_fragment: str. The url fragment of the blog post.
Returns:
BlogPostModel | None. The blog post model of the Blog or None if not
found.
"""
return BlogPostModel.query(
datastore_services.all_of(cls.url_fragment == url_fragment,
cls.deleted == False) # pylint: disable=singleton-comparison
).get()
def get_reviewable_voiceover_applications(
cls, user_id: str) -> Sequence[GeneralVoiceoverApplicationModel]:
"""Returns a list of voiceover application which a given user can
review.
Args:
user_id: str. The id of the user trying to make this query.
As a user cannot review their own voiceover application, so the
voiceover application created by the user will be excluded.
Returns:
list(GeneralVoiceoverApplicationModel). The list of voiceover
applications which the given user can review.
"""
return cls.query(
datastore_services.all_of(cls.author_id != user_id,
cls.status == STATUS_IN_REVIEW)).fetch()
def get_question_suggestions_waiting_longest_for_review(
cls) -> Sequence[GeneralSuggestionModel]:
"""Returns MAX_QUESTION_SUGGESTIONS_TO_FETCH_FOR_REVIEWER_EMAILS number
of question suggestions, sorted in descending order by review wait
time.
Returns:
list(GeneralSuggestionModel). A list of question suggestions,
sorted in descending order based on how long the suggestions have
been waiting for review.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW, cls.suggestion_type ==
feconf.SUGGESTION_TYPE_ADD_QUESTION)).order(
cls.last_updated).fetch(
MAX_QUESTION_SUGGESTIONS_TO_FETCH_FOR_REVIEWER_EMAILS)
def get_user_created_suggestions_of_suggestion_type(
cls, suggestion_type: str,
user_id: str) -> Sequence[GeneralSuggestionModel]:
"""Gets all suggestions of suggestion_type which the user has created.
Args:
suggestion_type: str. The type of suggestion to query for.
user_id: str. The id of the user trying to make this query.
Returns:
list(SuggestionModel). A list of suggestions that are of the given
type, which the given user has created.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.suggestion_type == suggestion_type,
cls.author_id == user_id)).order(-cls.created_on).fetch(
feconf.DEFAULT_SUGGESTION_QUERY_LIMIT)
def get_in_review_question_suggestions(
cls, user_id: str) -> Sequence['GeneralSuggestionModel']:
"""Gets all question suggestions which are in review.
Args:
user_id: str. The id of the user trying to make this query.
As a user cannot review their own suggestions, suggestions
authored by the user will be excluded.
Returns:
list(SuggestionModel). A list of suggestions that are of the given
type, which are in review, but not created by the given user.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW,
cls.suggestion_type == feconf.SUGGESTION_TYPE_ADD_QUESTION,
cls.author_id != user_id)).fetch(feconf.DEFAULT_QUERY_LIMIT)
def get_voiceover_applications(
cls, target_type: str, target_id: str,
language_code: str) -> Sequence[GeneralVoiceoverApplicationModel]:
"""Returns a list of voiceover applications submitted for a give entity
in a given language.
Args:
target_type: str. The type of entity.
target_id: str. The ID of the targeted entity.
language_code: str. The code of the language in which the voiceover
application is submitted.
Returns:
list(GeneralVoiceoverApplicationModel). The list of voiceover
application which is submitted to a give entity in a given language.
"""
return cls.query(
datastore_services.all_of(
cls.target_type == target_type, cls.target_id == target_id,
cls.language_code == language_code)).fetch()
def get_translation_suggestions_waiting_longest_for_review(
cls, language_code: str) -> Sequence[GeneralSuggestionModel]:
"""Returns MAX_TRANSLATION_SUGGESTIONS_TO_FETCH_FOR_REVIEWER_EMAILS
number of translation suggestions in the specified language code,
sorted in descending order by review wait time.
Args:
language_code: str. The ISO 639-1 language code of the translation
suggestions.
Returns:
list(GeneralSuggestionModel). A list of translation suggestions,
sorted in descending order based on how long the suggestions have
been waiting for review.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW, cls.suggestion_type ==
feconf.SUGGESTION_TYPE_TRANSLATE_CONTENT, cls.language_code ==
language_code)).order(cls.last_updated).fetch(
MAX_TRANSLATION_SUGGESTIONS_TO_FETCH_FOR_REVIEWER_EMAILS)
def get_in_review_translation_suggestions(
cls, user_id: str,
language_codes: List[str]) -> Sequence[GeneralSuggestionModel]:
"""Gets all translation suggestions which are in review.
Args:
user_id: str. The id of the user trying to make this query.
As a user cannot review their own suggestions, suggestions
authored by the user will be excluded.
language_codes: list(str). The list of language codes.
Returns:
list(SuggestionModel). A list of suggestions that are of the given
type, which are in review, but not created by the given user.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW, cls.suggestion_type ==
feconf.SUGGESTION_TYPE_TRANSLATE_CONTENT,
cls.author_id != user_id,
cls.language_code.IN(language_codes))).fetch(
feconf.DEFAULT_SUGGESTION_QUERY_LIMIT)
def get_translation_suggestions_in_review_with_exp_id(
cls, exp_id: str,
language_code: str) -> Sequence['GeneralSuggestionModel']:
"""Returns translation suggestions which are in review with target_id
== exp_id.
Args:
exp_id: str. Exploration ID matching the target ID of the
translation suggestions.
language_code: str. Language code.
Returns:
list(SuggestionModel). A list of translation suggestions in review
with target_id of exp_id. The number of returned results is capped
by feconf.DEFAULT_QUERY_LIMIT.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW,
cls.language_code == language_code, cls.suggestion_type ==
feconf.SUGGESTION_TYPE_TRANSLATE_CONTENT,
cls.target_id == exp_id)).fetch(feconf.DEFAULT_QUERY_LIMIT)
def get_in_review_translation_suggestions_by_exp_ids(
cls, exp_ids: List[str],
language_code: str) -> Sequence[GeneralSuggestionModel]:
"""Gets all in-review translation suggestions matching the supplied
exp_ids and language_code.
Args:
exp_ids: list(str). Exploration IDs matching the target ID of the
translation suggestions.
language_code: str. The ISO 639-1 language code of the translation
suggestions.
Returns:
list(SuggestionModel). A list of suggestions matching the supplied
exp_ids and language_code.
"""
return cls.get_all().filter(
datastore_services.all_of(
cls.status == STATUS_IN_REVIEW, cls.suggestion_type ==
feconf.SUGGESTION_TYPE_TRANSLATE_CONTENT,
cls.target_id.IN(exp_ids),
cls.language_code == language_code)).fetch(
feconf.DEFAULT_SUGGESTION_QUERY_LIMIT)
