def chat(request):
vars = {
"isFirstPage":True
}
if request.is_ajax():
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
if len( form.clean()['text'] ) > 4:
form.save()
return HttpResponse(status=200) # OK!
return HttpResponse(status=404) #CHANGE THIS
if request.method == 'GET':
posts = Post.active.order_by('-date_created')[:LIST_ITEM_LIMIT]
client_post = int(float( request.GET.get('s', '0') ) )
current_post = int(float( posts[0].id ) )
number_of_posts = current_post - client_post
if number_of_posts != 0:
vars['posts'] = posts[0:number_of_posts]
return render(request,'_chat.html', vars)
return HttpResponse(status=302) # Not changed
vars['form'] = PostForm()
vars['posts'] = Post.active.order_by('-date_created')[:LIST_ITEM_LIMIT]
return render(request,'chat.html', vars)
def read_article(request,user_id=None, id=None):
"""
Read article
"""
vars = {
'categories': defaultArticleCategories.objects.all(),
'ArticleBodyForm': ArticleCommentForm(),
}
if id==None:
"""
return all articles
"""
vars['notes'] = Notification.objects.filter(receiver=request.user, instance_type="ArticleComment")
return render(request,'articles.html', vars)
vars['article'] = Article.objects.get(id=id)
if vars['article'].allow_comments:
vars['comments'] = ArticleComment.objects.filter(post=vars['article'])
if user_id:
template = "user_article.html"
vars['user'] = User.objects.get(pk=user_id)
else:
template = "article.html"
return render(request,template, vars)
def auth_register(request):
"""
register a user
"""
#return render(request,'comming_soon.html')
vars = {
'body_id':'page_register',
'UserCreationForm': UserCreationForm( data = request.POST or None ),
'nextpage': request.GET.get('next', reverse('start')),
}
if request.method == 'POST':
if vars['UserCreationForm'].is_valid():
username = vars['UserCreationForm'].cleaned_data['username']
password = vars['UserCreationForm'].cleaned_data['password1']
# Try/except är en koll för att kolla om det redan finns en användare med samma namn
try:
User.objects.get(username__iexact=username)
return render(request, 'register.html', vars)
except:
vars['UserCreationForm'].save()
user = authenticate(username=username, password=password)
login(request, user)
profile, created = Profile.objects.get_or_create(user=user)
return HttpResponseRedirect(vars['nextpage'])
return render(request, 'register.html', vars)
def create_article(request, tags=None):
"""
Create article
"""
vars = {
'form':ArticleForm( user=request.user ),
'tagform' : DefaultArticleTagsForm(),
'categories':defaultArticleCategories.objects.all(),
'moderator_categories': ModeratorArticleCategories.objects.all(),
}
if tags != None:
initial_tags = tags.split(',')
vars['tagform'] = DefaultForumTagsForm(initial={'default_tags': initial_tags })
if request.method == 'POST':
form = ArticleForm(request.POST, user=request.user)
tagform = DefaultArticleTagsForm(request.POST)
vars['form'] = form
vars['tagform'] = tagform
if form.is_valid() & tagform.is_valid():
default_tags = tagform.cleaned_data['default_tags']
user_tags = form.cleaned_data['tags']
user_sub_tags = form.cleaned_data['user_tags']
# Combine and remove doubles
all_tags = list(set(default_tags + user_tags + user_sub_tags))
# Check if a default tag is present
if len(default_tags) == 0:
messages.add_message(request, messages.INFO, 'Du måste välja minst en huvudkategori!')
return render(request,'create_article.html', {'form': form,'tagform':tagform, 'categories':vars['categories']})
# Check maximum allowed tags
if len( all_tags ) > 5:
messages.add_message(request, messages.INFO, 'Du kan inte välja fler än fem kategorier!')
return render(request, 'create_article.html', {'form': form,'tagform':tagform, 'categories':vars['categories']})
post_values = request.POST.copy()
all_tags = validate_internal_tags(request, all_tags)
post_values['tags'] = ', '.join(all_tags)
try:
if post_values['allow_comments'] == "on":
post_values['allow_comments'] = True
except:
post_values['allow_comments'] = False
form = ArticleForm(post_values, user=request.user)
link = form.save()
return HttpResponseRedirect(reverse('read_article', args=[link.id]))
return render(request,'create_article.html', vars)
def create_forum(request, tags=None):
if tags:
initial_tags = tags.split(',')
tagform = DefaultForumTagsForm(initial={'default_tags': initial_tags })
else:
tagform = DefaultForumTagsForm()
vars = {
'form' : ForumForm( user=request.user ),
'tagform' : tagform,
'categories' : defaultCategories.objects.all(),
}
if request.method == 'POST':
form = ForumForm(request.POST, user=request.user)
tagform = DefaultForumTagsForm(request.POST)
if form.is_valid() & tagform.is_valid():
default_tags = tagform.cleaned_data['default_tags']
user_tags = form.cleaned_data['tags']
user_sub_tags = form.cleaned_data['user_tags']
# Filter list from empty strings
cleaned_tags = filter(None, user_tags)
# Combine and remove doubles
all_tags = list(set(default_tags + cleaned_tags + user_sub_tags))
# Check if a default tag is present
if len(default_tags) == 0:
messages.add_message(request, messages.INFO, 'Du måste välja minst en huvudkategori!')
return render(request, 'create_forum.html', {'form': form,'tagform':tagform, 'categories':vars['categories']})
# Check maximum allowed tags
if len( all_tags ) > 5:
messages.add_message(request, messages.INFO, 'Du kan inte välja fler än fem kategorier!')
return render(request, 'create_forum.html', {'form': form,'tagform':tagform, 'categories':vars['categories']})
post_values = request.POST.copy()
# Validate INTERNAL tags
all_tags = validate_internal_tags(request, all_tags)
post_values['tags'] = ', '.join(all_tags)
form = ForumForm(post_values, user=request.user)
link = form.save()
return HttpResponseRedirect(reverse('read_forum', args=[link.id]))
return render(request, 'create_forum.html', vars )
def update_entry(request, app_label, class_name, id):
vars = {}
# Check if theres an valid instance
try:
model = get_model(app_label, class_name)
if model:
instance = model.objects.get(id=id)
except ObjectDoesNotExist:
return HttpResponse(status=404) # No valid instance
# Check if user can edit instance
if instance.created_by != request.user:
HttpResponse(status=401) # User not auth
# if there any fields to edit
if not instance.ajax_editable_fields:
return HttpResponse(status=404) # No field to edit
if request.method == 'GET':
# Get form
fields = instance.ajax_editable_fields
form = update_entry_form( fields, model, instance=instance)
vars['instance'] = instance
vars['fields'] = fields
vars['form'] = form
vars['action'] = reverse('update_entry', args=[app_label, class_name, id])
if request.method == 'POST':
fields = instance.ajax_editable_fields
form = update_entry_form( fields, model, request.POST, instance=instance)
if form.is_valid():
form.save()
instance.date_last_changed = datetime.datetime.now()
instance.save()
vars['instance'] = instance
for field in fields:
vars[field] = getattr(instance,field)
if request.is_ajax():
return render(request, 'update_entry_form.html', vars )
return redirect( request.META['HTTP_REFERER'] )
return HttpResponse(status=401)
return render(request, 'update_entry_form.html', vars )
def chatpost(request,id,type):
"""
API for GET posts in HTML
Later this will also return
json and xml depending on <type>
"""
try:
post = Post.objects.get(id=id)
except:
# "no match"
raise Http404
if request.method == 'GET':
if type == 'html':
form = PostForm()
posts = [post]
return render(request,'chat.html', {"posts":posts,"form":form})
else:
# "wrong format"
raise Http404
else:
# "wrong method"
raise Http404
def notifications(request):
vars = {
'notifications' : request.user.receiver_entries.all(),
}
return render(request, "notifications.html", vars )
def guestbook(request,userid):
"""
Guestbook
"""
user = User.objects.get(pk=userid)
entries = Guestbooks.active.filter(user_id=user.id).order_by('-date_created')
vars = {
'form' : GuestbookForm(),
'entries' : entries,
'profile' : user.get_profile(),
'user' : user,
}
if request.user.id == int( float( userid ) ):
vars['page_title'] = u'Din egen gästbok'
else:
vars['page_title'] = u'{0} gästbok'.format(user)
if request.method == 'POST':
_post_guestbook(request, userid)
if request.is_ajax():
return HttpResponse(status=200)
else:
template = "guestbook.html"
return render(request, template, vars )
def update_article(request,id):
"""
Update article
"""
vars = {}
return render(request,'article.html', vars)
def history_entry(request, app_label, class_name, id):
vars = {}
# Check if theres an valid instance
try:
model = get_model(app_label, class_name)
if model:
instance = model.objects.get(id=id)
except ObjectDoesNotExist:
return HttpResponse(status=404) # No valid instance
# Check if history is allowed
if instance.allow_history and instance.fields_history:
versions = Version.objects.get_for_object(instance)
history_diff = []
for version in versions:
for field in instance.fields_history:
history = version.field_dict.get(field, None)
current = instance.__dict__.get(field, None)
if history != current:
history_diff += [{'content':history,'date':version.revision.date_created}]
vars['history'] = history_diff #versions #Version.objects.get_for_object(instance)
else:
return HttpResponse(status=401) # Not allowed
return render(request, 'history_entry_template.html', vars )
def read_frontpage(request):
vars = {
'articles' : Article.active.filter(tags__name__in=["FRONTPAGE"]).order_by('-id'),
}
return render(request, 'frontpage.html', vars )
def auth_login(request):
"""
Log in a user
"""
vars = {
'body_id':'page_login',
'AuthenticationForm': AuthenticationForm( data = request.POST or None ),
'nextpage': request.GET.get('next', reverse('start')),
}
if request.method == 'POST':
if vars['AuthenticationForm'].is_valid():
user = vars['AuthenticationForm'].get_user()
if user.is_active:
login(request, user)
if request.POST.get('keep_session', None):
request.session.set_expiry(timedelta(days=365))
else:
request.session.set_expiry(0)
return HttpResponseRedirect(vars['nextpage'])
return render(request, 'login.html', vars)
def auth_login(request):
"""
Log in a user
"""
vars = {"body_id": "page_login"}
if request.method == "POST":
username = request.POST["username"]
password = request.POST["password"]
user = authenticate(username=username, password=password)
if user is not None:
"""
if not user.is_staff:
messages.add_message(request, messages.INFO, "Siten inte öppen.")
return render(request, 'comming_soon.html')
"""
if user.is_active:
login(request, user)
request.session.set_expiry(0)
return HttpResponseRedirect(reverse("start"))
else:
messages.add_message(request, messages.INFO, "Ej aktiv användare")
else:
messages.add_message(request, messages.INFO, "Fel användarnamn eller lösenord.")
return render(request, "login.html")
def delete_entry(request, app_label, class_name, id):
vars = {}
# Check if theres an valid instance
try:
model = get_model(app_label, class_name)
if model:
instance = model.objects.get(id=id)
except ObjectDoesNotExist:
return HttpResponse(status=404) # No valid instance
# Check if user can delete instance
if instance.created_by != request.user and instance.is_deleteble:
HttpResponse(status=401) # User not auth
if request.method == 'GET':
# Get form
form = delete_entry_form()
vars['form'] = form
if request.method == 'POST':
form = delete_entry_form( request.POST )
if form.is_valid():
instance.delete()
return HttpResponse(status=200)
return HttpResponse(status=428)
return render(request, 'update_entry_form.html', vars )
def guestbook_conversation(request,sender_id,reciver_id):
A = int( float (sender_id) )
B = int( float (reciver_id) )
vars = {
'form' : GuestbookForm(),
}
users = [A, B]
kompis = None
for user in users:
if user != request.user.id:
kompis = User.objects.get(id=user)
# if user can see the converstion
if request.user.id in users:
entrys_from_A_to_B = Q(created_by__id = A) & Q(user_id__id = B)
entrys_from_B_to_A = Q(created_by__id = B) & Q(user_id__id = A)
vars['entries'] = Guestbooks.active.filter(entrys_from_A_to_B | entrys_from_B_to_A).order_by('-date_created')
vars['page_title'] = u'Gästbokskonversation mellan dig och {0}'.format(kompis)
if request.method == 'POST':
_post_guestbook(request, kompis.id)
return render(request, "guestbook.html", vars )
return HttpResponse(status=401)
def auth_logout(request):
"""
Log out a user
"""
logout(request)
return render(request, "login.html")
def delete_article(request,id):
"""
Delete article
"""
vars = {}
return render(request,'article.html', vars)
def notifications(request):
vars ={}
notifications = Notification.objects.filter(receiver=request.user)
vars['notifications'] = notifications
return render(request, "notifications.html", vars )
def get_threads_by_tags(request,tags):
categories = defaultCategories.objects.all()
tags_array = tags.split(",")
threads = Thread.active.filter(tags__name__in=tags_array)
if len( threads ) < 1:
messages.add_message(request, messages.INFO, 'Hittade inga trådar =(')
return render(request, 'old_forum.html', {"threads": threads,"categories":categories,"tags":tags})
def read_forum(request, id):
vars = {
'categories': defaultCategories.objects.all(),
'ArticleBodyForm': ForumCommentForm(),
}
vars['forum'] = Forum.objects.get(id=id)
vars['comments'] = ForumComment.objects.filter(post=vars['forum'])
return render(request, 'read_forum.html', vars )
def camchat(request):
"""
Temporary chamchat
"""
vars = {
'app_name':'camchat'
}
messages.add_message(request, messages.INFO, 'Lösenord är:fisk')
return render(request,'tinychat.html', vars)
def chat(request):
"""
Chat view, render chat page
"""
vars = {
'form' : PostForm(),
'comments' : Post.active.order_by('-date_created').select_related('created_by','created_by__profile__photo').order_by('-id')[:site_settings.CHAT_LIST_ITEM_LIMIT]
}
return render(request,'chat.html', vars)
def chatposts(request,id1,id2,type):
"""
API for GET a range of posts in HTML
"""
vars = {
'isFirstPage': False,
'isLastPage': False,
}
# Check order
if int(id1) > int(id2):
# "reverse"
start = int(id2)
stop = int(id1)
else:
# " not reverse"
start = int(id1)
stop = int(id2)
# Check if theres a negative value or its the first page
if start <= 1:
# "First page"
vars['isLastPage'] = True
start = 1
try:
# Add +1 padding to deteminate if its any more posts
posts = Post.objects.filter(id__range=(start,stop+1)).order_by('-date_created')
# Control if its the last page
if posts[0].id <= stop:
vars['isFirstPage'] = True
else:
# Trim query to match orginal request
posts = posts[1:LIST_ITEM_LIMIT+1]
except:
# "no match"
raise Http404
if request.method == 'GET':
if type == 'html':
form = PostForm()
vars['posts'] = posts
vars['form'] = form
return render(request,'chat.html', vars)
else:
#"wrong format"
raise Http404
else:
# "wrong method"
raise Http404
def read_article(request,user_id=None, id=None):
"""
Read article
"""
vars = {
'categories': defaultArticleCategories.objects.all(),
'commentform': ArticleCommentForm(),
}
if id==None:
"""
return all articles
"""
# Tar bara upp notifikationer
vars['notes'] = request.user.receiver_entries.filter(content_type__model = 'ArticleComment')
return render(request,'articles.html', vars)
vars['article'] = Article.objects.get(id=id)
if vars['article'].allow_comments:
vars['comments'] = ArticleComment.objects.filter(post=vars['article'])
if user_id:
template = "user_article.html"
vars['user'] = User.objects.get(pk=user_id)
else:
template = "article.html"
try:
article_note = request.user.receiver_entries.filter(content_type__model = 'article', object_id = id)
except:
article_note = []
for note in article_note:
note.delete()
return render(request,template, vars)
def read_frontpage(request):
articles = Article.active.filter(tags__name__in=["FRONTPAGE"]).select_related('created_by','created_by__profile__photo').order_by('-id')
articles = list( articles )
articles_ids = [article.id for article in articles]
vars = {
'articles' : articles,
}
return render(request, 'frontpage.html', vars )
def auth_register(request):
"""
register a user
"""
# return render(request,'comming_soon.html')
vars = {"body_id": "page_register"}
if request.method == "POST":
form = RegisterForm(request.POST)
if form.is_valid():
username = form.cleaned_data["username"]
password = form.cleaned_data["password1"]
try:
User.objects.get(username__iexact=username)
vars["form"] = form
messages.add_message(request, messages.INFO, "Användare {0} finns redan.".format(unicode(username)))
return render(request, "register.html", vars)
except:
form.save()
form = AuthenticationForm()
messages.add_message(request, messages.INFO, "Användare skapad.")
user = authenticate(username=username, password=password)
login(request, user)
profile, created = Profile.objects.select_related().get_or_create(user=user)
return HttpResponseRedirect(reverse("start"))
else:
messages.add_message(request, messages.INFO, "Fel fel fel fel")
else:
form = RegisterForm()
vars["form"] = form
return render(request, "register.html", vars)
def preview(request):
if request.method == 'POST':
if request.is_ajax():
preview_id = request.POST.get('preview', None)
if preview_id:
preview = request.POST.get(preview_id.strip(), None)
if preview:
return render(request, 'preview.html', {'preview':preview} )
return HttpResponse(status=404)
def auth_reset_password(request):
"""
reset user password
"""
vars = {
'PasswordResetForm':PasswordResetForm( data = request.POST or None ),
}
if request.method == 'POST':
if vars['PasswordResetForm'].is_valid():
vars['PasswordResetForm'].save()
return render(request, 'reset_password.html', vars)
def ajax_comments_article(request, article_id):
if request.is_ajax():
vars = {
'comments' : ArticleComment.objects.filter(post__id=article_id),
'article_id': article_id,
'commentform': ArticleCommentForm(),
'app_name': "articles",
'model_name': "ArticleComment",
'post_url': reverse('comment_article', args=[article_id]),
}
return render(request, '_article_comments.html', vars )
raise Http404
