source: dashwiki/wiki/views.py @ 8ff2dfa8dc699a6ba32373ebadf187b808e68bdf

#-----------------------------------------------------------------------------
# preamble {{{
#-----------------------------------------------------------------------------
# imports {{{

from django.http import HttpResponse
from django.template import RequestContext, loader
from models import WikiPage, WikiHistoryPage
from django.contrib.auth.decorators import login_required
from django.contrib import messages

from dashwiki.decorators import on_cancel, on_button_call
from dashwiki.logging import getLogger, message as log

# }}}
#-----------------------------------------------------------------------------
# tooling {{{

logger = getLogger(__name__)

def load_wiki_or_null(page_name):
  from django.core.exceptions import ObjectDoesNotExist

  try:
    page = WikiPage.objects.get(name = page_name)
  except ObjectDoesNotExist, e:
    page = None
    if '/' in page_name:
      parametrized_name = page_name[0:page_name.rfind('/') + 1]
      # XXX: hack(?) for loading parametrized wiki pages
      try:
        page = WikiPage.objects.get(name = parametrized_name)
      except ObjectDoesNotExist, e:
        pass

  return page

def create_cache():
  from django.conf import settings
  from django.core.urlresolvers import reverse
  from dashwiki.resource_cache import ResourceCache
  return ResourceCache(
    settings.DASHWIKI_CACHE_ROOT,
    reverse('cached_files'),
  )

# request and page_name are for context only (for logging)
# TODO: limit how much time this function spends in calling remote systems
# (timeout)
def call_all_macros(tree, request, page_name, page_param = None):
  from dashwiki.macros.models import Macro
  from django.core.exceptions import ObjectDoesNotExist
  from dashwiki.markup.ast import resolve_macros
  import traceback # for traceback.format_exc()

  def defer_return(result):
    def func(*other_args):
      return result
    return func

  from dashwiki.markup.nodes import node, error, tt

  cache = create_cache()

  def load_macro(macro_name): # {{{
    try:
      macro = Macro.objects.get(name = macro_name)
    except ObjectDoesNotExist, e:
      e_type    = e.__class__.__name__
      e_module  = e.__class__.__module__
      e_message = str(e)
      e_trace   = traceback.format_exc()
      logger.warn(log(
        'macro does not exist',
        ('macro_name', macro_name),
        ('page_name',  page_name),
        exception = {
          'type': '%s.%s' % (e_module, e_type),
          'message': e_message,
        },
      ))
      return defer_return(
        error(['macro ', tt(['[[@', macro_name, ']]']), ' does not exist'])
      )

    def call_macro(*macro_args):
      try:
        return macro.call(macro_args, cache)
      except Exception, e:
        e_type    = e.__class__.__name__
        e_module  = e.__class__.__module__
        e_message = str(e)
        e_trace   = traceback.format_exc()
        logger.warn(log(
          'error when calling macro',
          ('macro_name', macro_name),
          ('macro_args', macro_args),
          ('page_name',  page_name),
          exception = {
            'type': '%s.%s' % (e_module, e_type),
            'message': e_message,
            'traceback': e_trace,
          },
        ))
        return error([
          'error when calling ', tt(['[[@', macro_name, ']]']), ': ', str(e)
        ])

    return call_macro
  # }}}

  try:
    macro_calls = {}
    predefined_macros = {
      'page_name':  page_name, # XXX: this includes possible page parameter
      'page_param': page_param,
    }
    result = resolve_macros(tree, load_macro, macro_calls, predefined_macros)
    if len(macro_calls) > 0:
      cache.store('macros.json', macro_calls)
      cache.store('syntax_tree.json', result)
    return result
  except Exception, e:
    e_type    = e.__class__.__name__
    e_module  = e.__class__.__module__
    e_message = str(e)
    e_trace   = traceback.format_exc()
    logger.warn(log(
      'error when resolving macros',
      ('page_name',  page_name),
      exception = {
        'type': '%s.%s' % (e_module, e_type),
        'message': e_message,
        'traceback': e_trace,
      },
    ))
    return node(document = node(text_paragraph = error([
      'Error when resolving macros on this page: ', str(e)
    ])))

# }}}
#-----------------------------------------------------------------------------
# }}}
#-----------------------------------------------------------------------------
# wiki pages {{{
#-----------------------------------------------------------------------------
# edit_wiki() {{{

@login_required
def edit_wiki(request, page_name):
  template = loader.get_template('edit_wiki.html')

  from forms import WikiPageEdit
  import django.shortcuts

  rev = None
  if 'rev' in request.GET:
    from django.core.exceptions import ObjectDoesNotExist

    try:
      rev = int(request.GET['rev'])
      page = WikiHistoryPage.objects.get(name = page_name, revision = rev)
    except ValueError, e:
      messages.error(request,
        'Invalid revision "%s"' % (request.GET['rev'])
      )
      return django.shortcuts.redirect(request.path)
    except ObjectDoesNotExist, e:
      rev = None
      messages.error(request,
        'Revision %s does not exist' % (request.GET['rev'])
      )
      return django.shortcuts.redirect(request.path)
  else:
    page = load_wiki_or_null(page_name)

  save_no_change = False
  if page != None:
    page_instance = { 'instance': page }
  else:
    page_instance = { 'initial': { 'name': page_name } }

  if 'save' in request.POST:
    page_form = WikiPageEdit(request.POST, **page_instance)
  else:
    page_form = WikiPageEdit(**page_instance)

  # page unchanged
  if page != None and page.content == page_form.data.get('content'):
    messages.info(request, 'Wiki page unchanged')
    return django.shortcuts.redirect(request.path)

  if page_form.is_valid(): # try saving it {{{
    from dashwiki.markup import ParseError
    try:
      page_form.save()
      new_rev = page_form.instance.make_revision(request.user)
      new_rev.save()
      logger.info(log(
        'wiki page saved',
        page = page_form.instance.name,
        revision = new_rev.revision,
        author = request.user.username
      ))
      messages.success(request, 'Wiki page saved')
      return django.shortcuts.redirect(request.path)
    except ParseError, e:
      for err in e.errors:
        messages.error(request,
          "Syntax error at '%s' (%s), line %d, char %d.\n"
          "Expected one of these tokens: %s" % (
            err['text'], err['token'], err['line'], err['char'],
            ", ".join([str(e) for e in err['expected']])
          )
        )
  # }}}}

  context = RequestContext(request, {
    'name': page_name,
    'real_name': page_name,
    'revision': rev,
    'form': page_form,
    'body_raw':  None,
    'body_tree': None,
    'form_target': "%s?edit=%s" % (request.path, request.GET.get('edit', "")),
  })
  if page != None:
    context['body_raw']  = page.content
    context['body_tree'] = page.get_ast()

  return HttpResponse(template.render(context))

# }}}
#-----------------------------------------------------------------------------
# remove_wiki() {{{

@login_required
def remove_wiki(request, page_name):
  template = loader.get_template('remove_wiki.html')
  page = load_wiki_or_null(page_name)
  if 'confirm' in request.POST and page != None:
    new_rev = page.make_revision(request.user, is_delete = True)
    new_rev.save()
    page.delete()
    page = None
    logger.info(log(
      'wiki page deleted',
      page = page_name,
      revision = new_rev.revision,
      author = request.user.username
    ))
  context = RequestContext(request, {
    'name': page_name,
    'real_name': page_name,
    'form_target': "%s?remove=%s" % (request.path, request.GET.get('remove', "")),
    'confirmed': ('confirm' in request.POST),
  })

  return HttpResponse(template.render(context))

# }}}
#-----------------------------------------------------------------------------
# display_wiki() {{{

@on_cancel
@on_button_call(button = 'edit',   target = edit_wiki)
@on_button_call(button = 'remove', target = remove_wiki)
def display_wiki(request, page_name):
  template = loader.get_template('display_wiki.html')

  page = None
  rev = None
  real_name = page_name

  if 'rev' in request.GET:
    from django.core.exceptions import ObjectDoesNotExist

    try:
      rev = int(request.GET['rev'])
      page = WikiHistoryPage.objects.get(name = page_name, revision = rev)
      real_name = page.name
    except ValueError, e:
      messages.error(request,
        'Invalid revision "%s"' % (request.GET['rev'])
      )
    except ObjectDoesNotExist, e:
      rev = None
      messages.error(request,
        'Revision %s does not exist' % (request.GET['rev'])
      )
  else:
    page = load_wiki_or_null(page_name)
    if page:
      real_name = page.name

  context = RequestContext(request, {
    'name': page_name,
    'real_name': real_name,
    'body_raw':  None,
    'body_tree': None,
    'editable': request.user.is_authenticated(),
    'revision': rev,
  })
  if page != None:
    context['body_raw']  = page.content
    context['body_tree'] = call_all_macros(
      page.get_ast(), request, page_name, page_name[len(real_name):]
    )

  import email.utils, time
  response = HttpResponse(template.render(context))
  # inform proxy not to cache this page
  response['Expires'] = email.utils.formatdate(0, usegmt = True)
  response['Last-Modified'] = email.utils.formatdate(usegmt = True)
  response['Cache-Control'] = 'max-age=0, no-cache, must-revalidate, proxy-revalidate'
  return response

# }}}
#-----------------------------------------------------------------------------
# create_wiki() {{{

@login_required
@on_cancel(target = (display_wiki, ['WikiStart']))
def create_wiki(request):
  template = loader.get_template('create_wiki.html')

  from forms import WikiPageCreate

  if request.method == 'POST':
    create_form = WikiPageCreate(request.POST)
    proposed_name = create_form.data['name']

    if create_form.is_valid():
      if WikiPage.objects.filter(name = proposed_name).exists():
        context = RequestContext(request, {
          'form': create_form,
          'error': 'page %s already exists' % (proposed_name),
          'page_name': proposed_name,
        })
        return HttpResponse(template.render(context))

      messages.success(request, 'Page %s created' % proposed_name)
      context = RequestContext(request, {
        'form': create_form,
        'page_name': proposed_name,
        'created': True,
      })
      return HttpResponse(template.render(context))
    else:
      for err in create_form.errors['name']:
        messages.error(request, err)
      context = RequestContext(request, {
        'form': create_form,
        'page_name': proposed_name,
      })
      return HttpResponse(template.render(context))

  context = RequestContext(request, {
    'form': WikiPageCreate(),
  })
  return HttpResponse(template.render(context))

# }}}
#-----------------------------------------------------------------------------
# }}}
#-----------------------------------------------------------------------------
# navigation {{{
#-----------------------------------------------------------------------------
# list_history() {{{

def list_history(request):
  template = loader.get_template('list_history.html')
  histpages = WikiHistoryPage.objects.all().order_by('-creation_time')
  context = RequestContext(request, {
    'pages': histpages,
  })
  return HttpResponse(template.render(context))

# }}}
#-----------------------------------------------------------------------------
# list_pages() {{{

def list_pages(request):
  template = loader.get_template('list_pages.html')

  pages = [page.name for page in WikiPage.objects.all()]
  pages.sort()

  context = RequestContext(request, {
    'pages': pages,
    'editable': request.user.is_authenticated(),
  })
  return HttpResponse(template.render(context))

# }}}
#-----------------------------------------------------------------------------
# }}}
#-----------------------------------------------------------------------------
# vim:ft=python:foldmethod=marker