def data_issue(data):
m = type("Models", (object,), {})
m.public_issue = f.IssueFactory(project=data.public_project, ref=3)
m.public_history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.public_project,
comment="testing public",
key=make_key_from_model_object(m.public_issue),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_issue1 = f.IssueFactory(project=data.private_project1, ref=7)
m.private_history_entry1 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project1,
comment="testing 1",
key=make_key_from_model_object(m.private_issue1),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_issue2 = f.IssueFactory(project=data.private_project2, ref=11)
m.private_history_entry2 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project2,
comment="testing 2",
key=make_key_from_model_object(m.private_issue2),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
return m
def data_us(data):
m = type("Models", (object, ), {})
m.public_user_story = f.UserStoryFactory(project=data.public_project,
ref=1)
m.public_history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing public",
key=make_key_from_model_object(m.public_user_story),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_user_story1 = f.UserStoryFactory(project=data.private_project1,
ref=5)
m.private_history_entry1 = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing 1",
key=make_key_from_model_object(m.private_user_story1),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_user_story2 = f.UserStoryFactory(project=data.private_project2,
ref=9)
m.private_history_entry2 = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing 2",
key=make_key_from_model_object(m.private_user_story2),
diff={},
user={"pk": data.project_member_with_perms.pk})
return m
def data_issue(data):
m = type("Models", (object,), {})
m.public_issue = f.IssueFactory(project=data.public_project, ref=3)
m.public_history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.public_project,
comment="testing public",
key=make_key_from_model_object(m.public_issue),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_issue1 = f.IssueFactory(project=data.private_project1, ref=7)
m.private_history_entry1 = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.private_project1,
comment="testing 1",
key=make_key_from_model_object(m.private_issue1),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_issue2 = f.IssueFactory(project=data.private_project2, ref=11)
m.private_history_entry2 = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.private_project2,
comment="testing 2",
key=make_key_from_model_object(m.private_issue2),
diff={},
user={"pk": data.project_member_with_perms.pk})
return m
def data_task(data):
m = type("Models", (object,), {})
m.public_task = f.TaskFactory(project=data.public_project, ref=2)
m.public_history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.public_project,
comment="testing public",
key=make_key_from_model_object(m.public_task),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_task1 = f.TaskFactory(project=data.private_project1, ref=6)
m.private_history_entry1 = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.private_project1,
comment="testing 1",
key=make_key_from_model_object(m.private_task1),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_task2 = f.TaskFactory(project=data.private_project2, ref=10)
m.private_history_entry2 = f.HistoryEntryFactory.create(type=HistoryType.change,
project=data.private_project2,
comment="testing 2",
key=make_key_from_model_object(m.private_task2),
diff={},
user={"pk": data.project_member_with_perms.pk})
return m
def data_wiki(data):
m = type("Models", (object,), {})
m.public_wiki = f.WikiPageFactory(project=data.public_project, slug=4)
m.public_history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.public_project,
comment="testing public",
key=make_key_from_model_object(m.public_wiki),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_wiki1 = f.WikiPageFactory(project=data.private_project1, slug=8)
m.private_history_entry1 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project1,
comment="testing 1",
key=make_key_from_model_object(m.private_wiki1),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_wiki2 = f.WikiPageFactory(project=data.private_project2, slug=12)
m.private_history_entry2 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project2,
comment="testing 2",
key=make_key_from_model_object(m.private_wiki2),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
return m
def data_wiki(data):
m = type("Models", (object, ), {})
m.public_wiki = f.WikiPageFactory(project=data.public_project, slug=4)
m.public_history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing public",
key=make_key_from_model_object(m.public_wiki),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_wiki1 = f.WikiPageFactory(project=data.private_project1, slug=8)
m.private_history_entry1 = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing 1",
key=make_key_from_model_object(m.private_wiki1),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_wiki2 = f.WikiPageFactory(project=data.private_project2, slug=12)
m.private_history_entry2 = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing 2",
key=make_key_from_model_object(m.private_wiki2),
diff={},
user={"pk": data.project_member_with_perms.pk})
return m
def data_task(data):
m = type("Models", (object,), {})
m.public_task = f.TaskFactory(project=data.public_project, ref=2)
m.public_history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.public_project,
comment="testing public",
key=make_key_from_model_object(m.public_task),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_task1 = f.TaskFactory(project=data.private_project1, ref=6)
m.private_history_entry1 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project1,
comment="testing 1",
key=make_key_from_model_object(m.private_task1),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
m.private_task2 = f.TaskFactory(project=data.private_project2, ref=10)
m.private_history_entry2 = f.HistoryEntryFactory.create(
type=HistoryType.change,
project=data.private_project2,
comment="testing 2",
key=make_key_from_model_object(m.private_task2),
diff={},
user={"pk": data.project_member_with_perms.pk},
)
return m
def _import_activity(self, obj, activity, options):
activity_data = self._transform_activity_data(obj, activity, options)
if activity_data is None:
return
change_old = activity_data["change_old"]
change_new = activity_data["change_new"]
hist_type = activity_data["hist_type"]
comment = activity_data["comment"]
user = activity_data["user"]
key = make_key_from_model_object(activity_data["obj"])
typename = get_typename_for_model_class(type(activity_data["obj"]))
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
entry = HistoryEntry.objects.create(
user=user,
project_id=obj.project.id,
key=key,
type=hist_type,
snapshot=None,
diff=fdiff.diff,
values=make_diff_values(typename, fdiff),
comment=comment,
comment_html=mdrender(obj.project, comment),
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(
created_at=activity["occurred_at"])
return HistoryEntry.objects.get(id=entry.id)
def _import_history(self, project, obj, history, options):
key = make_key_from_model_object(obj)
typename = get_typename_for_model_class(obj.__class__)
history_data = self._transform_history_data(project, obj, history, options)
if history_data is None:
return
change_old = history_data['change_old']
change_new = history_data['change_new']
hist_type = history_data['hist_type']
comment = history_data['comment']
user = history_data['user']
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
values = make_diff_values(typename, fdiff)
values.update(history_data['update_values'])
entry = HistoryEntry.objects.create(
user=user,
project_id=obj.project.id,
key=key,
type=hist_type,
snapshot=None,
diff=fdiff.diff,
values=values,
comment=comment,
comment_html=mdrender(obj.project, comment),
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(created_at=history['created'])
return HistoryEntry.objects.get(id=entry.id)
def _import_action(self, us, action, statuses, options):
key = make_key_from_model_object(us)
typename = get_typename_for_model_class(UserStory)
action_data = self._transform_action_data(us, action, statuses,
options)
if action_data is None:
return
change_old = action_data['change_old']
change_new = action_data['change_new']
hist_type = action_data['hist_type']
comment = action_data['comment']
user = action_data['user']
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
entry = HistoryEntry.objects.create(
user=user,
project_id=us.project.id,
key=key,
type=hist_type,
snapshot=None,
diff=fdiff.diff,
values=make_diff_values(typename, fdiff),
comment=comment,
comment_html=mdrender(us.project, comment),
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(
created_at=action['date'])
return HistoryEntry.objects.get(id=entry.id)
def _import_action(self, us, action, statuses, options):
key = make_key_from_model_object(us)
typename = get_typename_for_model_class(UserStory)
action_data = self._transform_action_data(us, action, statuses, options)
if action_data is None:
return
change_old = action_data['change_old']
change_new = action_data['change_new']
hist_type = action_data['hist_type']
comment = action_data['comment']
user = action_data['user']
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
entry = HistoryEntry.objects.create(
user=user,
project_id=us.project.id,
key=key,
type=hist_type,
snapshot=None,
diff=fdiff.diff,
values=make_diff_values(typename, fdiff),
comment=comment,
comment_html=mdrender(us.project, comment),
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(created_at=action['date'])
return HistoryEntry.objects.get(id=entry.id)
def _import_event(self, obj, event, options, cumulative_data):
typename = get_typename_for_model_class(type(obj))
key = make_key_from_model_object(obj)
event_data = self._transform_event_data(obj, event, options, cumulative_data)
if event_data is None:
return
change_old = event_data['change_old']
change_new = event_data['change_new']
user = event_data['user']
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
values = make_diff_values(typename, fdiff)
values.update(event_data['update_values'])
entry = HistoryEntry.objects.create(
user=user,
project_id=obj.project.id,
key=key,
type=HistoryType.change,
snapshot=None,
diff=fdiff.diff,
values=values,
comment="",
comment_html="",
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(created_at=event['created_at'])
return HistoryEntry.objects.get(id=entry.id)
def send_notifications(obj, *, history):
if history.is_hidden:
return None
key = make_key_from_model_object(obj)
owner = User.objects.get(pk=history.user["pk"])
notification, created = (
HistoryChangeNotification.objects.select_for_update().get_or_create(
key=key,
owner=owner,
project=obj.project,
history_type=history.type))
notification.updated_datetime = timezone.now()
notification.save()
notification.history_entries.add(history)
# Get a complete list of notifiable users for current
# object and send the change notification to them.
notify_users = get_users_to_notify(obj, discard_users=[notification.owner])
for notify_user in notify_users:
notification.notify_users.add(notify_user)
# If we are the min interval is 0 it just work in a synchronous and spamming way
if settings.CHANGE_NOTIFICATIONS_MIN_INTERVAL == 0:
send_sync_notifications(notification.id)
def _import_comments(source_obj, target_obj):
pre_save = signals.pre_save.receivers
post_save = signals.post_save.receivers
signals.pre_save.receivers = []
signals.post_save.receivers = []
comments = (get_history_queryset_by_model_instance(source_obj).exclude(
comment__exact=''))
us_key = make_key_from_model_object(target_obj)
for entry in comments.all():
HistoryEntry.objects.create(
user=entry.user,
project_id=entry.project_id,
key=us_key,
type=entry.type,
snapshot=None,
diff=entry.diff,
values=entry.values,
comment=entry.comment,
comment_html=entry.comment_html,
delete_comment_date=entry.delete_comment_date,
delete_comment_user=entry.delete_comment_user,
is_hidden=False,
is_snapshot=False,
created_at=entry.created_at)
signals.pre_save.receivers = pre_save
signals.post_save.receivers = post_save
def _import_event(self, obj, event, options, cumulative_data):
typename = get_typename_for_model_class(type(obj))
key = make_key_from_model_object(obj)
event_data = self._transform_event_data(obj, event, options, cumulative_data)
if event_data is None:
return
change_old = event_data['change_old']
change_new = event_data['change_new']
user = event_data['user']
diff = make_diff_from_dicts(change_old, change_new)
fdiff = FrozenDiff(key, diff, {})
values = make_diff_values(typename, fdiff)
values.update(event_data['update_values'])
entry = HistoryEntry.objects.create(
user=user,
project_id=obj.project.id,
key=key,
type=HistoryType.change,
snapshot=None,
diff=fdiff.diff,
values=values,
comment="",
comment_html="",
is_hidden=False,
is_snapshot=False,
)
HistoryEntry.objects.filter(id=entry.id).update(created_at=event['created_at'])
return HistoryEntry.objects.get(id=entry.id)
def test_edit_comment(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing",
key=key,
diff={},
user={"pk": project.owner.id})
history_entry_created_at = history_entry.created_at
assert history_entry.comment_versions == None
assert history_entry.edit_comment_date == None
client.login(project.owner)
url = reverse("userstory-history-edit-comment", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
data = json.dumps({"comment": "testing update comment"})
response = client.post(url, data, content_type="application/json")
assert 200 == response.status_code, response.status_code
history_entry = HistoryEntry.objects.get(id=history_entry.id)
assert len(history_entry.comment_versions) == 1
assert history_entry.comment == "testing update comment"
assert history_entry.comment_versions[0]["comment"] == "testing"
assert history_entry.edit_comment_date != None
assert history_entry.comment_versions[0]["user"]["id"] == project.owner.id
def test_get_comment_versions(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
comment="testing",
key=key,
diff={},
user={"pk": project.owner.id},
edit_comment_date=datetime.datetime.now(),
comment_versions = [{
"comment_html": "<p>test</p>",
"date": "2016-05-09T09:34:27.221Z",
"comment": "test",
"user": {
"id": project.owner.id,
}}])
client.login(project.owner)
url = reverse("userstory-history-comment-versions", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
response = client.get(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
assert response.data[0]["user"]["username"] == project.owner.username
def send_notifications(obj, *, history):
if history.is_hidden:
return None
key = make_key_from_model_object(obj)
owner = User.objects.get(pk=history.user["pk"])
notification, created = (HistoryChangeNotification.objects.select_for_update()
.get_or_create(key=key,
owner=owner,
project=obj.project,
history_type = history.type))
notification.updated_datetime = timezone.now()
notification.save()
notification.history_entries.add(history)
# Get a complete list of notifiable users for current
# object and send the change notification to them.
notify_users = get_users_to_notify(obj, discard_users=[notification.owner])
for notify_user in notify_users:
notification.notify_users.add(notify_user)
# If we are the min interval is 0 it just work in a synchronous and spamming way
if settings.CHANGE_NOTIFICATIONS_MIN_INTERVAL == 0:
send_sync_notifications(notification.id)
def test_get_comment_versions(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(
project=project,
type=HistoryType.change,
comment="testing",
key=key,
diff={},
user={"pk": project.owner.id},
edit_comment_date=timezone.now(),
comment_versions = [{
"comment_html": "<p>test</p>",
"date": "2016-05-09T09:34:27.221Z",
"comment": "test",
"user": {
"id": project.owner.id,
}}])
client.login(project.owner)
url = reverse("userstory-history-comment-versions", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
response = client.get(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
assert response.data[0]["user"]["username"] == project.owner.username
def test_edit_comment(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
project=project,
comment="testing",
key=key,
diff={},
user={"pk": project.owner.id})
history_entry_created_at = history_entry.created_at
assert history_entry.comment_versions == None
assert history_entry.edit_comment_date == None
client.login(project.owner)
url = reverse("userstory-history-edit-comment", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
data = json.dumps({"comment": "testing update comment"})
response = client.post(url, data, content_type="application/json")
assert 200 == response.status_code, response.status_code
history_entry = HistoryEntry.objects.get(id=history_entry.id)
assert len(history_entry.comment_versions) == 1
assert history_entry.comment == "testing update comment"
assert history_entry.comment_versions[0]["comment"] == "testing"
assert history_entry.edit_comment_date != None
assert history_entry.comment_versions[0]["user"]["id"] == project.owner.id
def store_history(project, obj, history):
serialized = serializers.HistoryExportSerializer(data=history, context={"project": project})
if serialized.is_valid():
serialized.object.key = make_key_from_model_object(obj)
if serialized.object.diff is None:
serialized.object.diff = []
serialized.object._importing = True
serialized.save()
return serialized
add_errors("history", serialized.errors)
return serialized
def store_history(project, obj, history):
serialized = serializers.HistoryExportSerializer(data=history, context={"project": project})
if serialized.is_valid():
serialized.object.key = make_key_from_model_object(obj)
if serialized.object.diff is None:
serialized.object.diff = []
serialized.object._importing = True
serialized.save()
return serialized
add_errors("history", serialized.errors)
return serialized
def _store_history(project, obj, history):
validator = validators.HistoryExportValidator(data=history, context={"project": project})
if validator.is_valid():
validator.object.key = make_key_from_model_object(obj)
if validator.object.diff is None:
validator.object.diff = []
validator.object.project_id = project.id
validator.object._importing = True
validator.save()
return validator
add_errors("history", validator.errors)
return validator
def _store_history(project, obj, history):
validator = validators.HistoryExportValidator(data=history, context={"project": project})
if validator.is_valid():
validator.object.key = make_key_from_model_object(obj)
if validator.object.diff is None:
validator.object.diff = []
validator.object.project_id = project.id
validator.object._importing = True
validator.save()
return validator
add_errors("history", validator.errors)
return validator
def data_us(data):
m = type("Models", (object,), {})
m.public_user_story = f.UserStoryFactory(project=data.public_project, ref=1)
m.public_history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing public",
key=make_key_from_model_object(m.public_user_story),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_user_story1 = f.UserStoryFactory(project=data.private_project1, ref=5)
m.private_history_entry1 = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing 1",
key=make_key_from_model_object(m.private_user_story1),
diff={},
user={"pk": data.project_member_with_perms.pk})
m.private_user_story2 = f.UserStoryFactory(project=data.private_project2, ref=9)
m.private_history_entry2 = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing 2",
key=make_key_from_model_object(m.private_user_story2),
diff={},
user={"pk": data.project_member_with_perms.pk})
return m
def test_delete_comment_by_project_owner(client):
project = f.create_project()
us = f.create_userstory(project=project)
membership = f.MembershipFactory.create(project=project, user=project.owner, is_owner=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing",
key=key)
client.login(project.owner)
url = reverse("userstory-history-delete-comment", args=(us.id,))
url = "%s?id=%s"%(url, history_entry.id)
response = client.post(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
def test_delete_comment_by_project_owner(client):
project = f.create_project()
us = f.create_userstory(project=project)
membership = f.MembershipFactory.create(project=project,
user=project.owner,
is_owner=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(type=HistoryType.change,
comment="testing",
key=key)
client.login(project.owner)
url = reverse("userstory-history-delete-comment", args=(us.id, ))
url = "%s?id=%s" % (url, history_entry.id)
response = client.post(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
def create_task_context(project, owner):
task = f.TaskFactory(project=project, owner=owner)
key = make_key_from_model_object(task)
task_history_change = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="test:change",
type=HistoryType.change,
key=key,
is_hidden=False,
diff=[],
)
take_snapshot(task, user=task.owner)
return create_notification(project, key, owner, [task_history_change])
def test_get_comment_versions_from_history_entry_without_comment(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
key=key,
diff={},
user={"pk": project.owner.id})
client.login(project.owner)
url = reverse("userstory-history-comment-versions", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
response = client.get(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
assert response.data == None
def test_get_comment_versions_from_history_entry_without_comment(client):
project = f.create_project()
us = f.create_userstory(project=project)
f.MembershipFactory.create(project=project, user=project.owner, is_admin=True)
key = make_key_from_model_object(us)
history_entry = f.HistoryEntryFactory.create(
type=HistoryType.change,
key=key,
diff={},
user={"pk": project.owner.id})
client.login(project.owner)
url = reverse("userstory-history-comment-versions", args=(us.id,))
url = "%s?id=%s" % (url, history_entry.id)
response = client.get(url, content_type="application/json")
assert 200 == response.status_code, response.status_code
assert response.data == None
def create_epic_context(project, owner):
epic = f.EpicFactory.create(project=project, owner=owner)
key = make_key_from_model_object(epic)
hc1 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="",
type=HistoryType.create,
key=key,
is_hidden=False,
diff={"description": "new description"},
)
hc2 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="test: change",
type=HistoryType.change,
key=key,
is_hidden=False,
diff={"content": "change content"},
)
hc3 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="",
type=HistoryType.change,
key=key,
is_hidden=False,
diff={"blocked_note": "blocked note"},
)
take_snapshot(epic, user=epic.owner)
return create_notification(project, key, owner, [hc1, hc2, hc3])
def create_us_context(project, owner):
us = f.UserStoryFactory.create(project=project, owner=owner)
key = make_key_from_model_object(us)
hc1 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="test:change",
type=HistoryType.change,
key=key,
is_hidden=False,
values={"users": {}},
diff={"description": "test:desc"},
)
# not notifiable
hc2 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="",
type=HistoryType.change,
key=key,
is_hidden=False,
values={"users": {}},
diff={"content": "test:content"},
)
hc3 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="",
type=HistoryType.change,
key=key,
is_hidden=False,
values={"users": {
"5": "Administrator",
"11": "Angela Perez"
}},
diff={"users": {
"5": "Administrator",
"11": "Angela Perez"
}},
)
# not notifiable
hc4 = f.HistoryEntryFactory.create(
project=project,
user={"pk": owner.id},
comment="",
type=HistoryType.change,
key=key,
is_hidden=False,
values={
"users": [],
"status": {
"1": "New",
"3": "In progress"
}
},
diff={"content": "test:content"},
)
take_snapshot(us, user=us.owner)
return create_notification(project, key, owner, [hc1, hc2, hc3, hc4])
