def setup_revision(user, status):
    if user is not None:
        updater = django.contrib.auth.models.User.objects.get(username=user)
    else:
        updater = None
    reversion.set_user(updater)
    reversion.set_comment("Set status to %s" % (status.name, ))

    def form_valid(self, form):
        with transaction.atomic(), reversion.create_revision():
            self.make_exam(form)
            self.exam.save()
            reversion.set_user(self.exam.editoritem.author)

        return redirect(self.get_success_url())

def handle_edit(request, document):
    context = RequestContext(request)
    if request.method == "POST":
        form = TextForm(request.POST)
        if form.is_valid():
            cleaned_data = form.cleaned_data

            document.text = cleaned_data["text"]
            document.type = cleaned_data["type"]
            document.author = request.user
            if document.title != cleaned_data["title"]:
                # if the user changed the title we have to delete the old version
                # because the url_title will change, too...
                document.title = cleaned_data["title"]
                new_document = Document(
                    title=document.title, text=document.text, type=document.type, author=document.author
                )
                document.delete()
                document = new_document

                # save the document and also save the user and the comment the user added
            with transaction.atomic(), reversion.create_revision():
                document.save()
                reversion.set_user(request.user)
                reversion.set_comment(cleaned_data["comment"])
            raise FormValidException
        else:
            context["errors"] = form.errors
            context["form"] = form
    else:
        form_data = {"title": document.title, "text": document.text, "type": document.type}
        context["form"] = TextForm(form_data)

    context["document"] = document
    return context

    def create_aggregated(cls, period, entity, author, *args, **kwargs):
        agg_report = cls.start(period, entity, author, \
               type=Report.TYPE_AGGREGATED, *args, **kwargs)

        sources = ProvidedServicesReport.validated.filter(period=period, \
            entity__in=entity.get_children())

        if sources.count() == 0:
            agg_report.fill_blank()
            agg_report.save()

        for report in sources:
            for key, value in report.to_dict().items():
                pv = getattr(agg_report, key)
                if not pv:
                    nv = value
                elif pv in (cls.YES, cls.NO):
                    if pv == cls.YES:
                        nv = pv
                    else:
                        nv = value
                else:
                    nv = pv + value
                setattr(agg_report, key, nv)
            agg_report.save()

        for report in sources:
            agg_report.sources.add(report)

        with reversion.create_revision():
            agg_report.save()
            reversion.set_user(author.user)

        return agg_report

    def save(self, *args, **kwargs):
        author = None
        if 'author' in kwargs.keys():
            author = kwargs.pop('author')

        if 'at' in kwargs.keys():
            at = kwargs.pop('at')
        else:
            at = timezone.now()

        create_revision = False

        try:
            last_version = reversion.get_unique_for_object(self)[0].field_dict
        except (IndexError, AttributeError, TypeError):
            create_revision = True
            last_version = {}

        for field in ('role', 'location', 'is_active'):
            if field == 'is_active':
                current_value = getattr(self, field, False)
            else:
                current_value = getattr(getattr(self, field), 'slug')
            if last_version.get(field, current_value) != current_value:
                create_revision = True
                break

        if create_revision:
            self.access_since = at
            with reversion.create_revision():
                super(Provider, self).save(*args, **kwargs)
                reversion.set_user(author)
        else:
            super(Provider, self).save(*args, **kwargs)

def giro_status_ventar(modeladmin, request, queryset):
    with reversion.create_revision():
        for g in queryset:
            g.status='V'
            g.save()
        reversion.set_comment("Giro status ventar admin action")
        reversion.set_user(request.user)

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 edit_pii(request, id):
    name = _("Birtday, SSN, and ITIN")
    e = get_enumeration_user_manages_or_404(Enumeration, id, request.user)
    
    #Do not let this function work if the PII is already locked.
    if e.pii_lock:
        raise Http404()
    
    if request.method == 'POST':
        form = IndividualPIIForm(request.POST, instance=e)
        if form.is_valid():
            e = form.save(commit=False)
            e.last_updated_ip=request.META['REMOTE_ADDR']
            e.status="E"
            e.save()
            reversion.set_user(request.user)
            reversion.set_comment("Edit personal PII.")
            return HttpResponseRedirect(reverse('edit_enumeration', args=(id,)))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)
             
    #this is a GET
    context= {'name':name,
              'form': IndividualPIIForm(instance=e)}
    return render(request, 'generic/bootstrapform.html', context)

def reactivate(request, id):
    name = _("Reactivate a Deactivated Enumeration")
    e = get_object_or_404(Enumeration, id=id)
    if e.status == "D":
        
        
        #Remove all gatekeeper errors.
        GateKeeperError.objects.filter(enumeration=e).delete()
        
        # Status A
        e.status = "A"
        e.last_updated_ip=request.META['REMOTE_ADDR']
        e.enumerated_by = request.user
        e.save()
        msg = "This record has been reactivated by %s" % (request.user)
        
        
        Event.objects.create(enumeration=e, event_type="REACTIVATION",
                             note= msg,
                             details = msg,
                             subject=REACTIVATED_SUBJECT,
                             body = REACTIVATED_BODY)
        reversion.set_user(request.user)
        reversion.set_comment(msg)
        
        
        messages.success(request, msg)
    elif e.status == "A":
        messages.info(request, "This record was not deactivated. Nothing was done.")
    else:
        messages.info(request, "This record was not deactivated. Nothing was done.")
    return HttpResponseRedirect(reverse('report_index'))

def military_address(request, address_id, enumeration_id):
    a = Address.objects.get(id=address_id)
    e = Enumeration.objects.get(id=enumeration_id)
    name = "Edit Military %s for %s" % (a.get_address_purpose_display(),
                                                e.name())
    e = get_enumeration_user_manages_or_404(Enumeration, enumeration_id,
                                            request.user)
    address = Address.objects.get(id=address_id)
    if request.method == 'POST':
        form = MilitaryAddressForm(request.POST, instance=address)
        if form.is_valid():
            a = form.save(commit=False)
            a.last_updated_ip=request.META['REMOTE_ADDR']
            a.save()
            e.status="E"
            e.save()
            reversion.set_user(request.user)
            reversion.set_comment("Create/Edit Military Address")
            return HttpResponseRedirect(reverse('edit_enumeration',
                                    args=(enumeration_id, )))

        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)

    #this is a GET
    context= {'name':name,
              'form': MilitaryAddressForm(instance=address)}
    return render(request, 'generic/bootstrapform.html', context)

def self_take_over(request):
    
    name = "Take control of your individual provider identifer"
    if request.method == 'POST':
        form = SelfTakeOverForm(request.POST)
        if form.is_valid():
            e = form.get_enumeration()
            
            #Give ownership to the individual
            e.managers.add(request.user)
            #make sure this user is also the surrogate
            s = Surrogate.objects.get(user=request.user)
            s.save()
            s.enumerations.add(e)
            s.save()
            reversion.set_user(request.user)
            reversion.set_comment("Self Take Over")
            messages.success(request,_("You are now in control of your own record."))
            return HttpResponseRedirect(reverse('edit_enumeration', args=(e.id,)))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)
    
    
    
    
    #this is a GET
    context= {'name':name,
              'form': SelfTakeOverForm()}
    return render(request, 'generic/bootstrapform.html', context)

def add_other_taxonomies(request, enumeration_id):
    name = _("Add Other Taxonomies")
    e = get_enumeration_user_manages_or_404(Enumeration, enumeration_id,
                                            request.user)

    if request.method == 'POST':
        form = OtherTaxonomyForm(request.POST, instance=e)
        if form.is_valid():
            e = form.save(commit=False)
            e.last_updated_ip=request.META['REMOTE_ADDR']
            e.save()
            form.save()
            form.save_m2m()
            reversion.set_user(request.user)
            reversion.set_comment("Added/Changed other taxonomies.")
            messages.success(request,_("Other taxonomies were added/changed."))
            return HttpResponseRedirect(reverse('edit_enumeration',
                                                args=(enumeration_id,)))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)
    #this is a GET
    context= {'name':name,
              'form': OtherTaxonomyForm(instance=e)}
    return render(request, 'generic/bootstrapform.html', context)

def edit_item(request,iid,*args,**kwargs):
    item = get_object_or_404(MDR._concept,pk=iid).item
    if not user_can_edit(request.user, item):
        if request.user.is_anonymous():
            return redirect(reverse('django.contrib.auth.views.login')+'?next=%s' % request.path)
        else:
            raise PermissionDenied

    base_form = MDRForms.wizards.subclassed_edit_modelform(item.__class__)
    if request.method == 'POST': # If the form has been submitted...
        form = base_form(request.POST,instance=item,user=request.user)

        if form.is_valid():
            with transaction.atomic(), reversion.create_revision():
                change_comments = form.data.get('change_comments',None)
                item = form.save()
                reversion.set_user(request.user)
                if not change_comments:
                    change_comments = construct_change_message(request,form,None)
                reversion.set_comment(change_comments)
                return HttpResponseRedirect(url_slugify_concept(item))
    else:
        form = base_form(instance=item,user=request.user)
    return render(request,"aristotle_mdr/actions/advanced_editor.html",
            {"item":item,
             "form":form,
                }
            )

def submit(request, form):
    """
    Ingest a piece of text into the database
    """

    args = {'user': request.user, 'form': form,
            'authenticated': request.user.is_authenticated()}

    (text, sentences) = parse_text_from_request(request)
    if None in (text, sentences):
        return _render(request, 'invalid.html', args)

    source_text = source_text_from_form(form)
    if source_text.is_dirty():
        source_text.save()

    volume = volume_from_form(source_text, form, text)
    if volume.is_dirty():
        volume.save()

    volume.sourcetextsentence_set.all().delete()
    with reversion.create_revision():
        reversion.set_user(request.user)
        for sent in sentences:
            (text, begin, end) = sent
            SourceTextSentence.objects.create(volume=volume, sentence=text, start_line=begin, end_line=end)

    return _render(request, 'submitted.html', args)

    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 reject(request, id):
    name = _("Activate an Enumeration")
    e = get_object_or_404(Enumeration, id=id)
    if e.status == "P":
        
        
        #Remove all gatekeeper errors.
        GateKeeperError.objects.filter(enumeration=e).delete()
        
        e.status = "R"
        e.last_updated_ip=request.META['REMOTE_ADDR']
        e.enumerated_by = request.user
        e.save()
        msg = "This record has been rejected by %s" % (request.user)
        Event.objects.create(enumeration=e, event_type="REJECTION", note= msg,
                             details=msg,
                             body = RECJECTION_BODY,
                             subject = REJECTION_SUBJECT)

        reversion.set_user(request.user)
        comment = "Application rejected"
        reversion.set_comment(comment)
        messages.success(request, "This record has been successfully been rejected.")
    else:
        messages.info(request, "This record was not pending so nothing was done. The record was not rejected.")
    return HttpResponseRedirect(reverse('report_index'))

def deactivate(request, id):
    name = _("Deactivate")
    e = get_object_or_404(Enumeration, id=id)
    
    #If status is already deactivated then redirect.
    if e.status == "D":
        messages.info(request, "This record was not deactive so nothing was done. The record was not rejected.")
        return HttpResponseRedirect(reverse('report_index'))
    
    if request.method == 'POST':
        form = DeactivationForm(request.POST, instance=e)
        if form.is_valid():
            e = form.save(commit=False)
            e.last_updated_ip=request.META['REMOTE_ADDR']
            e.status="D"
            e.deactivation_date = datetime.date.today()
            e.save()
            msg = "Enumeration %s has been deactivated by %s." % (e.number, request.user)
            Event.objects.create(enumeration=e, event_type="DEACTIVATION", note= msg,
                                 details=msg, body = DEACTIVATED_BODY,
                                 subject = DEACTIVATED_SUBJECT)
            reversion.set_user(request.user)
            comment = "Deactivation of %s" % (e.number)
            reversion.set_comment(comment)
            messages.success(request, msg)
            return HttpResponseRedirect(reverse('report_index'))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)
    #this is a GET
    context= {'name':name,
              'form': DeactivationForm(instance=e)}
    return render(request, 'generic/bootstrapform.html', context)

 def post(self, request, *args, **kwargs):
     data = request.POST.dict().copy()
     try:
         self.model, editable_fields = self.get_editable_model_and_fields(data)
     except NoPermission as e:
         return HttpResponseForbidden(
             json.dumps(dict(message=e.message)),
             content_type='application/json')
     if 'slugfield' in data:
         self.slug_field = data.pop('slugfield')
     self.kwargs.update(data)
     obj = self.get_object()
     for fieldname in editable_fields:
         if fieldname in data:
             obj.__setattr__(fieldname, data.pop(fieldname))
     if REVERSION_INSTALLED:
         with reversion.create_revision():
             obj.save()
             reversion.set_user(request.user)
             reversion.set_comment("Contenteditable")
     else:
         obj.save()  # TODO only save if changed
     return HttpResponse(
         json.dumps(dict(message='ok')),
         content_type='application/json')

def edit_enhanced_enumeration(request, id):
    name = _("Edit Enhanced Profile Information")
    e = get_enumeration_user_manages_or_404(Enumeration, id, request.user)


    if request.method == 'POST':
        form = EnumerationEnhancementForm(request.POST, request.FILES, instance=e)
        if form.is_valid():
            e = form.save(commit=False)
            e.last_updated_ip=request.META['REMOTE_ADDR']
            e.status="E"
            e.save()
            reversion.set_user(request.user)
            reversion.set_comment("Edit Enhancements.")
            
            
            return HttpResponseRedirect(reverse('edit_enumeration',
                                                   args=(e.id,)))
        else:
            #The form is invalid
             messages.error(request,_("Please correct the errors in the form."))
             context = {'form': form,'name':name,}
             return render(request, 'generic/bootstrapform.html', context)
    #this is a GET
    context= {'name':name,
              'form': EnumerationEnhancementForm(instance=e)}
    return render(request, 'generic/bootstrapform.html', context)

 def patch(self, request, *args, **kwargs):
     """ custom patch method to support django-reversion """
     with reversion.create_revision():
         reversion.set_user(request.user)
         reversion.set_comment('changed through the RESTful API from ip %s' % request.META['REMOTE_ADDR'])
         kwargs['partial'] = True
         return self.update(request, *args, **kwargs)