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 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 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 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 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) '''