def attachment(request, object_id, update_id=None):
    dajax = Dajax()

    try:

        if object_id:
            attachments = Attachment.objects.filter(
                attached_object__id=object_id)
            template = 'core/tags/attachments_block'

            object_markup = render_to_string(template,
                                             {'object_id': object_id,
                                                 'attachments': attachments},
                                             context_instance=RequestContext(
                                                 request),
                                             response_format='html')

            dajax.add_data(
                {'target': 'div.attachment-block[object="%s"]' % object_id, 'content': object_markup}, 'treeio.add_data')

        if update_id:
            attachments = Attachment.objects.filter(
                attached_record__id=update_id)
            template = 'core/tags/attachments_record_block'
            update_markup = render_to_string(template,
                                             {'update_id': update_id,
                                                 'attachments': attachments},
                                             context_instance=RequestContext(
                                                 request),
                                             response_format='html')
            dajax.add_data(
                {'target': 'div.attachment-record-block[object="%s"]' % update_id, 'content': update_markup}, 'treeio.add_data')

    except Exception, e:
        print e

def permission_block(context, object):
    "Block with objects permissions"
    request = context['request']
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']

    response_format_tags = response_format
    if 'response_format_tags' in context:
        response_format_tags = context['response_format_tags']

    if 'permission' in request.GET:
        if request.user.get_profile().has_permission(object, mode='w'):
            if request.POST:
                if 'cancel' in request.POST:
                    request.redirect = request.path
                    return Markup(render_to_string('core/tags/permission_block',
                                                   {'object': object,
                                                       'path': request.path},
                                                   context_instance=RequestContext(
                                                       request),
                                                   response_format=response_format))
                form = PermissionForm(request.POST, instance=object)
                if form.is_valid():
                    form.save()
                    request.redirect = request.path
                    return Markup(render_to_string('core/tags/permission_block',
                                                   {'object': object,
                                                       'path': request.path},
                                                   context_instance=RequestContext(
                                                       request),
                                                   response_format=response_format))
            else:
                form = PermissionForm(instance=object)

            context = {'object': object, 'path': request.path, 'form': form}

            if 'ajax' in response_format_tags:
                context = converter.preprocess_context(context)

            return Markup(render_to_string('core/tags/permission_block_edit',
                                           context,
                                           context_instance=RequestContext(
                                               request),
                                           response_format=response_format))

    return Markup(render_to_string('core/tags/permission_block',
                                   {'object': object, 'path': request.path},
                                   context_instance=RequestContext(request),
                                   response_format=response_format))

def icon_line(context, user=None, size=25):
    """
    Print a line with a certain amount off achievement-icons.

    Arguments:
    context -- the current Context object, supplied by the decorator
    user -- which user, defaults to the active account
    size -- how many icons should be displayed
    """
    request = context["request"]
    if not user:
        user = request.user

    response_format = "html"
    if "response_format" in context:
        response_format = context["response_format"]

    achievements = user.achievements.all()[:size]

    return Markup(
        render_to_string(
            "achievements/tags/icon_line",
            {"achievements": achievements},
            context_instance=RequestContext(request),
            response_format=response_format,
        )
    )

def messaging_unread(context):
    "Print a number of unread messages"
    
    request = context['request']
    
    user = None
    if request.user.username:
        try: 
            user = request.user.get_profile()
        except Exception:
            pass
    
    unread = 0
    messaging = None
    if user:
        modules = user.get_perspective().get_modules()
        messaging = modules.filter(name='treeio.messaging')
        if messaging:
            unread = Object.filter_permitted(user, 
                                             Message.objects.filter(reply_to__isnull=True).exclude(read_by=user)).count()
        
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('messaging/tags/unread',
                               {'messaging': messaging, 'unread': unread},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def logo_block_container(context):
    "Returns logo_block_container"

    # request = context['request']
    response_format = "html"

    return Markup(render_to_string("core/tags/logo_block_container", response_format=response_format))

def user_block(context):
    "User block"
    request = context['request']
    user = None
    if request.user.username:
        try:
            user = request.user.get_profile()
        except Exception:
            pass

    modules = user.get_perspective().get_modules()

    account = modules.filter(name='treeio.account')

    admin = modules.filter(name='treeio.core')
    if admin:
        admin = admin[0]

    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']

    trial = False
    if getattr(settings, 'HARDTREE_SUBSCRIPTION_USER_LIMIT') == 3:
        trial = True

    active = context.get('active', None)

    return Markup(render_to_string('core/tags/user_block',
                  {'user': user,
                   'account': account,
                   'admin': admin,
                   'active': active,
                   'trial': trial},
                  response_format=response_format))

def attachments(context, object=None):
    "Attachments for an object or update record"

    request = context['request']

    profile = request.user.get_profile()

    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']

    update = isinstance(object,UpdateRecord)

    if not update:
        attachments = Attachment.objects.filter(attached_object=object)
        if profile.has_permission(object, mode='w'):
            template = 'core/tags/attachments'
        else:
            template = 'core/tags/attachments_block'

    else:
        attachments = Attachment.objects.filter(attached_record=object)
        if profile == object.author:
            template = 'core/tags/attachments_record'
        else:
            template = 'core/tags/attachments_record_block'

    return Markup(render_to_string(template,
                                   {'object': object,
                                    'attachments': attachments,
                                    },
                                   context_instance=RequestContext(request),
                                   response_format=response_format))

def core_watchlist(context, objects=None, skip_group=False, paginate=False):
    "Print a list of objects a user is subscribed to"
    
    request = context['request']
    profile = request.user.get_profile()
        
    if not objects:
        objects = profile.subscriptions.all()
    
    if 'unsubscribe' in request.GET:
        for object in objects.filter(pk=request.GET.get('unsubscribe')):
            object.subscribers.remove(profile)
        objects = profile.subscriptions.all()
    
    pathurl = request.path + '?'
    if request.GET:
        params = request.GET.copy()
        if 'unsubscribe' in params:
            del params['unsubscribe']
        pathurl += urllib.urlencode(params) + '&'
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('core/tags/watchlist',
                               {'objects': objects,
                                'skip_group': skip_group,
                                'dopaginate': paginate,
                                'pathurl': pathurl},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def email_caller_on_new_ticket(sender, instance, created, **kwargs):
    "When a new ticket is created send an email to the caller"
    if created:
        send_email_to_caller = False
        try:
            conf = ModuleSetting.get_for_module("treeio.services", "send_email_to_caller")[0]
            send_email_to_caller = conf.value
        except:
            send_email_to_caller = getattr(settings, "HARDTREE_SEND_EMAIL_TO_CALLER", True)

        if send_email_to_caller:
            # don't send email to yourself
            creator_contact = None
            if instance.creator:
                creator_contact = instance.creator.get_contact()

            if instance.caller and instance.caller != creator_contact:
                if not instance.reference:
                    if instance.queue:
                        instance.reference = instance.queue.ticket_code + str(instance.id)
                    else:
                        instance.reference = str(instance.id)
                    instance.save()
                subject = "[#%s] %s" % (instance.reference, instance.name)

                # Construct context and render to html, body
                context = {"ticket": instance}
                try:
                    conf = ModuleSetting.get_for_module("treeio.services", "send_email_template")[0]
                    send_email_template = conf.value
                    html = render_string_template(send_email_template, context)
                except Exception, e:
                    html = render_to_string("services/emails/notify_caller", context, response_format="html")
                body = strip_tags(html)

                if instance.queue and instance.queue.message_stream:
                    stream = instance.queue.message_stream
                    if stream.outgoing_server_name:
                        try:
                            caller_email = instance.caller.get_email()
                            if caller_email:
                                toaddr = caller_email
                                ssl = False
                                if stream.outgoing_server_type == "SMTP-SSL":
                                    ssl = True
                                email = BaseEmail(
                                    stream.outgoing_server_name,
                                    stream.outgoing_server_username,
                                    stream.outgoing_password,
                                    stream.outgoing_email,
                                    toaddr,
                                    subject,
                                    body,
                                    html=html,
                                    ssl=ssl,
                                )
                                email.process_email()
                        except:
                            pass

def demo_user(context):
    "Print demo block if demo"

    response_format = 'html'
    
    demo = getattr(settings, 'HARDTREE_DEMO_MODE', False)
        
    return Markup(render_to_string('core/tags/demo_user',
                  {'demo': demo},
                  response_format=response_format))

def object_tree_path(context, object, skipself=False):
    "Object tree path"
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
        
    path = object.get_tree_path(skipself)
        
    return Markup(render_to_string('core/tags/object_tree_path',
                                   {'path': path, 'skipself': skipself},
                                   response_format=response_format))

def projects_time_slot_list(context, time_slots, no_dates=False):
    "Print a list of time slots"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('projects/tags/time_slot_list',
                               {'time_slots': time_slots, 'no_dates': no_dates},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def finance_liability_list(context, liabilities, skip_group=False):
    "Print a list of orders"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('finance/tags/liability_list',
                               {'liabilities': liabilities, 'skip_group': skip_group},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def documents_weblink_list(context, links, skip_group=False):
    "Print a list of links"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('documents/tags/weblink_list',
                               {'links': links, 'skip_group': skip_group},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def identities_group_list(context, groups, skip_group=False):
    "Print a list of groups"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('identities/tags/group_list',
                               {'groups': groups, 'skip_group': skip_group},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def services_queue_list(context, queues, skip_group=False):
    "Print a list of queues"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('services/tags/queue_list',
                               {'queues': queues, 'skip_group': skip_group},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def infrastructure_servicing_list(context, items, skip_group=False):
    "Print a list of tasks"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('infrastructure/tags/servicing_list',
                               {'service_records': items, 'skip_group': skip_group},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def tags_box(context, object):

    request = context['request']

    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']

    response_format_tags = response_format
    if 'response_format_tags' in context:
        response_format_tags = context['response_format_tags']

    tags = object.tags.all()
    form = None
    if 'tags-edit' in request.GET:
        if request.POST.get('tags_object', 0) == unicode(object.id):
            form = TagsForm(tags, request.POST)
            if form.is_valid():
                if 'multicomplete_tags' in request.POST:
                    tag_names = request.POST.get(
                        'multicomplete_tags').split(',')
                    new_tags = []
                    for name in tag_names:
                        name = name.strip()
                        if name:
                            try:
                                tag = Tag.objects.get(name=name)
                            except Tag.DoesNotExist:
                                tag = Tag(name=name)
                                tag.save()
                            new_tags.append(tag)
                else:
                    new_tags = form.is_valid()

                object.tags.clear()
                for tag in new_tags:
                    object.tags.add(tag)
                tags = object.tags.all()
                form = None
        else:
            form = TagsForm(tags)

    context = {'object': object,
               'tags': tags,
               'form': form,
               'editlink': request.path + '?tags-edit'}

    if 'ajax' in response_format_tags:
        context = converter.preprocess_context(context)

    return Markup(render_to_string('core/tags/tags_box', context,
                                   context_instance=RequestContext(request),
                                   response_format=response_format))

def changes_set_list(context, changesets):
    "Print a list of ChangeSets"
    request = context['request']
    
    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']
    
    return Markup(render_to_string('changes/tags/changeset_list',
                               {'changesets': changesets},
                               context_instance=RequestContext(request),
                               response_format=response_format))

def administration_user_list(context, users, skip_group=False):
    "Print a list of users"
    request = context['request']

    response_format = 'html'
    if 'response_format' in context:
        response_format = context['response_format']

    return Markup(render_to_string('core/administration/tags/user_list',
                                   {'users': users, 'skip_group': skip_group},
                                   context_instance=RequestContext(request),
                                   response_format=response_format))