def obj_create(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
status_update = StatusUpdate.objects.get(status_en='Human Created')
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del(bundle.data['assigned_user'])
comment_uri = self.create_comment(
bundle.data['comment'],
status_update.id,
user
)
bundle.data['incident_comments'] = [
comment_uri
]
with reversion.create_revision():
bundle = super(IncidentResource, self)\
.obj_create(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
status='created',
user=user
)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def update_entities(model_dict, model_objects, appendable_keys):
'''
model_dict is the key value store of updated elements
model_objects are the models, these can be of type Actor, Bulletin or
Incident
delegates actual updating of fields to update_entity where the field
is to be replaced and to update_entity_appendable where the field is
to be added to
'''
appendable_dict, remainder_dict = separate_field_types(
model_dict, appendable_keys)
for model in model_objects:
model_dict_copy = remainder_dict.copy()
model_dict_copy = update_related_actors(model_dict_copy, model)
model = update_entity_appendable(appendable_dict, model)
model = update_entity_status(model_dict, model)
model = update_entity(model_dict_copy, model)
user = model_dict['user']
with reversion.create_revision():
model.save()
reversion.add_meta(VersionStatus, status='edited', user=user)
reversion.set_user(user)
comment_text = model_dict['comment']
reversion.set_comment(comment_text)
def test_diff_suppressed_priv(self):
"""Test diff with suppressed start/end as privledged user."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "BAD FAITH"
self.list.save()
bad_faith = self.versions().last()
bad_faith.revision.meta.suppressed = True
bad_faith.revision.meta.save()
diff_from = self.versions().first().pk
diff_to = self.versions().last().pk
self.assertNotEqual(diff_from, diff_to)
self.client.force_authenticate(user=self.oversighter)
url = "/api/lists/{list_pk}/revisions/{id}/diff/{other_id}/".format(
list_pk=self.list.pk,
id=diff_from,
other_id=diff_to,
)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertIn("original", response.data)
self.assertIn("operations", response.data)
self.assertIn("result", response.data)
self.assertTrue(response.data["result"]["suppressed"])
def create(self, validated_data):
"""Create a new tool list."""
user = self.context["request"].user
comment = validated_data.pop("comment", None)
tools = validated_data.pop("tools", [])
validated_data["tool_names"] = tools
validated_data["created_by"] = user
validated_data["modified_by"] = user
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
reversion.set_user(user)
if comment is not None:
reversion.set_comment(comment)
with auditlog_context(user, comment):
instance = ToolList.objects.create(**validated_data)
for idx, name in enumerate(tools):
ToolListItem.objects.create(
toollist=instance,
tool=Tool.objects.get(name=name),
order=idx,
added_by=user,
)
return instance
def testAddMetaMultDb(self):
with reversion.create_revision(using="mysql"), reversion.create_revision(using="postgres"):
obj = TestModel.objects.create()
reversion.add_meta(TestMeta, name="meta v1")
self.assertNoRevision()
self.assertSingleRevision((obj,), meta_names=("meta v1",), using="mysql")
self.assertSingleRevision((obj,), meta_names=("meta v1",), using="postgres")
def save(self, internal=False, *args, **kwargs):
if internal:
with transaction.commit_on_success():
with reversion.create_revision():
super(Listing, self).save(*args, **kwargs)
for a in self._amenity_list:
#add actually does a save internally, hitting the db
self.amenities.add(a)
serializer = JSONSerializer()
for event in self._uncommitted_events:
#we don't need to store the instance because it's not really part of the parameters
#and django-reversion will keep a snapshop
kwargs_to_save = {k: v for k, v in event.kwargs.items() if k != 'instance'}
data = serializer.serialize(kwargs_to_save)
reversion.add_meta(RevisionEvent, name=event.event_fq_name, version=event.version, data=data)
self.send_events()
else:
from scrapy_test.aggregates.listing.services import listing_service
listing_service.save_or_update(self)
def obj_create(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
status_update = StatusUpdate.objects.get(status_en='Human Created')
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del(bundle.data['assigned_user'])
comment_uri = self.create_comment(
bundle.data['comment'],
status_update.id,
user
)
bundle.data['bulletin_comments'] = [
comment_uri
]
with reversion.create_revision():
bundle = super(BulletinResource, self)\
.obj_create(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
status='created',
user=user
)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def testAddMetaMultDb(self):
with reversion.create_revision(using="mysql"), reversion.create_revision(using="postgres"):
obj = TestModel.objects.create()
reversion.add_meta(TestMeta, name="meta v1")
self.assertNoRevision()
self.assertSingleRevision((obj,), meta_names=("meta v1",), using="mysql")
self.assertSingleRevision((obj,), meta_names=("meta v1",), using="postgres")
def obj_update(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
if self.is_finalized(
Incident, kwargs['pk'],
'most_recent_status_incident') and can_finalize(user) is False:
raise ImmediateHttpResponse(
HttpForbidden('This item has been finalized'))
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del (bundle.data['assigned_user'])
status_id = self.id_from_url(bundle.data)
status_update = StatusUpdate.filter_by_perm_objects.get_update_status(
user, status_id)
comment_uri = self.create_comment(bundle.data['comment'],
status_update.id, user)
try:
bundle.data['incident_comments'].append(comment_uri)
except KeyError:
bundle.data['incident_comments'] = [
comment_uri,
]
with reversion.create_revision():
bundle = super(IncidentResource, self)\
.obj_update(bundle, **kwargs)
reversion.add_meta(VersionStatus, user=user, status='edited')
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def update_entities(model_dict, model_objects, appendable_keys):
'''
model_dict is the key value store of updated elements
model_objects are the models, these can be of type Actor, Bulletin or
Incident
delegates actual updating of fields to update_entity where the field
is to be replaced and to update_entity_appendable where the field is
to be added to
'''
appendable_dict, remainder_dict = separate_field_types(
model_dict, appendable_keys)
for model in model_objects:
model_dict_copy = remainder_dict.copy()
model_dict_copy = update_related_actors(model_dict_copy, model)
model = update_entity_appendable(appendable_dict, model)
model = update_entity_status(model_dict, model)
model = update_entity(model_dict_copy, model)
user = model_dict['user']
with reversion.create_revision():
model.save()
reversion.add_meta(
VersionStatus,
status='edited',
user=user
)
reversion.set_user(user)
comment_text = model_dict['comment']
reversion.set_comment(comment_text)
def create_revision(self, bundle, user, status_update):
with reversion.create_revision():
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
reversion.add_meta(
VersionStatus,
status=status_update,
user=user
)
def wrapped(self, request, *args, **kwargs):
with reversion.create_revision():
ret = fn(self, request, *args, **kwargs)
reversion.set_user(request.user)
reversion.add_meta(RevisionProject, project=request.project)
if getattr(self, 'log_obj', None):
reversion.add_meta(RevisionLogActivity,
log_activity=self.log_obj)
return ret
def wrapped(self, request, *args, **kwargs):
with reversion.create_revision():
ret = fn(self, request, *args, **kwargs)
reversion.set_user(request.user)
reversion.add_meta(RevisionProject, project=request.project)
if getattr(self, 'log_obj', None):
reversion.add_meta(RevisionLogActivity,
log_activity=self.log_obj)
return ret
def obj_update(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
bundle.data['id'] = kwargs['pk']
if self.can_edit(user, bundle, Actor) is False:
raise ImmediateHttpResponse(
HttpForbidden('You do not have permission to edit this entity')
)
if self.is_finalized(
Actor,
kwargs['pk'],
'most_recent_status_actor'
) and can_finalize(user) is False:
raise ImmediateHttpResponse(
HttpForbidden('This item has been finalized')
)
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del(bundle.data['assigned_user'])
status_id = self.id_from_url(bundle.data)
status_update = StatusUpdate.filter_by_perm_objects.get_update_status(
user,
status_id
)
comment_uri = self.create_comment(
bundle.data['comment'],
status_update.id,
user
)
if "condition" not in bundle.data:
bundle.data['condition'] = None
if "POB" not in bundle.data:
bundle.data['POB'] = None
if "current_location" not in bundle.data:
bundle.data['current_location'] = None
try:
bundle.data['actor_comments'].append(comment_uri)
except KeyError:
bundle.data['actor_comments'] = [comment_uri, ]
with reversion.create_revision():
bundle = super(ActorResource, self)\
.obj_update(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
status='edited',
user=user
)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def update(self, instance, validated_data):
"""Update a tool list record."""
user = self.context["request"].user
comment = validated_data.pop("comment", None)
tools = validated_data.pop("tools", [])
# Compute changes to the list metadata
instance_has_changes = False
for key, value in validated_data.items():
prior = getattr(instance, key)
if value != prior:
setattr(instance, key, value)
instance_has_changes = True
# Compute changes to the list contents
list_qs = ToolListItem.objects.filter(toollist=instance)
prior_tools = list(list_qs.values_list("tool__name", flat=True))
# I thought about doing some really fancy list diffing here using
# difflib.SequenceMatcher to find the minimal set of changes to the
# list items so that the db update could be really targeted. After
# playing with the idea it felt like a big pile of overkill, so
# instead we will just compare the ordered lists and if anything is
# different replace all of it below.
list_has_changes = prior_tools != tools
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
reversion.set_user(user)
if comment is not None:
reversion.set_comment(comment)
with auditlog_context(user, comment):
if instance_has_changes:
instance.modified_by = user
if list_has_changes:
# Save the list of tool names directly in our model as
# well as via the m2m relationship. This is a workaround
# for difficulties versioning m2m relations.
instance.tool_names = tools
# Delete prior list contents and then repopulate
list_qs.delete()
for idx, name in enumerate(tools):
ToolListItem.objects.create(
toollist=instance,
tool=Tool.objects.get(name=name),
order=idx,
added_by=user,
)
if instance_has_changes or list_has_changes:
instance.save()
return instance
def obj_update(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
if self.can_edit(user, bundle, Bulletin) is False:
raise ImmediateHttpResponse(
HttpForbidden('You do not have permission to edit this entity')
)
# permission checks
if self.is_finalized(
Bulletin,
kwargs['pk'],
'most_recent_status_bulletin'
) and can_finalize(user) is False:
raise ImmediateHttpResponse(
HttpForbidden('This item has been finalized')
)
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del(bundle.data['assigned_user'])
# decide on available status
status_id = self.id_from_url(bundle.data)
status_update = StatusUpdate.filter_by_perm_objects.get_update_status(
user,
status_id
)
# create the commnt from the status update and the bundled comment
comment_uri = self.create_comment(
bundle.data['comment'],
status_update.id,
user
)
try:
bundle.data['bulletin_comments'].append(comment_uri)
except KeyError:
bundle.data['bulletin_comments'] = [comment_uri, ]
with reversion.create_revision():
bundle = super(BulletinResource, self)\
.obj_update(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
status='edited',
user=user
)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def form_valid(self, form, formsets):
with reversion.create_revision():
self.object, action = self.save_object(form, formsets)
# Set reversion metadata
reversion.set_user(self.request.user)
reversion.set_comment('%sed %s.' % (action, self.object._meta.module_name))
reversion.add_meta(RevisionProject, project=self.project)
self.save_formsets(formsets)
form.save_m2m()
return redirect(self.get_success_url())
def obj_delete(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
with reversion.create_revision():
bundle = super(IncidentResource, self)\
.obj_delete(bundle, **kwargs)
reversion.add_meta(VersionStatus, user=user, status='deleted')
reversion.set_user(user)
reversion.set_comment('Deleted')
update_object.delay(username)
return bundle
def form_valid(self, form, formsets):
with reversion.create_revision():
self.object, action = self.save_object(form, formsets)
# Set reversion metadata
reversion.set_user(self.request.user)
reversion.set_comment('%sed %s.' %
(action, self.object._meta.model_name))
reversion.add_meta(RevisionProject, project=self.project)
self.save_formsets(formsets)
form.save_m2m()
return redirect(self.get_success_url())
def testCanAddMetaToRevision(self):
# Create a revision with lots of meta data.
with reversion.create_revision():
self.test11.save()
reversion.set_comment("Foo bar")
self.assertEqual(reversion.get_comment(), "Foo bar")
reversion.set_user(self.user)
self.assertEqual(reversion.get_user(), self.user)
reversion.add_meta(RevisionMeta, age=5)
# Test the revision data.
revision = reversion.get_for_object(self.test11)[0].revision
self.assertEqual(revision.user, self.user)
self.assertEqual(revision.comment, "Foo bar")
self.assertEqual(revision.revisionmeta.age, 5)
def testCanAddMetaToRevision(self):
# Create a revision with lots of meta data.
with reversion.create_revision():
self.test11.save()
reversion.set_comment("Foo bar")
self.assertEqual(reversion.get_comment(), "Foo bar")
reversion.set_user(self.user)
self.assertEqual(reversion.get_user(), self.user)
reversion.add_meta(RevisionMeta, age=5)
# Test the revision data.
revision = reversion.get_for_object(self.test11)[0].revision
self.assertEqual(revision.user, self.user)
self.assertEqual(revision.comment, "Foo bar")
self.assertEqual(revision.revisionmeta.age, 5)
def test_hide(self):
"""Test hide action."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "REVERTED"
self.list.save()
self.client.force_authenticate(user=self.oversighter)
url = "/api/lists/{list_pk}/revisions/{id}/hide/".format(
list_pk=self.list.pk,
id=self.versions().last().pk,
)
response = self.client.patch(url)
self.assertEqual(response.status_code, 204)
self.assertTrue(self.versions()[1].revision.meta.suppressed)
def _create_investment_activity(self, instance, note):
"""
Creates the InvestmentActivity and associates it with the relevant revision.
TODO: Remove the need to associate the note with a revision when the audit history
is deprecated and replaced with an activity stream using the InvestmentActivity table.
"""
reversion.add_meta(
InvestmentActivity,
text=note['text'],
activity_type_id=note['activity_type'].id,
investment_project=instance,
created_by=self.context.get('current_user'),
)
def obj_delete(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
with reversion.create_revision():
bundle = super(IncidentResource, self)\
.obj_delete(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
user=user,
status='deleted'
)
reversion.set_user(user)
reversion.set_comment('Deleted')
update_object.delay(username)
return bundle
def updateMpasFromWdpaQueryset(qs=None, poly=True, existingrevisions={}):
if qs is None:
qs = Wdpa2014Polygon.objects.all().defer(*Wdpa2014Polygon.get_geom_fields()).order_by('wdpaid')
count = 0
for wpoly in qs:
# mpa, created = Mpa.objects.get_or_create(wdpa_id=wpoly.wdpaid)
created = False
try:
mpa = Mpa.objects.get(wdpa_id=wpoly.wdpaid)
if mpa.country in UsaCodes:
print 'USA: not processing', wpoly.wdpaid
continue
except Mpa.DoesNotExist:
mpa = Mpa(wdpa_id=wpoly.wdpaid)
created = True
count += 1
print count
try:
versions = len(reversion.get_for_object(mpa))
except:
versions = 0
if versions > 0:
print 'Previous versions for wdpaid', wpoly.wdpaid
existingrevisions[wpoly.wdpaid] = (
{
'no_take_old': mpa.no_take,
'no_take_area_old': mpa.no_take_area
},
{
'no_take': wpoly.no_take,
'no_take_area': wpoly.no_tk_area
}
)
else:
print 'Updating wdpaid', wpoly.wdpaid
# update record and create a revision so we can roll back if needed
with transaction.atomic(), reversion.create_revision():
updateMpaFromWdpa(wpoly, mpa, poly)
comment = 'Updated record from WDPA October 2014'
reference = 'World Database on Protected Areas, October 2014'
reversion.set_comment(comment)
User = get_user_model()
user = User.objects.get(username='******')
reversion.set_user(user)
reversion.add_meta(VersionMetadata, comment=comment, reference=reference)
return True
def test_reveal_requires_special_rights(self):
"""Test reveal action."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "REVERTED"
self.list.save()
bad_faith = self.versions().last()
bad_faith.revision.meta.suppressed = True
bad_faith.revision.meta.save()
self.client.force_authenticate(user=self.user)
url = "/api/lists/{list_pk}/revisions/{id}/reveal/".format(
list_pk=self.list.pk,
id=bad_faith.pk,
)
response = self.client.patch(url)
self.assertEqual(response.status_code, 403)
def test_revert_as_oversighter(self):
"""Test revert action."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "Changed"
self.list.save()
self.assertEqual(self.list.title, "Changed")
self.client.force_authenticate(user=self.oversighter)
url = "/api/lists/{list_pk}/revisions/{id}/revert/".format(
list_pk=self.list.pk,
id=self.versions().last().pk,
)
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertIn("title", response.data)
self.assertNotEqual(response.data["title"], "Changed")
def obj_update(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
bundle.data['id'] = kwargs['pk']
if self.can_edit(user, bundle, Actor) is False:
raise ImmediateHttpResponse(
HttpForbidden(
'You do not have permission to edit this entity'))
if self.is_finalized(
Actor, kwargs['pk'],
'most_recent_status_actor') and can_finalize(user) is False:
raise ImmediateHttpResponse(
HttpForbidden('This item has been finalized'))
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del (bundle.data['assigned_user'])
status_id = self.id_from_url(bundle.data)
status_update = StatusUpdate.filter_by_perm_objects.get_update_status(
user, status_id)
comment_uri = self.create_comment(bundle.data['comment'],
status_update.id, user)
if "condition" not in bundle.data:
bundle.data['condition'] = None
if "POB" not in bundle.data:
bundle.data['POB'] = None
if "current_location" not in bundle.data:
bundle.data['current_location'] = None
try:
bundle.data['actor_comments'].append(comment_uri)
except KeyError:
bundle.data['actor_comments'] = [
comment_uri,
]
with reversion.create_revision():
bundle = super(ActorResource, self)\
.obj_update(bundle, **kwargs)
reversion.add_meta(VersionStatus, status='edited', user=user)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def obj_update(self, bundle, **kwargs):
username = bundle.request.GET['username']
user = User.objects.filter(username=username)[0]
if self.is_finalized(
Incident,
kwargs['pk'],
'most_recent_status_incident'
) and can_finalize(user) is False:
raise ImmediateHttpResponse(
HttpForbidden('This item has been finalized')
)
if can_assign_users(user) is False and 'assigned_user' in bundle.data:
del(bundle.data['assigned_user'])
status_id = self.id_from_url(bundle.data)
status_update = StatusUpdate.filter_by_perm_objects.get_update_status(
user,
status_id
)
comment_uri = self.create_comment(
bundle.data['comment'],
status_update.id,
user
)
try:
bundle.data['incident_comments'].append(comment_uri)
except KeyError:
bundle.data['incident_comments'] = [comment_uri, ]
with reversion.create_revision():
bundle = super(IncidentResource, self)\
.obj_update(bundle, **kwargs)
reversion.add_meta(
VersionStatus,
user=user,
status='edited'
)
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
update_object.delay(username)
return bundle
def _add_meta(request):
"""
Adding session key to revision meta via VersionMeta model
"""
token = request.headers.get('Authorization', u'')
if token and len(token.split()) == 2:
token_info = payload_from_auth_header(token)
user_id = token_info.get('user_id')
user = DotpUser.objects.get(id=user_id)
full_name = user.first_name + ' ' + user.last_name
else:
user_id = ''
full_name = ''
params = dict(
user_id=user_id,
full_name=full_name,
)
reversion.add_meta(AuditTrailUser, **params)
def testAddMetaInstance(self):
# Create an meta instance manually
inst = TestMetaWithNullRevision.objects.create(
name='meta v1 pre'
)
# Sanity check to make sure revision is null
self.assertEqual(inst.revision, None)
# Create the revision given it our meta instance
with reversion.create_revision():
reversion.add_meta(inst)
obj = TestModel.objects.create()
self.assertSingleRevision(
(obj,),
meta_names=("meta v1 pre", ),
meta_attr='testmetawithnullrevision_set'
)
# After refreshing the inst, ensure revision is now set
inst.refresh_from_db()
self.assertNotEqual(inst.revision, None)
def test_diff(self):
"""Test diff action."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "Changed"
self.list.save()
diff_from = self.versions().first().pk
diff_to = self.versions().last().pk
self.assertNotEqual(diff_from, diff_to)
self.client.force_authenticate(user=None)
url = "/api/lists/{list_pk}/revisions/{id}/diff/{other_id}/".format(
list_pk=self.list.pk,
id=diff_from,
other_id=diff_to,
)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertIn("original", response.data)
self.assertIn("operations", response.data)
self.assertIn("result", response.data)
def test_undo(self):
"""Test undo action."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "Changed"
self.list.save()
self.assertEqual(self.list.title, "Changed")
undo_from = self.versions().first().pk
undo_to = self.versions().last().pk
self.assertNotEqual(undo_from, undo_to)
self.client.force_authenticate(user=self.user)
url = "/api/lists/{list_pk}/revisions/{id}/undo/{other_id}/".format(
list_pk=self.list.pk,
id=undo_from,
other_id=undo_to,
)
response = self.client.post(url)
self.assertEqual(response.status_code, 200)
self.assertIn("title", response.data)
self.assertNotEqual(response.data["title"], "Changed")
def post(self, request, *args, **kwargs):
"""Add a new note section"""
section_type = request.DATA.get('section_type', None)
if section_type is None:
raise Exception('need a section type')
sec_serializer = _serializer_from_section_type(section_type)
serializer = sec_serializer(
data=request.DATA, context={
'request': request,
'create_revision': True
})
if serializer.is_valid():
serializer.object.note = self.get_object()
serializer.object.creator = request.user
serializer.object.last_updater = request.user
with reversion.create_revision():
serializer.save()
reversion.set_user(request.user)
reversion.add_meta(RevisionProject, project=request.project)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.data, status=status.HTTP_400_BAD_REQUEST)
def test_diff_suppressed_anon(self):
"""Test diff with suppressed start/end as anon."""
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
self.list.title = "BAD FAITH"
self.list.save()
bad_faith = self.versions().last()
bad_faith.revision.meta.suppressed = True
bad_faith.revision.meta.save()
self.assertTrue(self.versions().last().revision.meta.suppressed)
diff_from = self.versions().first().pk
diff_to = self.versions().last().pk
self.assertNotEqual(diff_from, diff_to)
self.client.force_authenticate(user=None)
url = "/api/lists/{list_pk}/revisions/{id}/diff/{other_id}/".format(
list_pk=self.list.pk,
id=diff_from,
other_id=diff_to,
)
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
def update(self, instance, validated_data):
"""Update an annotations record."""
user = self.context["request"].user
comment = validated_data.pop("comment", None)
has_changes = False
for key, value in validated_data.items():
prior = getattr(instance, key)
if value != prior:
setattr(instance, key, value)
has_changes = True
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
reversion.set_user(user)
if comment is not None:
reversion.set_comment(comment)
with auditlog_context(user, comment):
if has_changes:
instance.save()
instance.tool.modified_by = user
instance.tool.save()
return instance
def setUpTestData(cls):
"""Setup for all tests in this TestCase."""
cls.user = cls._user("user")
cls.oversighter = cls._user("oversighter", group="Oversighters")
cls.patroller = cls._user("patroller", group="Patrollers")
cls.toolinfo = cls._load_json("toolinfo_fixture.json")
cls.tool, _, _ = Tool.objects.from_toolinfo(cls.toolinfo, cls.user,
models.Tool.ORIGIN_API)
with reversion.create_revision():
reversion.add_meta(RevisionMetadata)
reversion.set_user(cls.user)
cls.list = models.ToolList.objects.create(
title="A test fixture list",
published=True,
created_by=cls.user,
)
models.ToolListItem.objects.create(
toollist=cls.list,
tool=cls.tool,
)
def testAddMetaNoBlock(self):
with self.assertRaises(reversion.RevisionManagementError):
reversion.add_meta(TestMeta, name="meta v1")
def testAddMeta(self):
with reversion.create_revision():
reversion.add_meta(TestMeta, name="meta v1")
obj = TestModel.objects.create()
self.assertSingleRevision((obj, ), meta_names=("meta v1", ))
def record_destroy(self, request, instance):
commit_comment = request.data.get('commit-comment', '')
instance.save()
reversion.set_user(user=self.request.user)
reversion.set_comment(comment=commit_comment)
reversion.add_meta(CommitDeletion)
def testAddMetaNoBlock(self):
with self.assertRaises(reversion.RevisionManagementError):
reversion.add_meta(TestMeta, name="meta v1")
def testAddMeta(self):
with reversion.create_revision():
reversion.add_meta(TestMeta, name="meta v1")
obj = TestModel.objects.create()
self.assertSingleRevision((obj,), meta_names=("meta v1",))
def bind_revision(self, obj, attrname='revision'):
reversion.add_meta(ReversionMerger(attrname), obj=obj)
def wrapped(self, request, *args, **kwargs):
with reversion.create_revision():
ret = fn(self, request, *args, **kwargs)
reversion.set_user(request.user)
reversion.add_meta(RevisionProject, project=request.project)
return ret
def parse(self): # {{{2
'''
parse all mails from imap mailbox
'''
#re_charset = re.compile( r'charset=([^\s]*)', re.IGNORECASE )
for number in self.get_list():
typ, data = self.mailbox.fetch(number, '(RFC822 UID BODY[TEXT])')
if (data is None) or (len(data) < 1) or (data[0] is None) or \
(len(data[0]) < 2):
continue
mail = email.message_from_string(data[0][1])
text = u""
msgobj = EmailParser().parse(StringIO(mail), False)
for part in msgobj.walk():
if part.get_content_type() == "text/plain":
if part.get_content_charset():
text += unicode(part.get_payload(decode=True),
part.get_content_charset(), 'replace')
# extracs subject
subject = ''
if msgobj['Subject'] is not None:
decodefrag = decode_header(msgobj['Subject'])
subj_fragments = []
for string, enc in decodefrag:
if enc:
string = unicode(string, enc, 'replace')
#s = unicode( s , enc ).encode( 'utf8', \
# 'replace' )
subj_fragments.append(string)
subject = u''.join(subj_fragments)
# 'from' field of the email received (TODO: better 'reply-to'?)
to_email = mail['From']
# sender of our emails
from_email = settings.DEFAULT_FROM_EMAIL
try:
sid = transaction.savepoint()
with reversion.create_revision():
event, dates_times_list = Event.parse_text(text)
reversion.add_meta(RevisionInfo,
as_text=smart_unicode(event.as_text()))
for dates_times in dates_times_list:
with reversion.create_revision():
clone = event.clone(
user=None,
except_models=[EventDate, EventSession],
**dates_times)
reversion.add_meta(RevisionInfo,
as_text=smart_unicode(
clone.as_text()))
assert (type(event) == Event)
self.mv_mail(number, 'saved')
self.stdout.write(
smart_str(u'Successfully added new event: ' + event.title))
message = render_to_string(
'mail/email_accepted_event.txt', {
'site_name': Site.objects.get_current().name,
'site_domain': Site.objects.get_current().domain,
'event': event,
'original_message': text,
})
mail = EmailMessage(''.join(subject.splitlines()), message,
from_email, (to_email, ))
mail.send(fail_silently=False)
transaction.savepoint_commit(sid)
except (ValidationError, IntegrityError) as err:
transaction.savepoint_rollback(sid)
# error found, saving the message in the imap forder 'errors'
self.mv_mail(number, 'errors')
# sending a notification email to the sender {{{3
if msgobj['Subject'] is not None:
subject = \
_( u'Validation error in: %(old_email_subject)s' ) \
% { 'old_email_subject': \
subject.replace( '\n', ' ' ), }
subject = subject.replace('\n', ' ')
else:
subject = _(u'Validation error')
# insert errors message into the email body
if hasattr(err, 'message_dict'):
# if hasattr(err, 'message_dict'), it looks like:
# {'url': [u'Enter a valid value.']}
message = render_to_string(
'mail/email_parsing_errors.txt', {
'site_name': Site.objects.get_current().name,
'site_domain': Site.objects.get_current().domain,
'original_message': text,
'errors_dict': err.message_dict
})
#TODO: write to an error log file instead of stderr
self.stderr.write( smart_str(
u"Found errors in message with subject: %s\n\terrors: %s" \
% ( mail['Subject'], unicode(err.message_dict))))
elif hasattr(err, 'messages'):
message = render_to_string(
'mail/email_parsing_errors.txt', {
'site_name': Site.objects.get_current().name,
'site_domain': Site.objects.get_current().domain,
'original_message': text,
'errors_list': err.messages
})
self.stderr.write( smart_str(
u"Found errors in message with subject: %s\n\terrors: %s" \
% ( mail['Subject'], unicode(err.messages))))
elif hasattr(err, 'message'):
message = render_to_string(
'mail/email_parsing_errors.txt', {
'site_name': Site.objects.get_current().name,
'site_domain': Site.objects.get_current().domain,
'original_message': text,
'errors_list': [err.message]
})
self.stderr.write( smart_str(
u"Found errors in message with subject: %s\n\terrors: %s" \
% ( mail['Subject'], unicode(err.message))))
else:
message = render_to_string(
'mail/email_parsing_errors.txt', {
'site_name': Site.objects.get_current().name,
'site_domain': Site.objects.get_current().domain,
'original_message': text,
'errors_list': []
})
self.stderr.write( smart_str(
u"Found errors in message with subject: %s" \
% mail['Subject'] ))
if subject and message and from_email:
mail = EmailMessage( subject, message, \
from_email, ( to_email, ) )
msg = str(mail.message())
try:
mail.send(fail_silently=False)
self.mailbox.append( 'IMAP.sent', None, None, \
msg )
except SMTPException:
#TODO: write to an error log file instead of stderr
self.stderr.write('imap.py:ERR:smtplib.SMTPException')
else:
#TODO: write to an error log file instead of stderr
self.stderr.write(
'imap.py:ERR:missing info for error email')
except:
transaction.savepoint_rollback(sid)
raise
'price': cat_price_total,
'total': sum([cat_exp_total, cat_price_total]),
'task_set': task_set_json,
}
return result_dict
reversion.register(Project, follow=['task_set'], exclude=["created, modified"])
class ProjectImage(Slugged):
project = models.ForeignKey(Project, related_name="project_images")
update = models.ForeignKey('updates.Update', related_name="project_images", null=True, blank=True)
change_order = models.ForeignKey('changes.ChangeOrder', related_name="project_images", null=True, blank=True)
image = models.ImageField(max_length=200, upload_to='projects', width_field='width', height_field='height')
width = models.IntegerField(max_length=255, blank=True, null=True)
height = models.IntegerField(max_length=255, blank=True, null=True)
#approved = models.NullBooleanField()
class Meta:
verbose_name = _("Project Image")
verbose_name_plural = _("Project Images")
order_with_respect_to = 'project'
'''
class VersionRating(models.Model):
revision = models.OneToOneField(Revision) # This is required
rating = models.PositiveIntegerField()
reversion.add_meta(VersionRating, rating=5)
'''
def create_revision(self, bundle, user, status_update):
with reversion.create_revision():
reversion.set_user(user)
reversion.set_comment(bundle.data['comment'])
reversion.add_meta(VersionStatus, status=status_update, user=user)
update = models.ForeignKey('updates.Update',
related_name="project_images",
null=True,
blank=True)
change_order = models.ForeignKey('changes.ChangeOrder',
related_name="project_images",
null=True,
blank=True)
image = models.ImageField(max_length=200,
upload_to='projects',
width_field='width',
height_field='height')
width = models.IntegerField(max_length=255, blank=True, null=True)
height = models.IntegerField(max_length=255, blank=True, null=True)
#approved = models.NullBooleanField()
class Meta:
verbose_name = _("Project Image")
verbose_name_plural = _("Project Images")
order_with_respect_to = 'project'
'''
class VersionRating(models.Model):
revision = models.OneToOneField(Revision) # This is required
rating = models.PositiveIntegerField()
reversion.add_meta(VersionRating, rating=5)
'''
