def post_add(request):
if request.method == "POST":
f = PostForm(request.POST)
if f.is_valid():
# if author is not selected and user is superuser, then assign the post to staff
if request.POST.get('author') == "" and request.user.is_superuser:
new_post = f.save(commit=False)
author = Author.objects.get(user__username='******')
new_post.author = author
new_post.save()
f.save_m2m()
# if author is selected and user is superuser
elif request.POST.get('author') and request.user.is_superuser:
new_post = f.save()
# if user is not a superuser
else:
new_post = f.save(commit=False)
new_post.author = Author.objects.get(
user__username=request.user.username)
new_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post added')
return redirect('post_add')
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
# If request is POST, create a bound form(form with data)
if request.method == "POST":
f = PostForm(request.POST, instance=post)
# check whether form is valid or not
# if the form is valid, save the data to the database
# and redirect the user back to the update post form
# If form is invalid show form with errors again
if f.is_valid():
f.save()
messages.add_message(request, messages.INFO, 'Post updated.')
return redirect(reverse('post_update', args=[post.id]))
# if request is GET the show unbound form to the user, along with data
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
def post_update(request, post_id=None):
if not post_id:
return redirect('blog:index')
title = 'DevInCafe | UPDATE'
context = {
'WEB_TITLE': title,
}
try:
post = Post.objects.get(id=post_id, author=request.user)
except ObjectDoesNotExist:
return redirect('blog:index')
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('blog:index')
else:
form = PostForm(instance=post)
context.update({'form': form})
return render(request, 'blog/pages/add_post.html', context)
def post_add(request):
#If request is POST, create a bound forms
if request.method == 'POST':
f = PostForm(request.POST)
if f.is_valid():
if request.POST.get('author') == '' and request.user.is_superuser:
new_post = f.save(commit=False)
author = Author.objects.get(user__username='******')
new_post.author = author
new_post.save()
f.save_m2m()
elif request.POST.get('author') and request.user.is_superuser:
new_post = f.save()
else:
new_post = f.save(commit=False)
new_post.author = Author.objects.get(
user__username=request.user.username)
new_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post added')
return redirect('post_add')
else:
print(f.errors)
#if form is valid, save data to database, redirect back to post_add view
#if request is GET, show unbound form
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
class PostUpdate(TemplateView, PageNumberMixin):
post = None
template_name = "post_edit.html"
form = None
def get(self, request, *args, **kwargs):
self.post = Post.objects.get(pk=self.kwargs["pk"])
self.form = PostForm(instance=self.post)
return super(PostUpdate, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(PostUpdate, self).get_context_data(**kwargs)
context["post"] = self.post
context["form"] = self.form
return context
def post(self, request, *args, **kwargs):
self.post = Post.objects.get(pk=self.kwargs["pk"])
self.form = PostForm(request.POST, instance=self.post)
if self.form.is_valid():
self.form.save()
messages.add_message(request, messages.SUCCESS,
"Пост успешно изменен")
redirect_url = reverse(
"index") + "?page=" + self.request.GET["page"]
return redirect(redirect_url)
else:
return super(PostUpdate, self).get(request, *args, **kwargs)
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
# If request is POST, create a bound form(form with data)
if request.method == "POST":
f = PostForm(request.POST, instance=post)
if f.is_valid():
# if author is not selected and user is superuser, then assign the post to the author named staff
if request.POST.get('author') == "" and request.user.is_superuser:
updated_post = f.save(commit=False)
author = Author.objects.get(user__username='******')
updated_post.author = author
updated_post.save()
f.save_m2m()
# if author is selected and user is superuser
elif request.POST.get('author') and request.user.is_superuser:
updated_post = f.save()
# if user is not a superuser
else:
updated_post = f.save(commit=False)
updated_post.author = Author.objects.get(
user__username=request.user.username)
updated_post.save()
f.save_m2m()
messages.add_message(request, messages.INFO, 'Post updated')
return redirect(reverse('post_update', args=[post.id]))
# if request is GET the show unbound form to the user
else:
f = PostForm(instance=post)
return render(request, 'cadmin/post_update.html', {
'form': f,
'post': post
})
def post(self, request, *args, **kwargs):
print "post"
create_post = PostForm(request.POST)
if create_post.is_valid():
print "valid"
create_post.save()
return HttpResponseRedirect("/")
def add_post(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/profile/')
return render(request, 'blog/add.html', {'form': form})
def update(request, id):
post = Post.objects.get(id=id)
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect("/blog")
return render(request, 'blog/edit.html', {'post': post})
def add_post(request):
form = PostForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save();
messages.add_message(request, messages.SUCCESS, 'POST GUARDADO CORRECTAMENTE')
return HttpResponseRedirect('/posts/')
return render (request, 'form_posts.html', {'form':form})
def add_post_view(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(data=request.POST, files=request.FILES)
if form.is_valid():
form.save()
return redirect('base')
print(form.cleaned_data)
return render(request, 'blog/form.html', locals())
def update_post(request, postId):
instance = get_object_or_404(Post, id=postId)
form = PostForm (request.POST or NONE, instance=instance)
if request.method == 'POST':
if form.is_valid():
form.save();
messages.add_message(request, messages.SUCCESS, 'POST actualizado CORRECTAMENTE')
return HttpResponseRedirect('/posts/list/')
return render (request, 'form_post.html', {'form':form})
def index(request):
print("DIGGU >>>>>>>>>>>>>>>>>>>>>>>")
if request.method == "GET":
form_post = PostForm()
return render(request, 'form.html', {'form': form_post.as_table()})
elif request.method == "POST":
form_post = PostForm(request.POST)
form_post.save()
return render(request, 'index.html', {})
def create_post(request):
if request.method == "POST":
form = PostForm(request.POST, user=request.user)
if form.is_valid():
form.save()
return redirect('/')
else:
form = PostForm()
return render(request, 'create-post.html', {'form': form})
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect("index")
else:
form = PostForm()
return HttpResponseRedirect("/")
def post_new(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect('index')
else:
return redirect('post_edit')
return render_to_response('blog/post_edit.html', {'form': form}, RequestContext(request))
def createPost(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('home-url')
data = {'form': form}
return render(request, template_name='blog/createPost.html', context=data)
def update_post(request, id):
post = Post.objects.get(pk=id)
form = PostForm(instance=post)
if request.method == 'POST':
post = Post.objects.get(pk=id)
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return HttpResponseRedirect('/profile/')
return render(request, 'blog/add.html', {'form': form})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
post = Post.objects.get(title=form.cleaned_data['title'])
return HttpResponseRedirect(reverse('blog.views.get_post',args=(post.slug,)))
else:
form = PostForm()
return render_to_response('post_form.html', {'form':form, 'new':True}, RequestContext(request))
def post(request):
post_list = PostForm()
ctx = {'post_list': post_list}
if request.method == 'POST':
com = PostForm(data=request.POST)
com.save()
return redirect('blog:home')
else:
pass
return render(request, template_name='blog/new_post.html', context=ctx)
def form2(request):
if request.method == 'GET':
return render(request, 'form2.html', { 'form' : PostForm(), 'site_header' : 'THIS' })
elif request.method == 'POST':
form_post = PostForm(request.POST)
if form_post.is_valid():
form_post.save()
return redirect('/blog/')
return render(request, 'form2.html', { 'form' : form_post })
def edit_post(request, post_id):
blog_entry = get_object_or_404(BlogEntry, pk=post_id)
if request.method == 'POST':
form = PostForm(request.POST, instance=blog_entry)
if form.is_valid():
form.save()
return render_to_response('viewpost.html', {'blog_entry': blog_entry})
form = PostForm(instance=blog_entry)
csrfContext = RequestContext(request, {'form':form, 'blog_entry':blog_entry})
return render_to_response('editpost.html', csrfContext)
def edit_post(request, posid):
context=RequestContext(request)
pos=Post.objects.get(pk=posid)
form = PostForm(request.POST or None, instance=pos)
if form.is_valid():
form.save()
return added(request)
return render_to_response('blog/edit_post.html', {'form':form, 'pos_id':posid}, context)
def post_create(request):
form = PostForm(request.POST or None, request.FILES or None)
title = 'Create'
author = get_author(request.user)
if form.is_valid():
form.instance.author = author
form.save()
return redirect(reverse('post', kwargs={'pk': form.instance.pk}))
return render(request, 'post_create.html', {'form': form, 'title': title})
def createPost(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect('post_list')
context = {'form': form}
return render(request, 'blog/post_form.html', context)
def post_new(request):
if request.method == "POST":
form=PostForm(request.POST, request.FILES)
if form.is_valid():
form = form.save(commit=False)
form.author = request.user
form.save()
return redirect("blog:post_list")
else:
post_form = PostForm()
return render(request, 'blog/post_form.html', {'post_form':post_form})
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return redirect('blog:post_list')
else:
form=PostForm()
return render(request,'blog/post_form.html', {
'form': form,
})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('blog:home'))
else:
form = PostForm()
return render(request, 'articles/add_post.html', {'form': form})
def add_post(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES)
if form.is_valid(): # is the form valid?
form.save(commit=True) # yes? save to database
return redirect(index)
else:
print(form.errors) # no? display errors to end user
else:
form = PostForm()
return render(request, "blog/add_post.html", {"form": form})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid(): # is the form valid?
form.save(commit=True) # yes? save to database
return redirect(index)
else:
print(form.errors) # no? display errors to end user
else:
form = PostForm()
return render(request, 'blog/add_post.html', {'form': form})
def edit_post(request, pk):
post = get_object_or_404(Post, pk=pk)
form = PostForm(request.POST or None, instance=post)
if form.is_valid():
form.save()
messages.success(request, "Your Post has been Updated")
return redirect('post_list')
else:
form = PostForm(instance=post)
return render(request, 'blog/post_create.html', {'form': form, 'post': post})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save(commit=True)
return redirect(index)
else:
print("form.errors")
else:
form = PostForm()
return render(request, 'blog/add_post.html', {'form': form})
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form = form.save(commit=False)
form.author = request.user
form.save()
return redirect("blog:post_list")
else:
post_form = PostForm()
return render(request, 'blog/post_form.html', {'post_form': post_form})
def post_add(request):
if request.method == 'POST':
f = PostForm(request.POST)
if f.is_valid():
f.save()
return redirect('post_add')
else:
f = PostForm()
return render(request, 'cadmin/post_add.html', {'form': f})
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('blog:post_list')
else:
form = PostForm()
return render(request, 'blog/post_form.html', {
'form': form,
})
def post(self, request):
form = PostForm(request.POST, request.FILES)
if form.is_valid():
if str(request.user.profile.id) == form.data.get('author'):
post = form.save()
else:
post = form.save()
post.author = request.user.profile
post.save()
return redirect(post.get_absolute_url())
return render(request, 'blog/create_post.html', context={'form': form})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid(): # is the form valid
form.save(commit=True) # yes? save to database
return post(None, form.cleaned_data['title'])
else:
print(form.errors) # no? display errors to end user
else:
form = PostForm()
return render(request, 'add_post.html', {'form': form})
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save(commit=True)
return redirect(index)
else:
print form.errors
else:
form = PostForm()
return render_to_response('blog/add_post.html', {'form': form}, context)
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid(): # is the form valid
form.save(commit=True) # yes and save to db
return redirect(index)
else:
print form.errors # no, display error to end user
else:
form = PostForm()
return render_to_response('blog/add_post.html', {'form': form}, context)
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save(commit = True) #save form data to database
return redirect(index_url_styles)
else :
print form.errors #show errors to user
else:
form = PostForm()
return render_to_response('blog/add_post_simple.html', {'form' : form}, context)
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid(): # is the form valid?
form.save(commit=True) # yes, then save to db
#return redirect(index)
return redirect('/blog/{0}'.format(encode_url(form.cleaned_data['title'])))
else:
print form.errors #no, then display errors to end user
else:
form = PostForm()
return render_to_response('blog/add_post.html', {'form': form}, context)
def post_edit(request, pk):
post = get_object_or_404(Post,pk=pk)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
#redirt로 인스턴스를 보낸 것은 model에 def get_absolute_url에서 이게 있으면 checking해서 이곳으로 url 보냄
return redirect(post)
else:
form=PostForm(instance=post)
return render(request,'blog/post_form.html', {
'form': form,
})
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save(commit=True)
return index(request)
else:
print form.errors
else:
form = PostForm()
return render(request, 'blog/add_post.html', {'form': form})
def post_new(request):
args = {}
if request.method == 'POST':
form = PostForm(request.POST or None, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
i=0
ingredients1 = Ingredient.objects.all()
post.published_date = timezone.now()
print(request.POST.getlist('quantity'))
for item in request.POST.getlist('quantity'):
i=i+1
if int(item) !=0:
w = Wasted.objects.all().get(pk=i)
w.weight = int(item)
w.save()
if Ingredient.objects.all().get(name=w.name, pk=i).weight >0:
ingr = Ingredient.objects.all().get(name=w.name, pk=i)
ingr.weight = ingr.weight - w.weight
ingr.save()
else:
args['login_error'] = "нет на складе продукта"
args['login_error'] = args['login_error']+w.name
return render_to_response('post_new', args)
post.save()
form.save_m2m()
# post.ingredients()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
posts = Ingredient.objects.all()
return render(request, 'blog/post_edit.html', {'form': form, 'posts': posts})
def post_new(request):
# ImageFormSet = modelformset_factory(Resource, form=ResourceForm, extra=3)
if request.method == "POST":
postForm = PostForm(request.POST)
formset = ResourceForm(request.POST, request.FILES)
if postForm.is_valid():
post = postForm.save(commit=False)
post.author = request.user
post.save()
for image in request.FILES.getlist("images", []):
# img = image_resizing(image)
photo = Resource(post=post, image_file=image)
photo.save()
return redirect('blog.views.post_detail', pk=post.pk)
# for form in formset.cleaned_data:
# image = form['image_file']
# photo = Resource(post=post, image_file=image)
# photo.save()
else:
postForm = PostForm()
formset = ResourceForm()
return render(request, 'blog/post_edit.html', {'postForm': postForm, 'formset': formset}, context_instance=RequestContext(request))
def new(request, id=None):
if id is not None:
post = get_object_or_404(Post, id=id)
else:
post = None
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
return redirect('blog:index')
else:
form = PostForm(instance=post)
return render(request, 'blog/post_form.html', {
'form': form,
})
def post_edit(request, pk):
# To check that the post is existing or not
post = get_object_or_404(Post, pk=pk)
# post = Post.objects.get(pk=pk)
# To check about user
if request.user != post.author:
return redirect('blog.views.errors')
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
# post.published_date = timezone.now()
post.save()
if request.FILES.getlist("images", []):
for resource in post.resources.all():
resource.delete()
for image in request.FILES.getlist("images", []):
photo = Resource(post=post, image_file=image)
photo.save()
return redirect('blog.views.post_detail', pk=post.pk)
else:
return redirect('blog.views.post_detail', pk=post.pk)
else:
postForm = PostForm(instance=post)
formset = ResourceForm(instance=post)
return render(request, 'blog/post_edit.html', {'postForm': postForm, 'formset': formset}, context_instance=RequestContext(request))
def new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.ip = request.META['REMOTE_ADDR']
# AWS Load Balancer 를 쓸 경우
# settings.USE_X_FORWARDED_HOST = True 여야,
# HTTP_X_FORWARDED_HOST META 정보에 값이 설정됩니다.
# post.ip = request.META['HTTP_X_FORWARDED_HOST']
post.save()
# post.author = request.user
# post = form.save(commit=False)
# post.category = get_object_or_404(Category, pk=1)
# post.save()
return redirect(post)
else:
form = PostForm()
return render(request, 'blog/form.html', {
'form': form,
})
def update(request, id):
form = PostForm(request.POST, instance=Post.objects.get(pk=id))
if form.is_valid():
post = form.save()
post.add_tags(request.POST['tags'])
return redirect(post.uri())
return render(request, 'blog/edit.html', {'post':post})
def post_create(request):
title = 'DevInCafe | NEW'
context = {
'WEB_TITLE': title,
}
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save(user=request.user)
return redirect('blog:index')
else:
form = PostForm()
context.update({'form': form})
return render(request, 'blog/pages/add_post.html', context)
def post_edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == "POST":
form = PostForm(request.POST or None, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
posts = Ingredient.objects.all()
post_numder = post.pk
for ing in request.POST.getlist('ingredients'):
theing = Ingredient.objects.get(pk=ing)
post.ingredients.add(theing.id)
post.save()
form.save_m2m()
# messages.success(request, "<a href='#'>Item</a> Saved", extra_tags='html_safe')
# return HttpResponseRedirect(instance.get_absolute_url())
context = {
"title": post.title,
"instance": post,
"form": form,
"posts":posts,
}
# return render(request, 'blog/post_edit.html', context)
return redirect('post_detail', pk=post.pk)
else:
form = PostForm(instance=post)
posts = Ingredient.objects.all()
return render(request, "blog/post_edit.html", {'form': form, 'posts': posts})
def create_post(request, slug):
blog = get_object_or_404(Blog, slug=slug)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
slug = generate_slug(post.title)
conflicts = Post.objects.filter(slug__startswith=slug)
if conflicts:
slug = get_unique_slug(slug, conflicts)
post.slug = slug
post.author = request.user
post.blog = blog
post.save()
# We don't want to start sending garbage requests while testing,
# and we only want to do this on the first save of a published post,
# not every update, otherwise we might get IP banned.
if not settings.DEBUG:
post.send_pingbacks()
return redirect('view_post', post.created.year, post.get_formatted_month(), post.slug)
else:
form = PostForm()
context = {
'blog': blog,
'post_form': form,
}
return render_to_response('blog/create_post.html', context, RequestContext(request))
def edit(request, pk=0, template_name="blog/edit.html"):
""" Edit a post """
user = request.user
post = None
posts = Post.objects.all()
if request.user.is_superuser:
if pk:
post = get_object_or_404(Post, pk=pk)
posts = Post.objects.exclude(id=post.pk)
posts = posts.filter(status__in=['draft', 'published'])
else:
if pk:
post = get_object_or_404(Post, pk=pk, user=request.user)
posts = Post.objects.exclude(id=post.pk)
posts = posts.filter(user=request.user,status__in=['draft', 'published'])
posts = posts.order_by('-pk')
if post:
user = post.user
kwargs = dict(instance=post,user=user,initial={'publish_dt':datetime.datetime.now()})
form = PostForm(request.POST or None, **kwargs)
if request.POST and form.is_valid():
post = form.save()
messages.success(request,'Edited post "%s".' % post)
return HttpResponseRedirect("/blog/admin/edit/%s/"%post.id)
values = {
'form': form,
'post': post,
'posts': posts,
}
return TemplateResponse(request, template_name, values)
def edit(request, pk):
post = get_object_or_404(Post, pk=pk)
# 수정하려는 사용자와 작성한 유저가 다르면 에러
if post.author != request.user:
pass
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
# post = form.save(commit=False)
# post.author = request.user
# post.save()
# 만약 폼에서 지정하지 못한 필수 필드가 있다면 아래와 같이
# 서버딴에서 필수 필드의 기본값을 설정하여 주는 방법으로 해결
# post = form.save(commit=False)
# post.category = get_object_or_404(Category, pk=1)
# post.save()
# return redirect('blog:detail', post.pk)
# models.py에서 get_absolute_url 함수가 정의된 경우 post만 넘겨도 가능하다.
return redirect(post)
else:
form = PostForm(instance=post)
return render(request, "blog/form.html", {"form": form})
def add_edit_post(request, slug=None):
if request.method == 'GET':
form = PostForm()
if slug: # If editing
post = get_object_or_404(Post, slug=slug)
if request.user.is_staff or request.user == post.author:
form = PostForm(instance=post)
else:
raise PermissionDenied
else: # POST
if not slug:
form = PostForm(request.POST)
else:
form = PostForm(request.POST, instance=get_object_or_404(Post, slug=slug))
if form.is_valid():
instance = form.save(commit=False)
if not getattr(instance, 'author'):
instance.author = request.user
if not request.user.is_staff:
instance.approved = False
instance.text = clean_untrusted_tags(instance.text)
instance.save()
form.save_m2m()
return render(request, 'add_post_success.html', {})
return render(request, 'add_edit_post.html', {
'form': form,
'edit': slug is not None
})
def add_post(request):
context = RequestContext(request)
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save(commit=True)
return added(request)
else:
print form.errors
else:
nn=request.META.__getitem__("USER")
print request
form = PostForm({'fk_CreatedBy': User.objects.get(username=request.user.username)} )
return render_to_response('blog/add_post.html', {'form':form}, context)
