Django에서 동적으로 생성 된 xml 파일

Question

최근 이벤트에 대한 XML 파일을 동적으로 생성하고 싶습니다. 나중에 파일을 구문 분석 할 수 있습니다. 나는 장고를 사용하려고 시도하고, 장고 객체를 직렬화하고, 다른 방법으로 시도했지만 성공하지 못했다.

#views.py 

from django.utils.translation import ugettext as _ 
from django.shortcuts import render_to_response, get_object_or_404 
from django.template import RequestContext 
from django.contrib.auth.decorators import login_required 
from events.models import Event, Attendance 
from events.forms import EventForm 
from dateutil.parser import parse 
from django.core import serializers 
from django.http import HttpResponseRedirect, HttpResponse, Http404 
from django.views.decorators.http import require_POST 
from django.core.urlresolvers import reverse 
from django.core import serializers 


def recentEvents(request, everyone=True): 

    """ 
    Renders a list of ``Event`` instances, which are selected mainly based on 
    two factors: 

    The ``everyone`` parameter: 
    If this is set to False, then we filter down the event list to be only 
    those events that were created by or attended by one of the people who 
    the user follows. 
    If the user is authenticated, the user's events are separated from the 
    other events. 
    """ 
events = Event.objects.today().filter(latest=True) 
if request.user.is_authenticated(): 
    my_events = events.filter(creator=request.user) |  events.filter(attendance__user=request.user) 
    events = events.exclude(creator=request.user).exclude(attendance__user=request.user) 
    following = request.user.following_set.all().values_list('to_user', flat=True) 
else: 
    my_events = Event.objects.none() 
    following = None 

if not everyone: 
    events = events.filter(creator__in=following) |  events.filter(attendance__user__in=following) 
events = events.order_by('-start_date', '-creation_date').distinct() 
context = { 
    'events': events, 
    'my_events': my_events, 
    'following': following, 
    'event_form': EventForm(), 
} 
return render_to_response('events/recentEvents.html', 
    context, 
    context_instance = RequestContext(request) 
) 

def oldEvents(request, everyone=True): 

""" 
Renders a list of ``Event`` instances, which are selected mainly based on 
one parameter: 

``everyone``: 
    If this is set to False, then we filter down the event list to be only 
    those events that were created by or attended by one of the people who 
    the user follows. 
""" 

events = Event.objects.filter(latest=False) | Event.objects.filter(attendance__user__isnull=False) 
if request.user.is_authenticated(): 
    following = list(request.user.following_set.all().values_list('to_user', flat=True)) 
else: 
    following = None 
if not everyone: 
    following.append(request.user.id) 
    events = events.filter(creator__in=following) | events.filter(attendance__user__in=following) 
events = events.order_by('-creation_date', '-start_date').distinct() 
context = { 
    'events': events, 
    'following': following, 
} 
return render_to_response('events/oldEvents.html', 
    context, 
    context_instance = RequestContext(request) 
) 

def event(request, id): 
    """ 
    Render a single event. 
    """ 
    event = get_object_or_404(Event, id=id) 
    return render_to_response('events/event_details.html', 
     {'event': event}, 
     context_instance = RequestContext(request) 
    ) 

def create(request): 
    """ 
    Renders a form for creating a new ``Event`` instance, validates against that 
    form, and creates the new instances. 
    """ 
    form = EventForm(request.POST or None) 
    if form.is_valid(): 
     event = form.save(commit=False) 
     event.creator = request.user 
     guessed_date = None 

     for word in event.description.split(): 
     try: 
      guessed_date = parse(word) 
      break 
     except ValueError: 
      continue 
     event.start_date = guessed_date 
    event.save() 
    if 'next' in request.POST: 
     next = request.POST['next'] 
else: 
     next = reverse('recentEvents') 
    if request.is_ajax(): 
     # If the request is AJAX, then render the created event and don't 
     # create messages for the user. 
     try: 
      Attendance.objects.get(event=event, user=request.user) 
      attending = True 
     except Attendance.DoesNotExist: 
      attending = False 
     return render_to_response('events/event.html', {'event': event, 
      'request': request, 'attending': attending, 
      'authenticated': True, 'event_num': 1, 'next': next}) 

    else: 
     # If the request is not AJAX, then create messages for the user and 
     # redirect them to the next page. 
     request.user.message_set.create(
      message=_('Your event was posted.')) 
     return HttpResponseRedirect(next) 
if request.is_ajax(): 
    raise Http404 
return render_to_response(
    'events/create.html', 
    {'form': form}, 
    context_instance = RequestContext(request) 
) 
create = login_required(create) 

def toggle_attendance(request): 
    """ 
    Toggles whether a user is set to attend an event or not. 
    """ 
    try: 
     event_id = int(request.POST['event_id']) 
    except (KeyError, ValueError): 
     raise Http404 
event = get_object_or_404(Event, id=event_id) 
attendance, created = Attendance.objects.get_or_create(user=request.user, event=event) 
if not created: 
    attendance.delete() 
if request.is_ajax(): 
    # If the request is AJAX, return JSON representing the new count of 
    # people who are attending the event. 
    json = '{"created": %s, "count": %s}' % (created and 'true' or 'false', 
     event.attendees.all().count()) 
    return HttpResponse(json, mimetype='application/json') 
# If the request was not AJAX, create messages for the user. 
if created: 
    request.user.message_set.create(
     message=_('You are now attending "%s"') % unicode(event)) 
else: 
    request.user.message_set.create(
     message=_('You are no longer attending "%s"') % unicode(event)) 
next = request.POST.get('next', '') 
#if not next: 
# next = reverse('ev_tonight') 

return HttpResponseRedirect(next) 
toggle_attendance = require_POST(login_required(toggle_attendance)) 



#generate xml file 
def xml_latest(request): 
    if request.is_ajax(): 
     #format = 'xml' 
     mimetype = 'application/xml' 

     #return serializers.serialize("xml", Event.objects.all()) 

     data = serializers.serialize("xml", Event.objects.all()) 
     #out = open("file.xml", "w") 
     #xml_serializer.serialize(Event.objects.all(), stream=out) 
     return HttpResponse(data,mimetype) 
    else: 
     return HttpResponse(status=400) 

models.py

from datetime import datetime, timedelta 
from django.db import models 
from django.contrib.auth.models import User 
from django.db.models.query import QuerySet 

def today(): 
""" 
Returns a tuple of two datetime instances: the beginning of today, and the 
end of today. 
""" 
now = datetime.now() 
start = datetime.min.replace(year=now.year, month=now.month, 
    day=now.day) 
end = (start + timedelta(days=1)) - timedelta.resolution 
return (start, end) 

class EventQuerySet(QuerySet): 
""" 
A very simple ``QuerySet`` subclass which adds only one extra method, 
``today``, which returns only those objects whose ``creation_date`` falls 
within the bounds of today. 
""" 
def today(self): 
    """ 
    Filters down to only those objects whose ``creation_date`` falls within 
    the bounds of today. 
    """ 
    return self.filter(creation_date__range=today()) 

class EventManager(models.Manager): 
""" 
A very simple ``Manager`` subclass which returns an ``EventQuerySet`` 
instead of the typical ``QuerySet``. It also includes a proxy for the extra 
``today`` method that is provided by the ``EventQuerySet`` subclass. 
""" 
def get_query_set(self): 
    """ 
    return EventQuerySet(self.model) 

def today(self): 
    """ 
    A proxy method for the extra ``today`` method that is provided by the 
    ``EventQuerySet`` subclass. 
    """ 
    return self.get_query_set().today() 

class Event(models.Model): 
description = models.TextField() 
start_date = models.DateTimeField(null=True, blank=True) 
creation_date = models.DateTimeField(default=datetime.now) 
creator = models.ForeignKey(User, related_name='event_creator_set') 
attendees = models.ManyToManyField(User, through='Attendance') 
latest = models.BooleanField(default=True) 

objects = EventManager() 

def __unicode__(self): 
    """ 
    Returns the first 80 characters of the description, or less, if the 
    description is less than 80 characters. 
    """ 
    if len(self.description) > 80: 
     return self.description[:76] + ' ...' 
    return self.description[:80] 

def save(self, **kwargs): 
    """ 
    First this updates all events created today by the same creator as this 
    event, and sets their ``latest`` field to False. 

    Then, this simply saves the object. Since the default for ``latest`` is 
    to be set to True, it will be passed through and saved as the latest 
    event for today by this user. 
    """ 
    Event.objects.today().filter(creator=self.creator).update(latest=False) 
    super(Event, self).save(**kwargs) 

def today(self): 
    """ 
    Determines whether this event takes place today or not. 
    """ 
    (start, end) = today() 
    return self.creation_date >= start and self.creation_date <= end 

def description_size(self): 
    """ 
    Useful only for display purposes, this designates a label of 'small', 
    'medium', or 'large' to the description text size. 
    """ 
    if len(self.description) < 120: 
     return 'small' 
    elif len(self.description) < 240: 
     return 'medium' 
    else: 
     return 'large' 

class Attendance(models.Model): 
""" 
This is the explicit intermediary model mapping ``User`` instances to 
``Event`` instances. 
""" 
user = models.ForeignKey(User) 
event = models.ForeignKey(Event) 
registration_date = models.DateTimeField(default=datetime.now) 

def __unicode__(self): 
    return "%s is attending %s" % (self.user.username, self.event) 

사람이 도움을 주시겠습니까! 미리 감사드립니다.

Answer 1

XML은 HTML과 다르지 않으므로 대부분의 경우 가장 빠른 방법은 html 템플릿과 마찬가지로 템플릿을 만들어서 렌더링하는 것입니다.

return TemplateResponse(request, 'events.xml', {'events': Event.objects.all()}) 

JSON은 XML에 수용 대안, 그리고 당신이 더 많은 기술 느끼는 경우

같은 뭔가, 나는 연장하고 싶은 jsonencoder 및 dump 응답에 그.