Python utils.log_change函数代码示例

    def delete_membership(self, user):
        assert user is not None

        me = Membership.objects.select_for_update().filter(pk=self.pk)[0]
        if me.status == STATUS_DELETED:
            raise MembershipAlreadyStatus("Membership already deleted")
        elif me.status == STATUS_NEW:
            # must be imported here due to cyclic imports
            from services.models import Service
            logger.info("Deleting services of the membership application %s." % repr(self))
            for service in Service.objects.filter(owner=self):
                service.delete()
            logger.info("Deleting aliases of the membership application %s." % repr(self))
            for alias in self.alias_set.all():
                alias.delete()
        else:
            logger.info("Not deleting services of membership %s." % repr(self))
            logger.info("Expiring aliases of membership %s." % repr(self))
            for alias in self.alias_set.all():
                alias.expire()

        contacts = [self.person, self.billing_contact, self.tech_contact,
                    self.organization]

        self._change_status(new_status=STATUS_DELETED)

        for contact in contacts:
            if contact is not None:
                contact.delete_if_no_references(user)
        log_change(self, user, change_message="Deleted")

def contact_edit(request, id, template_name='membership/entity_edit.html'):
    contact = get_object_or_404(Contact, id=id)

    # XXX: I hate this. Wasn't there a shortcut for creating a form from instance?
    class Form(ModelForm):
        class Meta:
            model = Contact

    before = contact.__dict__.copy() # Otherwise save() (or valid?) will change the dict, needs to be here
    if request.method == 'POST':
        if not request.user.has_perm('membership.manage_members'):
            messages.error(request, unicode(_("You are not authorized to modify memberships.")))
            return redirect('contact_edit', id)

        form = Form(request.POST, instance=contact)

        if form.is_valid():
            form.save()
            after = contact.__dict__
            log_change(contact, request.user, before, after)
            messages.success(request, unicode(_("Changes to contact %s saved.") % contact))
            return redirect('contact_edit', id) # form stays as POST otherwise if someone refreshes
        else:
            messages.error(request, unicode(_("Changes to contact %s not saved.") % contact))
    else:
        form =  Form(instance=contact)
        message = ""
    logentries = bake_log_entries(contact.logs.all())
    return render_to_response(template_name, {'form': form, 'contact': contact,
        'logentries': logentries},
        context_instance=RequestContext(request))

def bill_edit(request, id, template_name='membership/entity_edit.html'):
    bill = get_object_or_404(Bill, id=id)

    class Form(ModelForm):
        class Meta:
            model = Bill
            exclude = ('billingcycle', 'reminder_count')

    before = bill.__dict__.copy() # Otherwise save() (or valid?) will change the dict, needs to be here
    if request.method == 'POST':
        form = Form(request.POST, instance=bill)
        if form.is_valid():
            form.save()
            after = bill.__dict__
            log_change(bill, request.user, before, after)
            messages.success(request, unicode(_("Changes to bill %s saved.") % bill))
            return redirect('bill_edit', id) # form stays as POST otherwise if someone refreshes
        else:
            messages.error(request, unicode(_("Changes to bill %s not saved.") % bill))
    else:
        form =  Form(instance=bill)
    logentries = bake_log_entries(bill.logs.all())
    return render_to_response(template_name, {'form': form, 'bill': bill,
        'logentries': logentries},
        context_instance=RequestContext(request))

    def delete_membership(self, user):
        if self.status == 'D':
            raise MembershipOperationError("A deleted membership can't be deleted.")
        elif self.status == 'N':
            # must be imported here due to cyclic imports
            from services.models import Service
            logger.info("Deleting services of the membership application %s." % repr(self))
            for service in Service.objects.filter(owner=self):
                service.delete()
            logger.info("Deleting aliases of the membership application %s." % repr(self))
            for alias in self.alias_set.all():
                alias.delete()
        else:
            logger.info("Not deleting services of membership %s." % repr(self))
            logger.info("Expiring aliases of membership %s." % repr(self))
            for alias in self.alias_set.all():
                alias.expire()

        self.status = 'D'
        contacts = [self.person, self.billing_contact, self.tech_contact,
                    self.organization]
        self.person = None
        self.billing_contact = None
        self.tech_contact = None
        self.organization = None
        self.save()
        for contact in contacts:
            if contact != None:
                contact.delete_if_no_references(user)
        log_change(self, user, change_message="Deleted")

def membership_convert_to_organization(request, id, template_name='membership/membership_convert_to_organization.html'):
    membership = get_object_or_404(Membership, id=id)
    class ConfirmForm(Form):
        confirm = BooleanField(label=_('To confirm conversion, you must check this box:'),
                               required=True)

    if request.method == 'POST':
        form = ConfirmForm(request.POST)
        if form.is_valid():
            f = form.cleaned_data
            membership.type = 'O'
            contact = membership.person
            membership.person = None
            membership.organization = contact
            membership.save()
            log_change(membership, request.user, change_message="Converted to an organization")
            messages.success(request, unicode(_('Member %s successfully converted to an organization.') % membership))
            logger.info("User %s converted member %s to an organization." % (request.user.username, membership))
            return redirect('membership_edit', membership.id)
    else:
        form = ConfirmForm()

    return render_to_response(template_name,
                              {'form': form,
                               'membership': membership },
                              context_instance=RequestContext(request))

 def detach_from_cycle(self, user=None):
     if not self.billingcycle:
         return
     cycle = self.billingcycle
     logger.info("Payment %s detached from cycle %s." % (repr(self),
         repr(cycle)))
     self.billingcycle = None
     self.save()
     if user:
         log_change(self, user, change_message="Detached from billing cycle")
     cycle.update_is_paid()

    def preapprove(self, user):
        assert user is not None
        self._change_status(new_status=STATUS_PREAPPROVED)
        log_change(self, user, change_message="Preapproved")

        ret_items = send_preapprove_email.send_robust(self.__class__, instance=self, user=user)
        for item in ret_items:
            sender, error = item
            if error is not None:
                raise error
        logger.info("Membership {membership} preapproved.".format(membership=self))

 def approve(self, user):
     if self.status != 'P':
         raise MembershipOperationError("A membership from other state than preapproved can't be approved.")
     if user == None:
         msg = "Membership.approve() needs user object as a parameter"
         logger.critical("%s" % traceback.format_exc())
         logger.critical(msg)
         raise MembershipOperationError(msg)
     self.status = 'A'
     self.approved = datetime.now()
     self.save()
     log_change(self, user, change_message="Approved")

 def send_duplicate_payment_notice(self, user, **kwargs):
     if not user:
         raise Exception('send_duplicate_payment_notice user objects as parameter')
     billingcycle = BillingCycle.objects.get(reference_number=self.reference_number)
     if billingcycle.sum > 0:
         ret_items = send_duplicate_payment_notice.send_robust(self.__class__, instance=self, user=user, billingcycle=billingcycle)
         for item in ret_items:
             sender, error = item
             if error != None:
                 logger.error("%s" % traceback.format_exc())
                 raise error
         log_change(self, user, change_message="Duplicate payment notice sent")

    def attach_to_cycle(self, cycle, user=None):
        if self.billingcycle:
            raise PaymentAttachedError("Payment %s already attached to BillingCycle %s." % (repr(self), repr(cycle)))

        self.billingcycle = cycle
        self.ignore = False
        self.save()
        logger.info("Payment %s attached to member %s cycle %s." % (repr(self),
            cycle.membership.id, repr(cycle)))
        if user:
            log_change(self, user, change_message="Attached to billing cycle")
        cycle.update_is_paid(user=user)

    def cancel_dissociation_request(self, user):
        if self.status != 'S':
            raise MembershipOperationError("A membership has to be in dissociation requested state for the state to be canceled.")
        if user == None:
            msg = "Membership.cancel_dissociation_request() needs user object as a parameter"
            logger.critical("%s" % traceback.format_exc())
            logger.critical(msg)
            raise MembershipOperationError(msg)

        self.status = 'A'
        self.dissociation_requested = None
        self.save()
        log_change(self, user, change_message="Dissociation request state reverted")

    def dissociate(self, user):
        if self.status not in ('A', 'S'):
            raise MembershipOperationError("A membership from other state than dissociation requested or approved can't be dissociated.")
        if user == None:
            msg = "Membership.dissociate() needs user object as a parameter"
            logger.critical("%s" % traceback.format_exc())
            logger.critical(msg)
            raise MembershipOperationError(msg)

        self.status = 'I'
        self.dissociated = datetime.now()
        self.save()
        log_change(self, user, change_message="Dissociated")

    def update_is_paid(self, user=None):
        was_paid = self.is_paid
        total_paid = self.amount_paid()
        if not was_paid and total_paid >= self.sum:
            self.is_paid = True
            self.save()
            logger.info("BillingCycle %s marked as paid, total paid: %.2f." % (
                repr(self), total_paid))
        elif was_paid and total_paid < self.sum:
            self.is_paid = False
            self.save()
            logger.info("BillingCycle %s marked as unpaid, total paid: %.2f." % (
                repr(self), total_paid))

        if user:
            log_change(self, user, change_message="Marked as paid")

    def preapprove(self, user):
        if self.status != 'N':
            raise MembershipOperationError("A membership from other state than new can't be preapproved.")
        if user == None:
            msg = "Membership.preapprove() needs user object as a parameter"
            logger.critical("%s" % traceback.format_exc())
            logger.critical(msg)
            raise MembershipOperationError(msg)
        self.status = 'P'
        self.save()
        log_change(self, user, change_message="Preapproved")

        ret_items = send_preapprove_email.send_robust(self.__class__, instance=self, user=user)
        for item in ret_items:
            sender, error = item
            if error != None:
                raise error
        logger.info("Membership %s preapproved." % self)

def billingcycle_edit(request, id, template_name='membership/entity_edit.html'):
    cycle = get_object_or_404(BillingCycle, id=id)

    class Form(ModelForm):
        is_paid_forced = False
        class Meta:
            model = BillingCycle
            exclude = ('membership', 'start', 'end', 'sum', 'reference_number')

        def disable_fields(self):
            self.fields['is_paid'].required = False
            if cycle.amount_paid() >= cycle.sum and cycle.is_paid:
                self.fields['is_paid'].widget.attrs['disabled'] = 'disabled'
                self.is_paid_forced = True

        def clean_is_paid(self):
            if self.is_paid_forced:
                return cycle.is_paid
            else:
                return self.cleaned_data['is_paid']

    before = cycle.__dict__.copy() # Otherwise save() (or valid?) will change the dict, needs to be here
    if request.method == 'POST':
        form = Form(request.POST, instance=cycle)
        form.disable_fields()
        if form.is_valid():
            form.save()
            after = cycle.__dict__
            log_change(cycle, request.user, before, after)
            messages.success(request, unicode(_("Changes to billing cycle %s saved.") % cycle))
            return redirect('billingcycle_edit', id) # form stays as POST otherwise if someone refreshes
        else:
            messages.error(request, unicode(_("Changes to bill %s not saved.") % cycle))
    else:
        form =  Form(instance=cycle)
        form.disable_fields()
    logentries = bake_log_entries(cycle.logs.all())
    return render_to_response(template_name, {'form': form, 'cycle': cycle,
        'logentries': logentries},
        context_instance=RequestContext(request))