def to_dict(self) -> Dict[str, Union[bool, float, str, List[str]]]:
"""Returns a dict representation of the BeamJobRun.
Returns:
dict(str: *). The dict has the following structure:
job_id: str. The ID of the job execution.
job_name: str. The name of the job class that implements the
job's logic.
job_state: str. The state of the job at the time the model was
last updated.
job_started_on_msecs: float. The number of milliseconds since
UTC epoch at which the job was created.
job_updated_on_msecs: float. The number of milliseconds since
UTC epoch at which the job's state was last updated.
job_is_synchronous: bool. Whether the job has been run
synchronously.
"""
return {
'job_id':
self.job_id,
'job_name':
self.job_name,
'job_state':
self.job_state,
'job_started_on_msecs':
(utils.get_time_in_millisecs(self.job_started_on)),
'job_updated_on_msecs':
(utils.get_time_in_millisecs(self.job_updated_on)),
'job_is_synchronous':
self.job_is_synchronous,
}
def get(self, thread_id):
"""Handles GET requests."""
messages = feedback_services.get_messages(thread_id)
author_ids = [m.author_id for m in messages]
authors_settings = user_services.get_users_settings(author_ids)
message_ids = [m.message_id for m in messages]
feedback_services.update_messages_read_by_the_user(
self.user_id, thread_id, message_ids)
message_summary_list = []
suggestion = suggestion_services.get_suggestion_by_id(thread_id)
suggestion_thread = feedback_services.get_thread(thread_id)
exploration_id = feedback_services.get_exp_id_from_thread_id(thread_id)
if suggestion:
exploration = exp_fetchers.get_exploration_by_id(exploration_id)
current_content_html = (
exploration.states[suggestion.change.state_name].content.html)
suggestion_summary = {
'suggestion_html':
suggestion.change.new_value['html'],
'current_content_html':
current_content_html,
'description':
suggestion_thread.subject,
'author_username':
authors_settings[0].username,
'author_picture_data_url':
(authors_settings[0].profile_picture_data_url),
'created_on_msecs':
utils.get_time_in_millisecs(messages[0].created_on)
}
message_summary_list.append(suggestion_summary)
messages.pop(0)
authors_settings.pop(0)
for m, author_settings in zip(messages, authors_settings):
if author_settings is None:
author_username = None
author_picture_data_url = None
else:
author_username = author_settings.username
author_picture_data_url = (
author_settings.profile_picture_data_url)
message_summary = {
'message_id': m.message_id,
'text': m.text,
'updated_status': m.updated_status,
'author_username': author_username,
'author_picture_data_url': author_picture_data_url,
'created_on_msecs': utils.get_time_in_millisecs(m.created_on)
}
message_summary_list.append(message_summary)
self.render_json({'message_summary_list': message_summary_list})
def test_to_dict(self) -> None:
run = beam_job_domain.BeamJobRun('123', 'FooJob', 'RUNNING', self.NOW,
self.NOW, True)
self.assertEqual(
run.to_dict(), {
'job_id': '123',
'job_name': 'FooJob',
'job_state': 'RUNNING',
'job_started_on_msecs': utils.get_time_in_millisecs(self.NOW),
'job_updated_on_msecs': utils.get_time_in_millisecs(self.NOW),
'job_is_synchronous': True,
})
def export_data(cls, user_id):
"""Exports the data from BlogPostModel into dict format for Takeout.
Args:
user_id: str. The ID of the user whose data should be exported.
Returns:
dict. Dictionary of the data from BlogPostModel.
"""
user_data = {}
blog_post_models = cls.get_all().filter(
cls.author_id == user_id).fetch()
for blog_post_model in blog_post_models:
user_data[blog_post_model.id] = {
'title':
blog_post_model.title,
'content':
blog_post_model.content,
'url_fragment':
blog_post_model.url_fragment,
'tags':
blog_post_model.tags,
'thumbnail_filename':
blog_post_model.thumbnail_filename,
'published_on':
utils.get_time_in_millisecs(blog_post_model.published_on),
}
return user_data
def export_data(
cls,
user_id: str
) -> Dict[str, Dict[str, Union[str, bool, None]]]:
"""Exports the data from GeneralFeedbackThreadModel
into dict format for Takeout.
Args:
user_id: str. The ID of the user whose data should be exported.
Returns:
dict. Dictionary of the data from GeneralFeedbackThreadModel.
"""
user_data = {}
feedback_models: Sequence[GeneralFeedbackThreadModel] = (
cls.get_all().filter(cls.original_author_id == user_id).fetch())
for feedback_model in feedback_models:
user_data[feedback_model.id] = {
'entity_type': feedback_model.entity_type,
'entity_id': feedback_model.entity_id,
'status': feedback_model.status,
'subject': feedback_model.subject,
'has_suggestion': feedback_model.has_suggestion,
'summary': feedback_model.summary,
'message_count': feedback_model.message_count,
'last_updated_msec': utils.get_time_in_millisecs(
feedback_model.last_updated)
}
return user_data
def test_to_dict_with_non_existing_resolver_id(self) -> None:
task_entry = improvements_domain.TaskEntry(
constants.TASK_ENTITY_TYPE_EXPLORATION, self.exp.id, 1,
constants.TASK_TYPE_HIGH_BOUNCE_RATE,
constants.TASK_TARGET_TYPE_STATE, feconf.DEFAULT_INIT_STATE_NAME,
'issue description', constants.TASK_STATUS_RESOLVED, None,
self.MOCK_DATE)
# In case of non-existing resolver_id,
# get_task_dict_with_username_and_profile_picture should return
# with no changes to the TaskEntry dict.
task_entry_dict = (
improvements.
get_task_dict_with_username_and_profile_picture( # type: ignore[no-untyped-call]
task_entry))
self.assertEqual(
task_entry_dict, {
'entity_type': 'exploration',
'entity_id': self.exp.id,
'entity_version': 1,
'task_type': 'high_bounce_rate',
'target_type': 'state',
'target_id': 'Introduction',
'issue_description': 'issue description',
'status': 'resolved',
'resolver_username': None,
'resolver_profile_picture_data_url': None,
'resolved_on_msecs': utils.get_time_in_millisecs(
self.MOCK_DATE),
})
def test_to_dict(self) -> None:
fake_date = datetime.datetime(2016, 4, 10, 0, 0, 0, 0)
expected_thread_dict: feedback_domain.FeedbackThreadDict = {
'thread_id': self.THREAD_ID,
'status': u'open',
'state_name': u'a_state_name',
'summary': 'test summary',
'original_author_id': self.viewer_id,
'message_count': 1,
'subject': u'a subject',
'last_updated_msecs': utils.get_time_in_millisecs(fake_date),
'last_nonempty_message_text': 'last message',
'last_nonempty_message_author_id': self.viewer_id,
}
observed_thread = feedback_domain.FeedbackThread(
self.THREAD_ID, feconf.ENTITY_TYPE_EXPLORATION, self.EXP_ID,
expected_thread_dict['state_name'], self.viewer_id,
expected_thread_dict['status'], expected_thread_dict['subject'],
expected_thread_dict['summary'], False, 1, fake_date, fake_date,
'last message', self.viewer_id)
# Using type ignore[arg-type] here because assertDictEqual method
# expects both arguments to be of type Dict[Any, Any].
self.assertDictEqual(
expected_thread_dict,
observed_thread.to_dict()) # type: ignore[arg-type]
def generate_id(cls, ticket_name: str) -> str:
"""Generates key for the instance of AppFeedbackReportTicketModel
class in the required format with the arguments provided.
Args:
ticket_name: str. The name assigned to the ticket on creation.
Returns:
str. The generated ID for this entity using the current datetime in
milliseconds (as the entity's creation timestamp), a SHA1 hash of
the ticket_name, and a random string, of the form
'[creation_datetime_msec]:[hash(ticket_name)]:[random hash]'.
"""
current_datetime_in_msec = utils.get_time_in_millisecs(
datetime.datetime.utcnow())
for _ in python_utils.RANGE(base_models.MAX_RETRIES):
name_hash = utils.convert_to_hash(ticket_name,
base_models.ID_LENGTH)
random_hash = utils.convert_to_hash(
python_utils.UNICODE(
utils.get_random_int(base_models.RAND_RANGE)),
base_models.ID_LENGTH)
new_id = '%s.%s.%s' % (int(current_datetime_in_msec), name_hash,
random_hash)
if not cls.get_by_id(new_id):
return new_id
raise Exception(
'The id generator for AppFeedbackReportTicketModel is producing too'
'many collisions.')
def test_get_time_in_millisecs_with_complicated_time(self) -> None:
dt = datetime.datetime(2020, 6, 15, 5, 18, 23, microsecond=123456)
msecs = utils.get_time_in_millisecs(dt)
self.assertEqual(
dt,
datetime.datetime.fromtimestamp(python_utils.divide(
msecs, 1000.0))) # type: ignore[no-untyped-call]
def to_dict(self):
"""Returns a dict representation of this FeedbackThread object.
Returns:
dict. A dict representation of the FeedbackThread object.
"""
return {
'last_updated_msecs':
(utils.get_time_in_millisecs(self.last_updated)),
'original_author_username': (user_services.get_username(
self.original_author_id) if self.original_author_id else None),
'state_name':
self.state_name,
'status':
self.status,
'subject':
self.subject,
'summary':
self.summary,
'thread_id':
self.id,
'message_count':
self.message_count,
'last_nonempty_message_text':
self.last_nonempty_message_text,
'last_nonempty_message_author':
(user_services.get_username(self.last_nonempty_message_author_id)
if self.last_nonempty_message_author_id else None),
}
def export_data(cls, user_id: str) -> Dict[str, Dict[str, str]]:
"""Exports the data from AppFeedbackReportModel into dict format for
Takeout.
Args:
user_id: str. The ID of the user whose data should be exported;
this would be the ID of the user who has scrubbed the report.
Returns:
dict. Dictionary of the data from AppFeedbackReportModel.
"""
user_data = {}
report_models: Sequence[AppFeedbackReportModel] = (
cls.get_all().filter(cls.scrubbed_by == user_id).fetch())
for report_model in report_models:
submitted_on_msec = utils.get_time_in_millisecs(
report_model.submitted_on)
user_data[report_model.id] = {
'scrubbed_by': report_model.scrubbed_by,
'platform': report_model.platform,
'ticket_id': report_model.ticket_id,
'submitted_on': utils.get_human_readable_time_string(
submitted_on_msec),
'local_timezone_offset_hrs': (
report_model.local_timezone_offset_hrs),
'report_type': report_model.report_type,
'category': report_model.category,
'platform_version': report_model.platform_version
}
return user_data
def test_to_dict_has_expected_value(self):
task_entry = improvements_domain.TaskEntry(
improvements_models.TASK_ENTITY_TYPE_EXPLORATION, self.exp_id, 1,
improvements_models.TASK_TYPE_HIGH_BOUNCE_RATE,
improvements_models.TASK_TARGET_TYPE_STATE,
feconf.DEFAULT_INIT_STATE_NAME, 'issue description',
improvements_models.TASK_STATUS_RESOLVED, self.owner_id,
self.MOCK_DATE)
self.assertEqual(
task_entry.to_dict(), {
'entity_type':
'exploration',
'entity_id':
self.exp_id,
'entity_version':
1,
'task_type':
'high_bounce_rate',
'target_type':
'state',
'target_id':
'Introduction',
'issue_description':
'issue description',
'status':
'resolved',
'resolver_username':
self.OWNER_USERNAME,
'resolver_profile_picture_data_url':
(user_services.DEFAULT_IDENTICON_DATA_URL),
'resolved_on_msecs':
utils.get_time_in_millisecs(self.MOCK_DATE),
})
def test_export_data_nontrivial(self) -> None:
user_data = (feedback_models.GeneralFeedbackThreadModel.export_data(
self.USER_ID))
feedback_id = '%s.%s.%s' % (self.ENTITY_TYPE, self.ENTITY_ID, 'random')
test_data = {
feedback_id: {
'entity_type':
self.ENTITY_TYPE,
'entity_id':
self.ENTITY_ID,
'status':
self.STATUS,
'subject':
self.SUBJECT,
'has_suggestion':
self.HAS_SUGGESTION,
'summary':
self.SUMMARY,
'message_count':
self.MESSAGE_COUNT,
'last_updated_msec':
utils.get_time_in_millisecs(
self.feedback_thread_model.last_updated)
}
}
self.assertEqual(user_data, test_data)
def test_get_suggestions_after_updating_suggestion_summary(self):
self.login(self.EDITOR_EMAIL)
response_dict = self.get_json(
'%s/%s' %
(feconf.FEEDBACK_THREADLIST_URL_PREFIX, self.EXP_ID_1)
)
thread_id = response_dict['feedback_thread_dicts'][0]['thread_id']
thread_url = '%s/%s' % (
feconf.LEARNER_DASHBOARD_FEEDBACK_THREAD_DATA_URL, thread_id)
response_dict = self.get_json(thread_url)
messages_summary = response_dict['message_summary_list'][0]
self.assertEqual(
messages_summary['author_username'], self.EDITOR_USERNAME)
self.assertTrue(test_utils.check_image_png_or_webp(
messages_summary['author_picture_data_url']))
self.assertFalse(messages_summary.get('suggestion_html'))
self.assertFalse(messages_summary.get('current_content_html'))
self.assertFalse(messages_summary.get('description'))
new_content = state_domain.SubtitledHtml(
'content', '<p>new content html</p>').to_dict()
change_cmd = {
'cmd': exp_domain.CMD_EDIT_STATE_PROPERTY,
'property_name': exp_domain.STATE_PROPERTY_CONTENT,
'state_name': 'Welcome!',
'new_value': new_content
}
suggestion_models.GeneralSuggestionModel.create(
feconf.SUGGESTION_TYPE_EDIT_STATE_CONTENT,
feconf.ENTITY_TYPE_EXPLORATION, self.EXP_ID_1, 1,
suggestion_models.STATUS_IN_REVIEW, self.editor_id, None,
change_cmd, 'score category', thread_id, None)
suggestion_thread = feedback_services.get_thread(thread_id)
suggestion = suggestion_services.get_suggestion_by_id(thread_id)
exploration = exp_fetchers.get_exploration_by_id(self.EXP_ID_1)
current_content_html = (
exploration.states[
suggestion.change.state_name].content.html)
response_dict = self.get_json(thread_url)
messages_summary = response_dict['message_summary_list'][0]
first_suggestion = feedback_services.get_messages(thread_id)[0]
self.assertEqual(
messages_summary['author_username'], self.EDITOR_USERNAME)
self.assertTrue(test_utils.check_image_png_or_webp(
messages_summary['author_picture_data_url']))
self.assertEqual(
utils.get_time_in_millisecs(first_suggestion.created_on),
messages_summary['created_on_msecs'])
self.assertEqual(
messages_summary['suggestion_html'], '<p>new content html</p>')
self.assertEqual(
messages_summary['current_content_html'], current_content_html)
self.assertEqual(
messages_summary['description'], suggestion_thread.subject)
self.logout()
def to_dict(self) -> FeedbackMessageDict:
"""Returns a dict representation of this FeedbackMessage object.
Returns:
dict. Dict representation of the FeedbackMessage object.
"""
return {
'author_username': (
user_services.get_username(
self.author_id) # type: ignore[no-untyped-call]
if self.author_id else None),
'created_on_msecs':
utils.get_time_in_millisecs(self.created_on),
'entity_type':
self.entity_type,
'entity_id':
self.entity_id,
'message_id':
self.message_id,
'text':
self.text,
'updated_status':
self.updated_status,
'updated_subject':
self.updated_subject
}
def test_get_time_in_millisecs(self) -> None:
dt = datetime.datetime(2020, 6, 15)
msecs = utils.get_time_in_millisecs(dt)
self.assertEqual(
dt,
datetime.datetime.fromtimestamp(python_utils.divide(
msecs, 1000.0))) # type: ignore[no-untyped-call]
def generate_id(cls, platform: str,
submitted_on_datetime: datetime.datetime) -> str:
"""Generates key for the instance of AppFeedbackReportModel class in the
required format with the arguments provided.
Args:
platform: str. The platform the user is the report from.
submitted_on_datetime: datetime.datetime. The datetime that the
report was submitted on in UTC.
Returns:
str. The generated ID for this entity using platform,
submitted_on_sec, and a random string, of the form
'[platform].[submitted_on_msec].[random hash]'.
"""
submitted_datetime_in_msec = utils.get_time_in_millisecs(
submitted_on_datetime)
for _ in python_utils.RANGE(base_models.MAX_RETRIES):
random_hash = utils.convert_to_hash(
python_utils.UNICODE(
utils.get_random_int(base_models.RAND_RANGE)),
base_models.ID_LENGTH)
new_id = '%s.%s.%s' % (platform, int(submitted_datetime_in_msec),
random_hash)
if not cls.get_by_id(new_id):
return new_id
raise Exception(
'The id generator for AppFeedbackReportModel is producing too '
'many collisions.')
def setUp(self):
super(AugmentedSkillSummaryTests, self).setUp()
current_time = datetime.datetime.utcnow()
self.time_in_millisecs = utils.get_time_in_millisecs(current_time)
self.augmented_skill_summary = skill_domain.AugmentedSkillSummary(
'skill_id', 'description', 'en', 1, 1, 1, ['topic1'], ['math'],
current_time, current_time)
def _get_displayable_collection_summary_dicts(collection_summaries):
"""Gets a summary of collections in human readable form.
Args:
collection_summaries: list(CollectionSummary). List of collection
summary domain object.
Returns:
list(dict). A list of exploration summary dicts in human readable form.
Example:
[ {
'category': u'A category',
'community_owned': False,
'id': 'eid2',
'language_code': 'en',
'num_views': 0,
'objective': u'An objective',
'status': 'public',
'tags': [],
'thumbnail_bg_color': '#a33f40',
'thumbnail_icon_url': self.get_static_asset_url(
'/images/subjects/Lightbulb.svg'),
'title': u'Exploration 2 Albert title',
}, ]
"""
displayable_collection_summaries = []
for collection_summary in collection_summaries:
if collection_summary and collection_summary.status != (
rights_domain.ACTIVITY_STATUS_PRIVATE):
displayable_collection_summaries.append({
'id':
collection_summary.id,
'title':
collection_summary.title,
'category':
collection_summary.category,
'activity_type':
constants.ACTIVITY_TYPE_COLLECTION,
'objective':
collection_summary.objective,
'language_code':
collection_summary.language_code,
'tags':
collection_summary.tags,
'node_count':
collection_summary.node_count,
'last_updated_msec':
utils.get_time_in_millisecs(
collection_summary.collection_model_last_updated),
'thumbnail_icon_url':
(utils.get_thumbnail_icon_url_for_category(
collection_summary.category)),
'thumbnail_bg_color':
utils.get_hex_color_for_category(collection_summary.category)
})
return displayable_collection_summaries
def to_dict(self):
"""Returns a dict-representation of the task.
Returns:
dict. Contains the following keys:
entity_type: str. The type of entity the task entry refers to.
For example, "exploration".
entity_id: str. The ID of the entity the task entry refers to.
For example, an exploration ID.
entity_version: int. The version of the entity the task entry
refers to. For example, an exploration's version.
task_type: str. The type of task the task entry tracks.
target_type: str. The type of sub-entity the task entry refers
to. For example, "state" when entity type is "exploration".
target_id: str. The ID of the sub-entity the task entry refers
to. For example, the state name of an exploration.
issue_description: str. The sentence generated by Oppia to
describe why the task was created.
status: str. Tracks the state/progress of the task entry.
resolver_username: str. Username of the user who resolved the
task when status is resolved. Otherwise None.
resolver_profile_picture_data_url: str. Profile picture URL of
the user who resolved the task when status is resolved.
Otherwise None.
resolved_on_msecs: float. Time in milliseconds since epoch at
which the task was resolved when status is resolved.
Otherwise None.
"""
resolver_settings = (self.resolver_id
and user_services.get_user_settings(
self.resolver_id, strict=True))
return {
'entity_type':
self.entity_type,
'entity_id':
self.entity_id,
'entity_version':
self.entity_version,
'task_type':
self.task_type,
'target_type':
self.target_type,
'target_id':
self.target_id,
'issue_description':
self.issue_description,
'status':
self.status,
'resolver_username': (resolver_settings
and resolver_settings.username),
'resolver_profile_picture_data_url':
(resolver_settings and resolver_settings.profile_picture_data_url),
'resolved_on_msecs':
(self.resolved_on
and utils.get_time_in_millisecs(self.resolved_on)),
}
def test_to_dict(self):
"""Test to verify to_dict method of the Question Summary
object.
"""
expected_object_dict = {
'id':
'question_1',
'question_content':
'<p>question content</p>',
'interaction_id':
'TextInput',
'last_updated_msec':
utils.get_time_in_millisecs(self.fake_date_updated),
'created_on_msec':
utils.get_time_in_millisecs(self.fake_date_created),
'misconception_ids': ['skill1-1', 'skill2-2']
}
self.assertEqual(expected_object_dict, self.observed_object.to_dict())
def to_dict(self) -> FeedbackMessageDict:
"""Returns a dict representation of this FeedbackMessage object.
Returns:
dict. Dict representation of the FeedbackMessage object.
"""
return {
'author_id': self.author_id,
'created_on_msecs': utils.get_time_in_millisecs(self.created_on),
'entity_type': self.entity_type,
'entity_id': self.entity_id,
'message_id': self.message_id,
'text': self.text,
'updated_status': self.updated_status,
'updated_subject': self.updated_subject
}
def test_to_dict(self):
fake_date = datetime.datetime(2016, 4, 10, 0, 0, 0, 0)
expected_message_dict = {
'author_username': self.OWNER_USERNAME,
'created_on_msecs': utils.get_time_in_millisecs(fake_date),
'entity_type': feconf.ENTITY_TYPE_EXPLORATION,
'entity_id': self.EXP_ID,
'message_id': self.MESSAGE_ID,
'text': 'a message text',
'updated_status': 'open',
'updated_subject': 'an updated subject'
}
observed_message = feedback_domain.FeedbackMessage(
self.FULL_MESSAGE_ID, self.THREAD_ID, self.MESSAGE_ID,
self.owner_id, expected_message_dict['updated_status'],
expected_message_dict['updated_subject'],
expected_message_dict['text'], fake_date, fake_date, False)
self.assertDictEqual(expected_message_dict, observed_message.to_dict())
def setUp(self):
super(SkillSummaryTests, self).setUp()
current_time = datetime.datetime.utcnow()
time_in_millisecs = utils.get_time_in_millisecs(current_time)
self.skill_summary_dict = {
'id': 'skill_id',
'description': 'description',
'language_code': 'en',
'version': 1,
'misconception_count': 1,
'worked_examples_count': 1,
'skill_model_created_on': time_in_millisecs,
'skill_model_last_updated': time_in_millisecs
}
self.skill_summary = skill_domain.SkillSummary('skill_id',
'description', 'en', 1,
1, 1, current_time,
current_time)
def test_export_data_nontrivial(self):
user_data = blog_models.BlogPostModel.export_data(self.USER_ID)
blog_post_id = 'blog_one'
test_data = {
blog_post_id: {
'title':
self.TITLE,
'content':
self.CONTENT,
'url_fragment':
'sample-url-fragment',
'tags':
self.TAGS,
'thumbnail_filename':
self.THUMBNAIL,
'published_on':
utils.get_time_in_millisecs(self.blog_post_model.published_on)
}
}
self.assertEqual(user_data, test_data)
def test_to_dict(self) -> None:
fake_date = datetime.datetime(2016, 4, 10, 0, 0, 0, 0)
expected_message_dict: feedback_domain.FeedbackMessageDict = {
'author_username': self.OWNER_USERNAME,
'created_on_msecs': utils.get_time_in_millisecs(fake_date),
'entity_type': feconf.ENTITY_TYPE_EXPLORATION,
'entity_id': self.EXP_ID,
'message_id': self.MESSAGE_ID,
'text': 'a message text',
'updated_status': 'open',
'updated_subject': 'an updated subject'
}
observed_message = feedback_domain.FeedbackMessage(
self.FULL_MESSAGE_ID, self.THREAD_ID, self.MESSAGE_ID,
self.owner_id, expected_message_dict['updated_status'],
expected_message_dict['updated_subject'],
expected_message_dict['text'], fake_date, fake_date, False)
# Using type ignore[arg-type] here because assertDictEqual method
# expects both arguments to be of type Dict[Any, Any].
self.assertDictEqual(
expected_message_dict, observed_message.to_dict()) # type: ignore[arg-type]
def to_dict(self):
"""Returns dict representation of the FeedbackThreadSummary object.
Returns:
dict. Dict representation of the FeedbackThreadSummary object.
"""
return {
'status': self.status,
'original_author_id': self.original_author_id,
'last_updated_msecs':
(utils.get_time_in_millisecs(self.last_updated)),
'last_message_text': self.last_message_text,
'total_message_count': self.total_message_count,
'last_message_is_read': self.last_message_is_read,
'second_last_message_is_read': self.second_last_message_is_read,
'author_last_message': self.author_last_message,
'author_second_last_message': self.author_second_last_message,
'exploration_title': self.exploration_title,
'exploration_id': self.exploration_id,
'thread_id': self.thread_id,
}
def test_to_dict(self):
fake_date = datetime.datetime(2016, 4, 10, 0, 0, 0, 0)
expected_thread_dict = {
'thread_id': self.THREAD_ID,
'status': u'open',
'state_name': u'a_state_name',
'summary': None,
'original_author_username': self.VIEWER_USERNAME,
'message_count': 1,
'subject': u'a subject',
'last_updated_msecs': utils.get_time_in_millisecs(fake_date),
'last_nonempty_message_text': 'last message',
'last_nonempty_message_author': self.VIEWER_USERNAME,
}
observed_thread = feedback_domain.FeedbackThread(
self.THREAD_ID, feconf.ENTITY_TYPE_EXPLORATION, self.EXP_ID,
expected_thread_dict['state_name'], self.viewer_id,
expected_thread_dict['status'], expected_thread_dict['subject'],
expected_thread_dict['summary'], False, 1, fake_date, fake_date,
'last message', self.viewer_id)
self.assertDictEqual(expected_thread_dict, observed_thread.to_dict())
def test_get_all_unscrubbed_expiring_report_models(self) -> None:
expired_timestamp = datetime.datetime.utcnow() - (
feconf.APP_FEEDBACK_REPORT_MAXIMUM_LIFESPAN +
datetime.timedelta(days=10))
expired_model = app_feedback_report_models.AppFeedbackReportModel(
id='%s.%s.%s' % (
self.PLATFORM_ANDROID,
int(utils.get_time_in_millisecs(expired_timestamp)),
'randomInteger123'),
platform=self.PLATFORM_ANDROID,
scrubbed_by=None,
ticket_id='%s.%s.%s' % (
'random_hash',
int(self.TICKET_CREATION_TIMESTAMP_MSEC),
'16CharString1234'),
submitted_on=expired_timestamp,
local_timezone_offset_hrs=0,
report_type=self.REPORT_TYPE_SUGGESTION,
category=self.CATEGORY_OTHER,
platform_version=self.PLATFORM_VERSION,
android_device_country_locale_code=(
self.DEVICE_COUNTRY_LOCALE_CODE_INDIA),
android_device_model=self.ANDROID_DEVICE_MODEL,
android_sdk_version=self.ANDROID_SDK_VERSION,
entry_point=self.ENTRY_POINT_NAVIGATION_DRAWER,
text_language_code=self.TEXT_LANGUAGE_CODE_ENGLISH,
audio_language_code=self.AUDIO_LANGUAGE_CODE_ENGLISH,
android_report_info=self.ANDROID_REPORT_INFO,
android_report_info_schema_version=(
self.ANDROID_REPORT_INFO_SCHEMA_VERSION)
)
expired_model.created_on = expired_timestamp
expired_model.put()
model_class = app_feedback_report_models.AppFeedbackReportModel
model_entities = model_class.get_all_unscrubbed_expiring_report_models()
self.assertEqual(len(model_entities), 1)
self.assertEqual(model_entities[0].id, expired_model.id)
def test_to_dict_has_expected_value(self) -> None:
# Data url for images/avatar/user_blue_72px.png.
# Generated using utils.convert_png_to_data_url.
task_entry = improvements_domain.TaskEntry(
constants.TASK_ENTITY_TYPE_EXPLORATION, self.exp_id, 1,
constants.TASK_TYPE_HIGH_BOUNCE_RATE,
constants.TASK_TARGET_TYPE_STATE,
feconf.DEFAULT_INIT_STATE_NAME, 'issue description',
constants.TASK_STATUS_RESOLVED, self.owner_id,
self.MOCK_DATE)
self.assertEqual(task_entry.to_dict(), {
'entity_type': 'exploration',
'entity_id': self.exp_id,
'entity_version': 1,
'task_type': 'high_bounce_rate',
'target_type': 'state',
'target_id': 'Introduction',
'issue_description': 'issue description',
'status': 'resolved',
'resolver_username': None,
'resolver_profile_picture_data_url': None,
'resolved_on_msecs': utils.get_time_in_millisecs(self.MOCK_DATE),
})
