def history(request,
            group_slug=None, group_slug_field=None, group_qs=None,
            article_qs=ALL_ARTICLES, changes_qs=ALL_CHANGES,
            template_name='recentchanges.html',
            template_dir='wiki',
            extra_context=None,
            *args, **kw):

    if request.method == 'GET':
        if  group_slug is not None:
            group = get_object_or_404(group_qs,
                                      **{group_slug_field : group_slug})
            changes_qs = changes_qs.filter(article__content_type=get_ct(group),
                                           article__object_id=group.id)
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            allow_read = allow_write = True

        if not allow_read:
            return HttpResponseForbidden()

        template_params = {'changes': changes_qs.order_by('-modified'),
                           'allow_write': allow_write}


#####
        if group_slug is not None:
#            template_params['group'] = group
            new_article = ArticleClass(title="NewArticle",
                                       content_type=get_ct(group),
                                       object_id=group.id)
        else:
            new_article = ArticleClass(title="NewArticle")
        template_params['new_article'] = new_article
#####
#        template_params = {'new_article': new_article,


        if group_slug is not None:
            template_params['group'] = group_slug

        if extra_context is not None:
            template_params.update(extra_context)

        return render_to_response('/'.join([template_dir, template_name]),
                                  template_params,
                                  context_instance=RequestContext(request))
    return HttpResponseNotAllowed(['GET'])

    def __init__(
        self,
        title,
        request,
        group_slug=None,
        group_slug_field=None,
        group_qs=None,
        article_qs=ALL_ARTICLES,
        changes_qs=ALL_CHANGES,
        extra_context=None,
        title_template=u"feeds/history_title.html",
        description_template=u"feeds/history_description.html",
        *args,
        **kw
    ):

        if group_slug is not None:
            group = get_object_or_404(group_qs, **{group_slug_field: group_slug})
            self.article_qs = article_qs.filter(content_type=get_ct(group), object_id=group.id)
        else:
            self.article_qs = article_qs

        self.title_template = get_template(title_template)
        self.description_template = get_template(description_template)
        super(AtomArticleHistoryFeed, self).__init__("", request)

    def clean_title(self):
        """ Whiteboard title is always the group slug.
        Really, whiteboards don't need titles, but using the slug enforces
        uniqueness... (can relax this if we do full wikis for groups)
        (actually, is this even called, since "title" is in the exclude list?)
        """
        
        ctype = get_ct(self.cleaned_data['content_type'])
        group = ctype.get_object_for_this_type(pk=self.cleaned_data['object_id'])
        self.cleaned_data['title'] = group.slug

        return self.cleaned_data['title']

def revert_to_revision(request, title,
                       group_slug=None, bridge=None,
                       article_qs=ALL_ARTICLES,
                       extra_context=None,
                       is_member=None,
                       is_private=None,
                       *args, **kw):

    if request.method == 'POST':

        revision = int(request.POST['revision'])

        article_args = {'title': title}

        group = None
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            # @@@ use bridge instead
            article_args.update({'content_type': get_ct(group),
                                 'object_id': group.id})
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            group = None
            allow_read = allow_write = True
            article_args.update({'object_id': None})

        if not (allow_read or allow_write):
            return HttpResponseForbidden()

        article = get_object_or_404(article_qs, **article_args)

        if request.user.is_authenticated():
            article.revert_to(revision, get_real_ip(request), request.user)
        else:
            article.revert_to(revision, get_real_ip(request))


        if request.user.is_authenticated():
            request.user.message_set.create(
                message=u"The article was reverted successfully.")
                
        url = get_url('wiki_article_history', group, kw={
            'title': title,
        }, bridge=bridge)
        
        return redirect_to(request, url)

    return HttpResponseNotAllowed(['POST'])

def view_changeset(request, title, revision,
                   group_slug=None, bridge=None,
                   article_qs=ALL_ARTICLES,
                   changes_qs=ALL_CHANGES,
                   template_name='changeset.html',
                   template_dir='wiki',
                   extra_context=None,
                   is_member=None,
                   is_private=None,
                   *args, **kw):

    if request.method == "GET":
        article_args = {'article__title': title}
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            # @@@ hmm, need to look into this for the bridge i think
            article_args.update({'article__content_type': get_ct(group),
                                 'article__object_id': group.id})
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            group = None
            allow_read = allow_write = True
            article_args.update({'article__object_id': None})

        if not allow_read:
            return HttpResponseForbidden()

        changeset = get_object_or_404(
            changes_qs.select_related(),
            revision=int(revision),
            **article_args)

        article = changeset.article

        template_params = {'article': article,
                           'article_title': article.title,
                           'changeset': changeset,
                           'allow_write': allow_write}

        template_params['group'] = group
        if extra_context is not None:
            template_params.update(extra_context)

        return render_to_response(os.path.join(template_dir, template_name),
                                  template_params,
                                  context_instance=RequestContext(request))
    return HttpResponseNotAllowed(['GET'])

def revert_to_revision(
    request,
    title,
    group_slug=None,
    bridge=None,
    article_qs=ALL_WHITEBOARDS,
    extra_context=None,
    is_member=None,
    is_private=None,
    *args,
    **kw
):

    if request.method == "POST":

        revision = int(request.POST["revision"])

        article_args = {"title": title}

        group = None
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404

            # permissions check
            if not group.user_is_member(request.user, admin_override=True):
                return HttpResponseForbidden()

            # @@@ use bridge instead
            article_args.update({"content_type": get_ct(group), "object_id": group.id})

        article = get_object_or_404(article_qs, **article_args)

        if request.user.is_authenticated():
            article.revert_to(revision, get_real_ip(request), request.user)
        else:
            article.revert_to(revision, get_real_ip(request))

        if request.user.is_authenticated():
            request.user.message_set.create(message=u"The article was reverted successfully.")

        url = group.get_absolute_url()
        return redirect_to(request, url)

    return HttpResponseNotAllowed(["POST"])

def article_history(request, title,
                    group_slug=None, bridge=None,
                    article_qs=ALL_ARTICLES,
                    template_name='history.html',
                    template_dir='wiki',
                    extra_context=None,
                    is_member=None,
                    is_private=None,
                    *args, **kw):

    if request.method == 'GET':

        article_args = {'title': title}
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            # @@@ use bridge instead
            article_args.update({'content_type': get_ct(group),
                                 'object_id': group.id})
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            group = None
            allow_read = allow_write = True
            article_args.update({'object_id': None})

        if not allow_read:
            return HttpResponseForbidden()

        article = get_object_or_404(article_qs, **article_args)
        changes = article.changeset_set.all().order_by('-revision')

        template_params = {'article': article,
                           'changes': changes,
                           'allow_write': allow_write}
        template_params['group'] = group
        if extra_context is not None:
            template_params.update(extra_context)

        return render_to_response(os.path.join(template_dir, template_name),
                                  template_params,
                                  context_instance=RequestContext(request))

    return HttpResponseNotAllowed(['GET'])

def revert_to_revision(request, title,
                       group_slug=None, group_slug_field=None, group_qs=None,
                       article_qs=ALL_ARTICLES,
                       extra_context=None,
                       is_member=None,
                       is_private=None,
                       *args, **kw):

    if request.method == 'POST':

        revision = int(request.POST['revision'])

        article_args = {'title': title}

        group = None
        if group_slug is not None:
            group = get_object_or_404(group_qs,**{group_slug_field: group_slug})
            article_args.update({'content_type': get_ct(group),
                                 'object_id': group.id})
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            allow_read = allow_write = True

        if not (allow_read or allow_write):
            return HttpResponseForbidden()

        article = get_object_or_404(article_qs, **article_args)

        if request.user.is_authenticated():
            article.revert_to(revision, get_real_ip(request), request.user)
        else:
            article.revert_to(revision, get_real_ip(request))


        if request.user.is_authenticated():
            messages.add_message(request, messages.INFO, u"The article was reverted successfully.")

        url = get_url('wiki_article_history', group,
                      [title], {'title': title,
                                'group_slug': group_slug})

        return redirect_to(request, url)

    return HttpResponseNotAllowed(['POST'])

    def __init__(self, request,
                 group_slug=None, group_slug_field=None, group_qs=None, 
                 article_qs=ALL_ARTICLES, changes_qs=ALL_CHANGES, 
                 extra_context=None, 
                 title_template = u'feeds/history_title.html', 
                 description_template = u'feeds/history_description.html', 
                 *args, **kw):

        if  group_slug is not None:
            group = get_object_or_404(group_qs, 
                                      **{group_slug_field : group_slug})
            self.changes_qs = changes_qs.filter(article__content_type=get_ct(group), 
                                                article__object_id=group.id)
        else:
            self.changes_qs = changes_qs

        self.title_template = title_template
        self.description_template = description_template
        super(RssHistoryFeed, self).__init__('', request)

def observe_article(request, title,
                    group_slug=None, bridge=None,
                    article_qs=ALL_ARTICLES,
                    template_name='recentchanges.html',
                    template_dir='wiki',
                    extra_context=None,
                    is_member=None,
                    is_private=None,
                    *args, **kw):
    if request.method == 'POST':

        article_args = {'title': title}
        group = None
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            article_args.update({'content_type': get_ct(group),
                                 'object_id': group.id})
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
        else:
            group = None
            allow_read = True

        if not allow_read:
            return HttpResponseForbidden()

        article = get_object_or_404(article_qs, **article_args)

        notification.observe(article, request.user,
                             'wiki_observed_article_changed')
        
        url = get_url('wiki_article', group, kw={
            'title': article.title,
        }, bridge=bridge)
        
        return redirect_to(request, url)

    return HttpResponseNotAllowed(['POST'])

    def __init__(self, request,
                 group_slug=None, bridge=None, 
                 article_qs=ALL_ARTICLES, changes_qs=ALL_CHANGES, 
                 extra_context=None, 
                 title_template = u'feeds/history_title.html', 
                 description_template = u'feeds/history_description.html', 
                 *args, **kw):

        if  group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            self.changes_qs = changes_qs.filter(article__content_type=get_ct(group), 
                                                article__object_id=group.id)
        else:
            self.changes_qs = changes_qs.filter(article__object_id=None)

        self.title_template = get_template(title_template)
        self.description_template = get_template(description_template)
        super(AtomHistoryFeed, self).__init__('', request)

def history(request,
            group_slug=None, bridge=None,
            article_qs=ALL_ARTICLES, changes_qs=ALL_CHANGES,
            template_name='recentchanges.html',
            template_dir='wiki',
            extra_context=None,
            *args, **kw):

    if request.method == 'GET':
        if group_slug is not None:
            try:
                group = bridge.get_group(group_slug)
            except ObjectDoesNotExist:
                raise Http404
            changes_qs = changes_qs.filter(article__content_type=get_ct(group),
                                           article__object_id=group.id)
            allow_read = has_read_perm(request.user, group, is_member,
                                       is_private)
            allow_write = has_write_perm(request.user, group, is_member)
        else:
            group = None
            allow_read = allow_write = True
            changes_qs = changes_qs.filter(article__object_id=None)

        if not allow_read:
            return HttpResponseForbidden()

        template_params = {'changes': changes_qs.order_by('-modified'),
                           'allow_write': allow_write}
        template_params['group'] = group_slug

        if extra_context is not None:
            template_params.update(extra_context)

        return render_to_response(os.path.join(template_dir, template_name),
                                  template_params,
                                  context_instance=RequestContext(request))
    return HttpResponseNotAllowed(['GET'])

def get_articles_for_object(object, article_qs=None):
    if article_qs is None:
        article_qs = ALL_ARTICLES
    return article_qs.filter( content_type=get_ct(object),
                                       object_id=object.id)

def edit_article(request, title,
                 group_slug=None, bridge=None,
                 article_qs=ALL_ARTICLES,
                 ArticleClass=Article, # to get the DoesNotExist exception
                 ArticleFormClass=ArticleForm,
                 template_name='edit.html',
                 template_dir='wiki',
                 extra_context=None,
                 check_membership=False,
                 is_member=None,
                 is_private=None,
                 *args, **kw):

    if group_slug is not None:
        try:
            group = bridge.get_group(group_slug)
        except ObjectDoesNotExist:
            raise Http404
        allow_read = has_read_perm(request.user, group, is_member,
                                   is_private)
        allow_write = has_write_perm(request.user, group, is_member)
    else:
        group = None
        allow_read = allow_write = True


    if not allow_write:
        return HttpResponseForbidden()

    try:
        article = article_qs.get_by(title, group)
    except ArticleClass.DoesNotExist:
        article = None

    if request.method == 'POST':

        form = ArticleFormClass(request.POST, instance=article)

        if form.is_valid():

            if request.user.is_authenticated():
                form.editor = request.user
                if article is None:
                    user_message = u"Your article was created successfully."
                else:
                    user_message = u"Your article was edited successfully."
                request.user.message_set.create(message=user_message)

            if ((article is None) and (group_slug is not None)):
                form.group = group

            new_article, changeset = form.save()
            
            url = get_url('wiki_article', group, kw={
                'title': new_article.title,
            }, bridge=bridge)
            
            return redirect_to(request, url)

    elif request.method == 'GET':
        user_ip = get_real_ip(request)

        lock = cache.get(title, None)
        if lock is None:
            lock = ArticleEditLock(title, request)
        lock.create_message(request)

        initial = {'user_ip': user_ip}
        if group_slug is not None:
            # @@@ wikiapp currently handles the group filtering, but we will
            # eventually want to handle that via the bridge.
            initial.update({'content_type': get_ct(group).id,
                            'object_id': group.id})

        if article is None:
            initial.update({'title': title,
                            'action': 'create'})
            form = ArticleFormClass(initial=initial)
        else:
            initial['action'] = 'edit'
            form = ArticleFormClass(instance=article,
                                    initial=initial)

    template_params = {'form': form}

    template_params['group'] = group
    if extra_context is not None:
        template_params.update(extra_context)

    return render_to_response(os.path.join(template_dir, template_name),
                              template_params,
                              context_instance=RequestContext(request))

def edit_article(
    request,
    title,
    group_slug=None,
    bridge=None,
    article_qs=ALL_WHITEBOARDS,
    ArticleClass=Whiteboard,  # to get the DoesNotExist exception
    ArticleFormClass=WhiteboardForm,
    template_name="edit_whiteboard.html",
    template_dir="whiteboard",
    extra_context=None,
    check_membership=False,
    is_member=None,
    is_private=None,
    *args,
    **kw
):

    if group_slug is not None:
        try:
            group = bridge.get_group(group_slug)
        except ObjectDoesNotExist:
            raise Http404

        # permissions check
        if not group.user_is_member(request.user, admin_override=True):
            return HttpResponseForbidden()

        try:
            article = article_qs.get_by(title, group)
        except ArticleClass.DoesNotExist:
            article = None

        attach_forms = []
        if request.method == "POST":
            try:
                attach_count = int(request.POST.get("attach_count", 0))
            except ValueError:
                attach_count = 0

            form = ArticleFormClass(request.POST, instance=article)
            attach_forms = [
                AttachmentForm(request.POST, request.FILES, prefix=str(x), instance=Attachment())
                for x in range(0, attach_count)
            ]

            # do not take blank attachment forms into account
            for af in attach_forms:
                if not af.is_valid() and not af["attachment_file"].data:
                    attach_forms.remove(af)
                    attach_count = attach_count - 1

            if form.is_valid() and all([af.is_valid() for af in attach_forms]):

                if request.user.is_authenticated():
                    form.editor = request.user
                    if article is None:
                        user_message = u"Whiteboard was created successfully."
                    else:
                        user_message = u"Whiteboard was edited successfully."
                    request.user.message_set.create(message=user_message)

                if (article is None) and (group_slug is not None):
                    form.group = group

                new_article, changeset = form.save()

                for af in attach_forms:
                    attachment = af.save(request, new_article)

                # FIXME: is there a more efficient way of finding the parent
                # than running these count() queries?
                if new_article.topic.count():
                    url = new_article.topic.all()[0].get_absolute_url()
                elif new_article.event.count():
                    url = new_article.event.all()[0].get_absolute_url()
                else:
                    url = group.get_absolute_url() + "#group-whiteboard"

                return redirect_to(request, url)

        elif request.method == "GET":
            user_ip = get_real_ip(request)

            lock = cache.get(title, None)
            if lock is None:
                lock = ArticleEditLock(title, request)
            lock.create_message(request)

            initial = {"user_ip": user_ip}
            if group_slug is not None:
                # @@@ wikiapp currently handles the group filtering, but we will
                # eventually want to handle that via the bridge.
                initial.update({"content_type": get_ct(group).id, "object_id": group.id})

            if article is None:
                initial.update({"title": title, "action": "create"})
                form = ArticleFormClass(initial=initial)
            else:
                initial["action"] = "edit"
#.........这里部分代码省略.........