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 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['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 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 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 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 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='russmo')
            reversion.set_user(user)
            reversion.add_meta(VersionMetadata, comment=comment, reference=reference)
    return True

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

                '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 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 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 bind_revision(self, obj, attrname='revision'):
     reversion.add_meta(ReversionMerger(attrname), obj=obj)