Forums on a Shared Host

In this chapter, we will setup initial forum pages.

We can see the actual implementation via BoGo Forums.

Some of the screen shots are:

Forums Home (http://www.bogotobogo.com/dj/forums)

Python Forum (http://www.bogotobogo.com/dj/forums/forum/10/)

Thread view of the Python Forum (http://www.bogotobogo.com/dj/forums/thread/12/)

Reply to a thread of the Python Forum (http://www.bogotobogo.com/dj/forums/post/reply/12/)

Starting a new thread of the Python Forum (http://www.bogotobogo.com/dj/forums/post/new_thread/10/)

User Registration (http://www.bogotobogo.com/dj/accounts/register/)

More things to be done (some of the sources are not completed)

1. Email activation - sending email / authentication via email / recovery of a password
2. User profile editing including user avatar setting

Our forum consists of two apps:

$ python manage.py startapp forum
$ python manage.py startapp registration

forum:

registration:

As we can see from the trees, there are some static files, and they are initially stored in each app's static directory under relevant sub-directories. Then we issue collectstatic command (see Managing (Deploying) Static files (CSS, Images, Javascript) on Shared Host):

$ pwd
/home2/bogotob1/djangoproject
$ python manage.py collectstatic

Note that we need to set the STATIC_ROOT to the directory from which we like to serve these files. So, when we do collectstatic, it will copy all files from our static folders into the STATIC_ROOT directory.I n my case, it is:

STATIC_ROOT = "/home2/bogotob1/www/dj/static/"

INSTALLED_APPS = (
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',
 'registration',
 'djangoapp',
 'taggit',
 'blog',
 'forum',
 'myapp',
)
MIDDLEWARE_CLASSES = (
 'django.contrib.sessions.middleware.SessionMiddleware',
 'django.middleware.common.CommonMiddleware',
 'django.middleware.csrf.CsrfViewMiddleware',
 'django.contrib.auth.middleware.AuthenticationMiddleware',
 'django.contrib.messages.middleware.MessageMiddleware',
 'django.middleware.clickjacking.XFrameOptionsMiddleware',
)
ROOT_URLCONF = 'djangoproject.urls'
...
DATABASES = {
 'default': {
 'ENGINE': 'django.db.backends.mysql',
 'NAME': 'name',
 'USER': 'user',
 'PASSWORD': 'password',
 'HOST': 'localhost', # Or an IP Address that your DB is hosted on
 'PORT': '3306',
 }

from django.db import models
from django.contrib.auth.models import User
from django.contrib import admin
from string import join
from djangoproject.settings import MEDIA_ROOT
from django.db.models.signals import post_save
class Forum(models.Model):
 title = models.CharField(max_length=60)
 def __unicode__(self):
 return self.title
 def num_posts(self):
 posts = sum([t.num_posts() for t in self.thread_set.all()])
 return posts
 def last_post(self):
 if self.thread_set.count():
 last = None
 for t in self.thread_set.all():
 l = t.last_post()
 if l:
 if not last: last = l
 elif l.created > last.created: last = l
 return last
class Thread(models.Model):
 title = models.CharField(max_length=60)
 created = models.DateTimeField(auto_now_add=True)
 creator = models.ForeignKey(User, blank=True, null=True)
 forum = models.ForeignKey(Forum)
 def __unicode__(self):
 return unicode(self.creator) + " - " + self.title
 def num_posts(self):
 return self.post_set.count()
 def num_replies(self):
 return self.post_set.count() - 1
 def last_post(self):
 if self.post_set.count():
 return self.post_set.order_by("created")[0]
class Post(models.Model):
 title = models.CharField(max_length=60)
 created = models.DateTimeField(auto_now_add=True)
 creator = models.ForeignKey(User, blank=True, null=True)
 thread = models.ForeignKey(Thread)
 body = models.TextField(max_length=10000)
 def __unicode__(self):
 return u"%s - %s - %s" % (self.creator, self.thread, self.title)
 def short(self):
 return u"%s - %s\n%s" % (self.creator, self.title, self.created.strftime("%b %d, %I:%M %p"))
 short.allow_tags = True
 def profile_data(self):
 p = self.creator.userprofile_set.all()[0]
 return p.posts, p.avatar
class UserProfile(models.Model):
 avatar = models.ImageField("Profile Pic", upload_to="images/", blank=True, null=True)
 posts = models.IntegerField(default=0)
 user = models.ForeignKey(User, unique=True)
 def __unicode__(self):
 return unicode(self.user)
### Admin
class ProfileAdmin(admin.ModelAdmin):
 list_display = ["user"]
class ForumAdmin(admin.ModelAdmin):
 pass
class ThreadAdmin(admin.ModelAdmin):
 list_display = ["title", "forum", "creator", "created"]
 list_filter = ["forum", "creator"]
class PostAdmin(admin.ModelAdmin):
 search_fields = ["title", "creator"]
 list_display = ["title", "thread", "creator", "created"]
def create_user_profile(sender, **kwargs):
 """When creating a new user, make a profile for him or her."""
 u = kwargs["instance"]
 if not UserProfile.objects.filter(user=u):
 UserProfile(user=u).save()
post_save.connect(create_user_profile, sender=User)

Then, to add tables, we need to run:

$ python manage.py syncdb

from django.shortcuts import render
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
# Create your views here.
from django.core.urlresolvers import reverse
from djangoproject.settings import MEDIA_ROOT, MEDIA_URL
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import get_object_or_404, render_to_response
from django.core.context_processors import csrf
from django.core.paginator import Paginator, InvalidPage, EmptyPage
from django.forms import ModelForm
from django.core.urlresolvers import reverse
from forum.models import *
class ProfileForm(ModelForm):
 class Meta:
 model = UserProfile
 exclude = ["posts", "user"]
@login_required
def profile(request, pk):
 """Edit user profile."""
 profile = UserProfile.objects.get(user=pk)
 img = None
 if request.method == "POST":
 pf = ProfileForm(request.POST, request.FILES, instance=profile)
 if pf.is_valid():
 pf.save()
 # resize and save image under same filename
 imfn = pjoin(MEDIA_ROOT, profile.avatar.name)
 im = PImage.open(imfn)
 im.thumbnail((160,160), PImage.ANTIALIAS)
 im.save(imfn, "JPEG")
 else:
 pf = ProfileForm(instance=profile)
 if profile.avatar:
 img = "/media/" + profile.avatar.name
 return render_to_response("forum/profile.html", add_csrf(request, pf=pf, img=img))
def save_profile(request, pk):
 """Edit user profile."""
 profile = UserProfile.objects.get(user=pk)
 img = None
 if request.method == "POST":
 pf = ProfileForm(request.POST, request.FILES, instance=profile)
 if pf.is_valid():
 pf.save()
 # resize and save image under same filename
 imfn = pjoin(MEDIA_ROOT, profile.avatar.name)
 im = PImage.open(imfn)
 im.thumbnail((160,160), PImage.ANTIALIAS)
 im.save(imfn, "JPEG")
 else:
 pf = ProfileForm(instance=profile)
 if profile.avatar:
 img = "/media/" + profile.avatar.name
 return render_to_response("forum/profile.html", add_csrf(request, pf=pf, img=img))
def mk_paginator(request, items, num_items):
 """Create and return a paginator."""
 paginator = Paginator(items, num_items)
 try: page = int(request.GET.get("page", '1'))
 except ValueError: page = 1
 try:
 items = paginator.page(page)
 except (InvalidPage, EmptyPage):
 items = paginator.page(paginator.num_pages)
 return items
def main(request):
 """Main listing."""
 forums = Forum.objects.all()
 return render_to_response("forum/list.html", dict(forums=forums, user=request.user)) 
class ThreadAdmin(admin.ModelAdmin):
 list_display = ["title", "forum", "creator", "created"]
 list_filter = ["forum", "creator"]
class PostAdmin(admin.ModelAdmin):
 search_fields = ["title", "creator"]
 list_display = ["title", "thread", "creator", "created"]
@login_required
def post(request, ptype, pk):
 """Display a post form."""
 action = reverse("forum.views.%s" % ptype, args=[pk])
 #t = Thread.objects.get(pk=pk)
 #f = Forum.objects.get(pk=t.forum.pk)
 if ptype == "new_thread":
 f = Forum.objects.get(pk=pk)
 title = f.title + " Forum - Start New Topic"
 subject = ''
 elif ptype == "reply":
 t = Thread.objects.get(pk=pk)
 f = Forum.objects.get(pk=t.forum.pk)
 title = f.title + " Forum - Reply"
 subject = "Re: " + Thread.objects.get(pk=pk).title
 return render_to_response("forum/post.html", add_csrf(request, subject=subject, action=action,
 title=title))
def forum(request, pk):
 """Listing of threads in a forum."""
 threads = Thread.objects.filter(forum=pk).order_by("-created")
 threads = mk_paginator(request, threads, 20)
 forum = Forum.objects.get(pk=pk)
 return render_to_response("forum/forum.html", add_csrf(request, threads=threads, pk=pk, forum=forum))
def thread(request, pk):
#def thread(request,forum_pk, pk):
 """Listing of posts in a thread."""
 posts = Post.objects.filter(thread=pk).order_by("created")
 posts = mk_paginator(request, posts, 15)
 t = Thread.objects.get(pk=pk)
 f = Forum.objects.get(pk=t.forum.pk)
 return render_to_response("forum/thread.html", add_csrf(request, posts=posts, pk=pk, 
 forum_title=f.title,
 thread_title=t.title,
 forum_pk=t.forum.pk, media_url=MEDIA_URL))
def add_csrf(request, **kwargs):
 """Add CSRF to dictionary."""
 d = dict(user=request.user, **kwargs)
 d.update(csrf(request))
 return d
@login_required
def new_thread(request, pk):
 """Start a new thread."""
 p = request.POST
 if p["subject"] and p["body"]:
 forum = Forum.objects.get(pk=pk)
 thread = Thread.objects.create(forum=forum, title=p["subject"], creator=request.user)
 Post.objects.create(thread=thread, title=p["subject"], body=p["body"], creator=request.user)
 increment_post_counter(request)
 return HttpResponseRedirect(reverse("forum.views.forum", args=[pk]))
@login_required
def reply(request, pk):
 """Reply to a thread."""
 p = request.POST
 if p["body"]:
 thread = Thread.objects.get(pk=pk)
 post = Post.objects.create(thread=thread, title=p["subject"], body=p["body"],
 creator=request.user)
 return HttpResponseRedirect(reverse("forum.views.thread", args=[pk]) + "?page=last")
def increment_post_counter(request):
 profile = request.user.userprofile_set.all()[0]
 profile.posts += 1
 profile.save()
@login_required
def new_thread(request, pk):
 """Start a new thread."""
 p = request.POST
 if p["subject"] and p["body"]:
 forum = Forum.objects.get(pk=pk)
 thread = Thread.objects.create(forum=forum, title=p["subject"], creator=request.user)
 Post.objects.create(thread=thread, title=p["subject"], body=p["body"], creator=request.user)
 increment_post_counter(request)
 return HttpResponseRedirect(reverse("forum.views.forum", args=[pk]))
def mytest(request, pk):
 profile = UserProfile.objects.get(user=pk)
 p = request.POST
 return render_to_response("forum/mytest.html", {})
class ForumAdmin(admin.ModelAdmin):
 pass

Forum app urls:

from django.conf.urls import patterns, include, url
urlpatterns = patterns('forum.views',
 url(r'^$', 'main'),
 url(r'^forum/(\d+)/$', 'forum'),
 url(r'^thread/(\d+)/$', 'thread'),
 url(r"^post/(new_thread|reply)/(\d+)/$", "post"),
 url(r"^reply/(\d+)/$", "reply"),
 url(r"^new_thread/(\d+)/$", "new_thread"),
 url(r"^profile/(\d+)/$", "profile"),
 url(r"^save_profile/(\d+)/$", "save_profile"),
 url(r"^mytest/(\d+)/$", "mytest"),
)

Registration app urls:

from django.conf.urls import patterns, include, url
urlpatterns = patterns('registration.views',
 url(r'^logout/$', 'logout'),
 url(r'^login/$', 'login'),
 url(r'^register/$', 'register_user'),
 url(r'^register_success/$', 'register_success'),
 url(r'^auth/$', 'auth_view'),
 url(r'^loggedin/$', 'loggedin'),
 url(r'^invalid/$', 'invalid_login'),
)

Project urls:

from django.conf.urls import patterns, include, url
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('',
 # user authentication urls
 #url(r'^accounts/', include('djangoapp.urls')),
 # user registration urls
 url(r'^accounts/', include('registration.urls')),
 # admin
 url(r'^admin/', include(admin.site.urls)),
 # blog
 url(r'^blogs/', include('blog.urls')),
 # forum
 url(r'^forums/', include('forum.urls')),
 # django default
 url(r'^$', 'djangoapp.views.home', name='home'),
 # myapp - image upload
 url(r'^myapp/', include('myapp.urls')),
)

from django.shortcuts import render_to_response
from django.http import HttpResponseRedirect
from django.contrib import auth
from django.core.context_processors import csrf
from django.contrib.auth.forms import UserCreationForm
# Create your views here.
def logout(request):
 auth.logout(request)
 return render_to_response("logout.html")
def login(request):
 c = {}
 c.update(csrf(request))
 return render_to_response("login.html", c)
def auth_view(request):
 '''
 username = request.POST.get('username', '')
 password = request.POST.get('password', '')
 '''
 username = request.POST['username']
 password = request.POST['password']
 user = auth.authenticate(username=username, password=password)
 if user is not None:
 auth.login(request, user)
 return HttpResponseRedirect('/dj/accounts/loggedin')
 else:
 return HttpResponseRedirect('/dj/accounts/invalid')
def loggedin(request):
 return render_to_response('loggedin.html',
 {'full_name': request.user.username})
def invalid_login(request):
 return render_to_response('invalid_login.html')
def register_user(request):
 # 2nd time around
 if request.method == 'POST':
 # form = MyRegistrationForm(request.POST)
 form = UserCreationForm(request.POST)
 if form.is_valid():
 form.save()
 return HttpResponseRedirect('/dj/accounts/register_success')
 # 1st time visit
 args = {}
 args.update(csrf(request))
 # form with no input
 # args['form'] = MyRegistrationForm()
 args['form'] = UserCreationForm()
 print args
 # passing form
 return render_to_response('register.html', args)
def register_success(request):
 return render_to_response('register_success.html')

All files including templates are available: forum.tar.gz and registration.tar.gz.