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 remove_trainees(self, trainees):
     with reversion.create_revision() and transaction.atomic():
         if reversion.is_active():
             reversion.set_comment('Removed trainees')
         for trainee in trainees:
             self.trainees.remove(trainee)
         self.save()

def editInclusionOrder(request, dss_id, inc_type):
    if inc_type not in ['cluster', 'data_element']:
        raise Http404
    item = get_object_or_404(aristotle_dse.models.DataSetSpecification, pk=dss_id)
    if not user_can_edit(request.user, item):
        if request.user.is_anonymous():
            return redirect(reverse('friendly_login') + '?next=%s' % request.path)
        else:
            raise PermissionDenied

    item_type, field_name = {
        'cluster': (aristotle_dse.models.DSSClusterInclusion, 'child'),
        'data_element': (aristotle_dse.models.DSSDEInclusion, 'data_element'),
        }.get(inc_type)

    num_values = item_type.objects.filter(dss=item.id).count()
    if num_values > 0:
        extra = 0
    else:
        extra = 1

    ValuesFormSet = modelformset_factory(
        item_type,
        formset=HiddenOrderModelFormSet,
        can_order=True,
        fields=('id',),
        extra=extra
    )

    if request.method == 'POST':
        formset = ValuesFormSet(request.POST, request.FILES)
        if formset.is_valid():
            with transaction.atomic(), reversion.create_revision():
                item.save()  # do this to ensure we are saving reversion records for the DSS, not just the values
                formset.save(commit=False)
                for form in formset.forms:
                    if form['id'].value() not in [deleted_record['id'].value() for deleted_record in formset.deleted_forms]:
                        inc = item_type.objects.get(pk=form['id'].value())
                        if inc.dss != item:
                            raise PermissionDenied
                        inc.order = form['ORDER'].value()
                        # inc.maximum_occurances = form['maximum_occurances'].value()
                        # value = form.save(commit=False) #Don't immediately save, we need to attach the value domain
                        # value.dss = item
                        inc.save()
                for obj in formset.deleted_objects:
                    obj.delete()
                reversion.set_user(request.user)
                reversion.set_comment(construct_change_message(request, None, [formset, ]))

                return redirect(reverse("aristotle_mdr:item", args=[item.id]))
    else:
        formset = ValuesFormSet(
            queryset=item_type.objects.filter(dss=item.id),
        )
    return render(
        request,
        "aristotle_dse/actions/edit_inclusion_order.html",
        {'item': item, 'formset': formset, 'include_type': inc_type, 'value_model': item_type, }
    )

def make_profile(backend, user, response, is_new=False, *args, **kwargs):
    if is_new:
        if not hasattr(user, "profile"):
            profile = Profile(user=user)
            profile.language = Language.get_python2()
            if backend.name == "google-oauth2":
                profile.name = response["displayName"]
            elif backend.name in ("github", "facebook") and "name" in response:
                profile.name = response["name"]
            else:
                logger.info("Info from %s: %s", backend.name, response)
            profile.save()
            form = ProfileForm(instance=profile, user=user)
        else:
            data = backend.strategy.request_data()
            logger.info(data)
            form = ProfileForm(data, instance=user.profile, user=user)
            if form.is_valid():
                with transaction.atomic(), revisions.create_revision():
                    form.save()
                    revisions.set_user(user)
                    revisions.set_comment("Updated on registration")
                    return
        return render(
            backend.strategy.request,
            "registration/profile_creation.jade",
            {"title": "Create your profile", "form": form},
        )

def edit_mpa(request, pk):
    mpa = get_object_or_404(Mpa, pk=pk)
    if (request.POST):
        # Got a form submission
        editform = MpaForm(request.POST, instance=mpa)
        if editform.is_valid():
            mpasaved = editform.save()
            try:
                reversion.set_comment(editform.cleaned_data.get("edit_comment"))
            except:
                pass
            try:
                reversion.set_user(request.user)
            except:
                pass
            try:
                reversion.add_meta(VersionMetadata, comment=editform.cleaned_data.get("edit_comment"), reference=editform.cleaned_data.get("edit_reference"))
            except:
                pass
            return HttpResponseRedirect(reverse('mpa-siteinfo', kwargs={'pk': pk}))
    else:
        editform = MpaForm(instance=mpa)
    return render_to_response('mpa/Mpa_editform.html', {
        'form': editform,
        'mpa': mpa,
        'respond_url': reverse('mpa-editsite', kwargs={'pk': pk}),
    }, context_instance=RequestContext(request))

    def ingest(cls, open_file, force=False):
        name = os.path.basename(open_file.name)
        content = open_file.read()

        stat_info = os.stat(open_file.name)
        file_modified = datetime.utcfromtimestamp(stat_info.st_mtime).replace(tzinfo=tzutc())

        with transaction.atomic(), revisions.create_revision():
            revisions.set_comment('Ingested {name}'.format(name=name))

            try:
                existing = cls.objects.get(name=name)
            except cls.DoesNotExist:
                logger.info('Ingest %s', name)
                return cls.objects.create(name=name, content=content)
            else:
                if file_modified <= existing.updated_at:
                    if force:
                        logger.warn('Ingest %s (force)', name)
                    else:
                        logger.info('Ignore %s (older)', name)
                        return existing
                else:
                    logger.info('Ingest %s (newer)', name)

                existing.content = content
                existing.save()
                return existing

    def import_lag(self, lag_fn=None):
        reversion.set_comment("Import frå Access")
        liste = csv.reader(open(lag_fn or self.lag_fil))
        liste.next()
        alle_lag = {}

        for rad in liste:
            namn = rad[2].decode('utf-8')       \
                    .title()                    \
                    .replace(' Og ', ' og ')    \
                    .replace(' I ', ' i ')      \
                    .replace(u' På ', u' på ')  \
                    .replace('Fmu', 'FMU')      \
                    .replace('Nmu', 'NMU')      \
                    .replace(' Mu', ' MU')

            lag = Lokallag.objects.filter(pk=rad[3])
            if len(lag):
                lag = lag[0]
                lag.namn = namn
                lag.andsvar = rad[4].decode('utf-8')
            else:
                lag = Lokallag(pk=rad[3], namn=namn, andsvar=rad[4].decode('utf-8'))
            lag.save()

            alle_lag[rad[3]] = lag

        return alle_lag

 def log_change(self, request, object, message):
     if is_active():
         if isinstance(message, list):
             set_comment(LogEntry(change_message=json.dumps(message)).get_change_message())
         else:
             set_comment(message)
     super(VersionAdmin, self).log_change(request, object, message)

    def post(self, request, *args, **kwargs):
        if not request.user.is_authenticated():
            raise Exception("Not logged in!  Only staff have access to this function")

        if not request.user.is_staff and not request.user.is_superuser:
            raise Exception("Only staff have access to this function")

        keys = [('location', Location), ('time_block', TimeBlock), ('time_slot', TimeSlot)]
        key_text = 0
        key_db_object = 1

        game_id = request.POST.get('id')
        game = Game.objects.get(id=game_id)

        changed = []

        for key in keys:
            incoming_id = request.POST.get(key[key_text])
            old = getattr(game, key[key_text])
            new = key[key_db_object].objects.get(id=incoming_id) if incoming_id else None

            setattr(game, key[key_text], new)
            if old != new:
                changed.append(key[key_text])

        changed.sort()
        game.last_scheduled = timezone.now()

        with reversion.create_revision():
            reversion.set_user(request.user)
            reversion.set_comment("AJAX Schedule Submission - %s Changed" % ", ".join(changed))

            game.save()

def change_mark(request, slug):
    if request.method == "POST":
        data = json.loads(request.body.decode("utf-8"))
        grade_system = data.get("grade_system")
        pk = data.get("pk")
        new_comment = data.get("comment")
        new_mark = data.get("mark")
        if grade_system is not None and pk is not None and new_mark is not None:
            with reversion.create_revision():
                mark, old_mark = MarkAPI.set_mark(grade_system, pk, new_mark)
                if mark.problem:
                    assignment_hierarchy = "{0:s}/{1:s}/{2:s}".format(
                        mark.problem.task.assignment.name, mark.problem.task.name, mark.problem.name
                    )
                elif mark.task:
                    assignment_hierarchy = "{0:s}/{1:s}".format(mark.task.assignment.name, mark.task.name)
                else:
                    assignment_hierarchy = "{0:s}".format(mark.assignment.name)
                reversion.set_user(request.user)
                reversion.set_comment(
                    """Mark for '{0:s}' student, for '{1:s}'
                    assignment was changed from '{2:d}' to '{3:d}' by '{4:s}' user """.format(
                        mark.student.username, assignment_hierarchy, old_mark, mark.mark, request.user.username
                    )
                )
        if grade_system is not None and pk is not None and new_comment is not None:
            MarkAPI.set_comment(grade_system, pk, new_comment)
    return HttpResponse()

    def obj_create(self, bundle, **kwargs):
        '''
        created objects should automatically have a status of Human Created
        '''
        status_update = StatusUpdate.objects.get(status_en='Human Created')
        username = bundle.request.GET['username']
        user = User.objects.filter(username=username)[0]
        status_id = status_update.id

        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_id,
            user
        )
        bundle.data['actor_comments'] = [
            comment_uri
        ]
        with reversion.create_revision():
            bundle = super(ActorResource, 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 form_valid(self, form):
        """
        Sets EDID and identification when creating new timing.

        Used for CreateView and UpdateView.
        """

        # For CreateView, set EDID
        if not form.instance.EDID_id:
            form.instance.EDID = form.edid
            if not form.instance.identification:
                # Get count of available timings
                count = self.model.objects.filter(EDID=form.instance.EDID)\
                                          .count()
                # Set identification to count + 1
                form.instance.identification = count + 1

        # Set the user
        form.instance.user = self.request.user

        # Set revision comment
        if isinstance(self, CreateView):
            comment = 'Created %s %s.'
        elif isinstance(self, UpdateView):
            comment = 'Updated %s %s.'

        reversion.set_comment(comment % (
            form.instance._meta.verbose_name, form.instance
        ))

        reversion.add_to_revision(form.instance.EDID)

        return super(TimingMixin, self).form_valid(form)

    def create(self, validated_data):
        request = self.context['request']
        venue_id = validated_data['venue']
        slots = validated_data['slots']
        talk = validated_data.get('talk')
        page = validated_data.get('page')

        try:
            existing_schedule_item = ScheduleItem.objects.get(
                venue_id=venue_id, slots__in=slots)
        except ScheduleItem.DoesNotExist:
            revisions.set_user(request.user)
            revisions.set_comment("Created using Schedule Editor")
        else:
            existing_schedule_item.talk = talk
            existing_schedule_item.page = page
            existing_schedule_item.slots = slots
            # Clear any existing details that aren't editable by the
            # schedule edit view
            existing_schedule_item.details = ''
            existing_schedule_item.notes = ''
            existing_schedule_item.css_class = ''
            existing_schedule_item.expand = False
            existing_schedule_item.save()
            revisions.set_user(request.user)
            revisions.set_comment("Updated using Schedule Editor")
            return existing_schedule_item
        return super(ScheduleItemSerializer, self).create(validated_data)

 def handle(self, *app_labels, **options):
     verbosity = options["verbosity"]
     using = options["using"]
     model_db = options["model_db"]
     comment = options["comment"]
     batch_size = options["batch_size"]
     meta = options["meta"]
     meta_models = []
     for label in meta.keys():
         try:
             model = apps.get_model(label)
             meta_models.append(model)
         except LookupError:
             raise CommandError("Unknown model: {}".format(label))
     meta_values = meta.values()
     # Create revisions.
     using = using or router.db_for_write(Revision)
     with transaction.atomic(using=using):
         for model in self.get_models(options):
             # Check all models for empty revisions.
             if verbosity >= 1:
                 self.stdout.write("Creating revisions for {name}".format(
                     name=model._meta.verbose_name,
                 ))
             created_count = 0
             live_objs = _safe_subquery(
                 "exclude",
                 model._default_manager.using(model_db),
                 model._meta.pk.name,
                 Version.objects.using(using).get_for_model(
                     model,
                     model_db=model_db,
                 ),
                 "object_id",
             )
             # Save all the versions.
             ids = list(live_objs.values_list("pk", flat=True).order_by())
             total = len(ids)
             for i in range(0, total, batch_size):
                 chunked_ids = ids[i:i+batch_size]
                 objects = live_objs.in_bulk(chunked_ids)
                 for obj in objects.values():
                     with create_revision(using=using):
                         if meta:
                             for model, values in zip(meta_models, meta_values):
                                 add_meta(model, **values)
                         set_comment(comment)
                         add_to_revision(obj, model_db=model_db)
                     created_count += 1
                 reset_queries()
                 if verbosity >= 2:
                     self.stdout.write("- Created {created_count} / {total}".format(
                         created_count=created_count,
                         total=total,
                     ))
             # Print out a message, if feeling verbose.
             if verbosity >= 1:
                 self.stdout.write("- Created {total} / {total}".format(
                     total=total,
                 ))

 def _reversion_revisionform_view(self, request, version, template_name, extra_context=None):
     # Check that database transactions are supported.
     if not connection.features.uses_savepoints:
         raise ImproperlyConfigured("Cannot use VersionAdmin with a database that does not support savepoints.")
     # Run the view.
     try:
         with transaction.atomic(using=version.db):
             # Revert the revision.
             version.revision.revert(delete=True)
             # Run the normal changeform view.
             with self.create_revision(request):
                 response = self.changeform_view(request, version.object_id, request.path, extra_context)
                 # Decide on whether the keep the changes.
                 if request.method == "POST" and response.status_code == 302:
                     set_comment(_("Reverted to previous version, saved on %(datetime)s") % {
                         "datetime": localize(template_localtime(version.revision.date_created)),
                     })
                 else:
                     response.template_name = template_name  # Set the template name to the correct template.
                     response.render()  # Eagerly render the response, so it's using the latest version.
                     raise _RollBackRevisionView(response)  # Raise exception to undo the transaction and revision.
     except RevertError as ex:
         opts = self.model._meta
         messages.error(request, force_text(ex))
         return redirect("{}:{}_{}_changelist".format(self.admin_site.name, opts.app_label, opts.model_name))
     except _RollBackRevisionView as ex:
         return ex.response
     return response

 def get(self, request, attendance_id):
     a = get_object_or_404(Attendance,  pk=attendance_id)
     with transaction.atomic(), reversion.create_revision():
         a.rotate()
         reversion.set_user(request.user)
         reversion.set_comment("Rotating by %s" % request.user)
     return HttpResponseRedirect(reverse('training:course', args=[a.clazz.course.id]))

    def test_page_versions(self):
        self.client.login(username="admin", password="123")
        page = Page(name="Test Name", url="test-url", content="Content goes here")
        with reversion.create_revision():
            reversion.set_comment("initial")
            page.save()

        versions = reversion.get_for_object(page)
        self.assertEquals(len(versions), 1)
        self.assertEquals(versions[0].revision.comment, "initial")

        url = reverse("admin:page_page_change", args=[page.id])
        self.client.post(url, {"name": "2nd name", "url": "test-url", "content": "New content"})
        page = Page.objects.get(id=page.id)

        self.assertEquals(page.name, "2nd name")
        self.assertEquals(page.content, "New content")

        versions = map(lambda x: x, reversion.get_for_object(page))
        self.assertEquals(len(versions), 2)
        self.assertEquals(versions[0].revision.comment, "Changed name and content.")

        actual_initial = json.loads(versions[1].serialized_data)[0]
        self.assertEquals(actual_initial["fields"]["name"], "Test Name")
        self.assertEquals(actual_initial["fields"]["url"], "test-url")
        self.assertEquals(actual_initial["fields"]["content"], "Content goes here")

        actual_final = json.loads(versions[0].serialized_data)[0]
        self.assertEquals(actual_final["fields"]["name"], "2nd name")
        self.assertEquals(actual_final["fields"]["url"], "test-url")
        self.assertEquals(actual_final["fields"]["content"], "New content")

    def handle(self, *args, **options):
        reversion.set_comment('Updating actions.')

        action_names = settings.ACTIONS.keys()
        if options['action_name']:
            action_names = [name for name in action_names if name in options['action_name']]

        for name in action_names:
            self.stdout.write('Updating action {}...'.format(name), ending='')
            implementation = get_implementation(name)
            arguments_schema = get_arguments_schema(name)

            # Create a new action or update the existing one.
            try:
                action = Action.objects.get(name=name)
                should_update = (
                    action.implementation != implementation
                    or action.arguments_schema != arguments_schema
                )

                if should_update:
                    action.implementation = implementation
                    action.arguments_schema = arguments_schema
                    action.save()

            except Action.DoesNotExist:
                action = Action(
                    name=name,
                    implementation=implementation,
                    arguments_schema=arguments_schema
                )
                action.save()

            self.stdout.write('Done')

 def post(self, request, *args, **kwargs):
     if "room" in request.POST:
         if request.POST["room"] != "" and request.POST["room"] != 0:
             roomid = request.POST["room"][0]
             room = get_object_or_404(Room, pk=roomid)
         else:
             room = None
     else:
         room = None
     response = super(DeviceApiLend, self).post(request)
     if request.POST["device"] != "" and response.status_code == 201:
         device = Device.objects.get(pk=request.POST["device"])
         device.currentlending = self.object
         if room:
             device.room = room
             reversion.set_user(request.user)
             reversion.set_comment("Device marked as lend")
             try:
                 template = MailTemplate.objects.get(usage="room")
             except:
                 template = None
             if not template == None:
                 recipients = []
                 for recipient in template.default_recipients.all():
                     recipient = recipient.content_object
                     if isinstance(recipient, Group):
                         recipients += recipient.lageruser_set.all().values_list("email")[0]
                     else:
                         recipients.append(recipient.email)
                 template.send(self.request, recipients, {"device": device, "user": self.request.user})
         reversion.set_ignore_duplicates(True)
         device.save()
     return response

	def setUp(self):
		self.user = mommy.make(UserProfile, is_superuser=True)

		document = mommy.prepare(InformationDocument, text="text")
		with transaction.atomic(), revisions.create_revision():
				document.save()
				revisions.set_user(self.user)
				revisions.set_comment('test version')