def create_or_update(sender, **kwargs):
    """
    Create or update an Activity Monitor item from some instance.
    """
    now = datetime.datetime.now()

    # I can't explain why this import fails unless it's here.
    from activity_monitor.models import Activity
    instance = kwargs['instance']

    # Find this object's content type and model class.
    instance_content_type = ContentType.objects.get_for_model(sender)
    instance_model        = sender
    content_object        = instance_model.objects.get(id=instance.id)

    # check to see if the activity already exists. Will need later.
    try:
        activity = Activity.objects.get(content_type=instance_content_type, object_id=content_object.id)
    except:
        activity = None

    # We now know the content type, the model (sender), content type and content object.
    # We need to loop through ACTIVITY_MONITOR_MODELS in settings for other fields
    for activity_setting in settings.ACTIVITY_MONITOR_MODELS:
        this_app_label    = activity_setting['model'].split('.')[0]
        this_model_label  = activity_setting['model'].split('.')[1]
        this_content_type = ContentType.objects.get(app_label=this_app_label, model=this_model_label)

        if this_content_type == instance_content_type:
            # first, check to see if we even WANT to register this activity.
            # use the boolean 'check' field. Also, delete if needed.
            if 'check' in activity_setting:
                if getattr(instance, activity_setting['check']) is False:
                    if activity:
                        activity.delete()
                    return

            # does it use the default manager (objects) or a custom manager?
            try:
                manager = activity_setting['manager']
            except:
                manager  = 'objects'

            # what field denotes the activity time? created is default
            try:
                timestamp = getattr(instance, activity_setting['date_field'])
            except:
                timestamp = getattr(instance, 'created')

            # if the given time stamp is a daterather than datetime type,
            # normalize it out to a datetime
            if type(timestamp) == type(now):
                clean_timestamp = timestamp
            else:
                clean_timestamp = datetime.datetime.combine(timestamp, datetime.time())

           # Find a valid user object
            if 'user_field' in activity_setting:  # pull the user object from instance using user_field
                user = getattr(instance, activity_setting['user_field'])
            elif this_model_label == 'user' or this_model_label == 'profile':  # this IS auth.user or a Django 1.5 custom user
                user = instance
            else:  # we didn't specify a user, so it must be instance.user
                user = instance.user

            # BAIL-OUT CHECKS
            # Determine all the reasons we would want to bail out.
            # Make sure it's not a future item, like a future-published blog entry.
            if clean_timestamp > now:
                return
            # or some really old content that was just re-saved for some reason
            if clean_timestamp < (now - datetime.timedelta(days=3)):
                return
            # or there's not a user object
            if not user:
                return
            # or the user is god or staff, and we're filtering out, don't add to monitor
            if user.is_superuser and 'filter_superuser' in activity_setting:
                return
            if user.is_staff and 'filter_staff' in activity_setting:
                return

            # build a default string representation
            # note that each activity can get back to the object via get_absolute_url()
            verb = activity_setting.get('verb', None)
            override_string = activity_setting.get('override_string', None)


    # MANAGER CHECK
    # Make sure the item "should" be registered, based on the manager argument.
    # If InstanceModel.manager.all() includes this item, then register. Otherwise, return.
    # Also, check to see if it should be deleted.
    try:
        getattr(instance_model, manager).get(pk=instance.pk)
    except instance_model.DoesNotExist:
        try:
            activity.delete()
            return
        except Activity.DoesNotExist:
            return

    if user and clean_timestamp and instance:
        if not activity:  # If the activity didn't already exist, create it.
            activity = Activity(
                actor          = user,
                content_type   = instance_content_type,
                object_id      = content_object.id,
                content_object = content_object,
                timestamp      = clean_timestamp,
                verb = verb,
                override_string = override_string,
            )
            activity.save()
        return activity
Create or update an Activity Monitor item from some instance.