def post(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs['pk'])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(request.POST, instance=self.blog)
if self.form.is_valid():
self.form.save()
messages.add_message(request, messages.SUCCESS,
'Статья успешно изменена')
redirect_url = reverse(
'blog_index') + '?page=' + self.request.GET['page']
try:
redirect_url = redirect_url + '&search=' + self.request.GET[
'page']
except KeyError:
pass
try:
redirect_url = redirect_url + '&tag=' + self.request.GET[
'tag']
except KeyError:
pass
return redirect(redirect_url)
else:
return super().get(request, *args, **kwargs)
else:
return redirect(reverse('login'))
def create_blog(request):
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
blog = Blog.objects.create(author=request.user,
title=cd['title'],
body=cd['body'],
column=cd['column'])
tags = request.POST.getlist('tags[]', [])
tag_list = []
for tag in tags:
tag_obj = Tag(name=tag, blog=blog)
tag_list.append(tag_obj)
Tag.objects.bulk_create(tag_list)
return JsonResponse({
"code":
200,
'msg':
'Created',
'url':
reverse('blog:blog_detail', kwargs={"slug": blog.slug})
})
else:
return JsonResponse({
"code": 400,
'msg': 'Invalid request' + str(form.errors)
})
else:
columns = Column.objects.all()
return render(request, 'myadmin/blog/blog.html', {"columns": columns})
def get(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs['pk'])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(instance=self.blog)
return super().get(request, *args, **kwargs)
else:
return redirect(reverse('login'))
def post(self, request, *args, **kwargs):
from blog.forms import BlogForm
from blog.models import Blog
from common.templates import render_for_platform
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
self.form_post = BlogForm(request.POST,
request.FILES,
instance=self.blog)
if request.is_ajax() and self.form_post.is_valid(
) and request.user.is_supermanager():
post = self.form_post.save(commit=False)
new_post = post.edit_blog(
title=post.title,
image=post.image,
description=post.description,
comments_enabled=post.comments_enabled,
votes_on=post.votes_on,
tags=request.POST.getlist("tags"),
manager_id=request.user.pk,
region=request.POST.getlist("region"),
elect=request.POST.getlist("elect"),
attach=request.POST.getlist("attach_items"))
return HttpResponse()
else:
from django.http import HttpResponseBadRequest
return HttpResponseBadRequest()
def blog_add(request):
if request.method == 'POST':
form = BlogForm(request.POST)
tag = TagForm(request.POST)
if form.is_valid() and tag.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
tagname = cdtag['tag_name']
for taglist in tagname.split():
Tag.objects.get_or_create(tag_name=taglist.strip())
title = cd['caption']
author = Author.objects.get(id=1)
content = cd['content']
blog = Blog(caption=title, author=author,
content=content)
blog.save()
for taglist in tagname.split():
blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
blog.save()
id = Blog.objects.order_by('-publish_time')[0].id
return HttpResponseRedirect('/myblog/blog/%s' % id)
#return HttpResponseRedirect(reverse('detailblog',args=[id]))
else:
form = BlogForm()
tag = TagForm(initial={'tag_name': 'notags'})
return render(request,'blog_add.html', {'form': form, 'tag': tag},
context_instance=RequestContext(request))
def put(self, request, id, *args, **kwargs):
# Parse the request body for updating the blog item
valid_json = is_vaid_json(request.body)
# Validation for invalid JSON body
if not valid_json:
error_data = json.dumps({"message": "Invalid JSON data!"})
return self.render_to_response(error_data, status=400)
original_data = self.get_id_details(id=id)
# Check if the data exists in the database with that ID
if original_data is None:
error_data = json.dumps(
{"message": "Item does not exists with that ID!"})
return self.render_to_response(error_data, status=404)
# serialize the original data from the database to JSON
og_data = json.loads(original_data.serialize())
passed_data = json.loads(request.body)
for key, value in passed_data.items():
og_data[key] = value
form = BlogForm(og_data, instance=original_data)
# If everything is valid
if form.is_valid():
# Save the data
original_data = form.save(commit=True)
updated_data = json.dumps(og_data)
return self.render_to_response(updated_data, status=201)
# If form validation fails
if form.errors:
data = json.dumps(form.errors)
return self.render_to_response(data, status=400)
json_data = json.dumps({"message": "Something went wrong!"})
return self.render_to_response(json_data)
def post(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(request.POST, instance=self.blog)
if self.form.is_valid():
self.form.save()
messages.add_message(request, messages.SUCCESS,
"Статья успешно изменена")
redirect_url = reverse(
"blog_index") + "?page=" + self.request.GET["page"]
try:
redirect_url = redirect_url + "&search=" + self.request.GET[
"search"]
except KeyError:
pass
try:
redirect_url = redirect_url + "&tag=" + self.request.GET[
"tag"]
except KeyError:
pass
return redirect(redirect_url)
else:
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def blog_add(request):
if request.method == 'POST':
form = BlogForm(request.POST)
tag = TagForm(request.POST)
if form.is_valid() and tag.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
tagname = cdtag['tag_name']
for taglist in tagname.split():
Tag.objects.get_or_create(tag_name=taglist.strip())
title = cd['caption']
author = Author.objects.get(id=1)
content = cd['content']
blog = Blog(caption=title, author=author, content=content)
blog.save()
for taglist in tagname.split():
blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
blog.save()
id = Blog.objects.order_by('-publish_time')[0].id
return HttpResponseRedirect('/myblog/blog/%s' % id)
#return HttpResponseRedirect(reverse('detailblog',args=[id]))
else:
form = BlogForm()
tag = TagForm(initial={'tag_name': 'notags'})
return render(request,
'blog_add.html', {
'form': form,
'tag': tag
},
context_instance=RequestContext(request))
def blog_update(request, id=""):
id = id
global blog,form,tag,paginator
if request.method == 'POST':
form = BlogForm(request.POST)
tag = TagaddForm(request.POST)
if form.is_valid() and tag.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
tagname = cdtag['tag_name']
tagnamelist = tagname.split()
for taglist in tagnamelist:
Tag.objects.get_or_create(tag_name=taglist.strip())
title = cd['caption']
content = cd['content']
blog = Blog.objects.get(id=id)
if blog:
blog.caption = title
blog.content = content
blog.save()
for taglist in tagnamelist:
blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
blog.save()
tags = blog.tags.all()
for tagname in tags:
tagname = unicode(str(tagname), "utf-8")
if tagname not in tagnamelist:
notag = blog.tags.get(tag_name=tagname)
blog.tags.remove(notag)
else:
blog = Blog(caption=blog.caption, content=blog.content)
blog.save()
# return HttpResponseRedirect('/sblog/blog/%s'% id)
blogs = Blog.objects.all()
paginator = Paginator(blogs, 4)
page = request.GET.get('page')
try:
contacts = paginator.page(page)
except PageNotAnInteger:
contacts = paginator.page(1)
except (EmptyPage,InvalidPage):
contacts = paginator.page(paginator.num_pages)
return render_to_response('admin_bloglist.html',{"content":content})
else:
try:
blog = Blog.objects.get(id=id)
except Exception:
raise Http404
form = BlogForm(initial={'caption': blog.caption, 'content': blog.content}, auto_id=False)
tags = blog.tags.all()
if tags:
taginit = ''
for x in tags:
taginit += str(x) + ' '
tag = TagaddForm(initial={'tag_name': taginit})
else:
tag = TagaddForm()
return render_to_response("admin_blogupdate.html", {'blog': blog, 'form': form, 'id': id, 'tag': tag},context_instance=RequestContext(request))
def blog_add(request):
author = Author.objects.all()
ification = Classification.objects.all()
tags = Tag.objects.all()
if request.method == 'POST':
af = BlogForm(request.POST)
if af.is_valid():
cd = af.cleaned_data
caption = cd['caption']
auid = request.POST.get('authorid')
auth = Author.objects.get(id=auid)
cationid = request.POST.get('ificationid')
ication = Classification.objects.get(id=cationid)
content = cd['content']
blog = Blog(caption = caption, author = auth, content = content, if_name = ication)
blog.save()
try:
tags = request.POST.getlist('answer',None)
for tag in tags:
blog.tags.add(Tag.objects.get(tag_name=tag))
blog.save()
except DoesNotExist:
raise Http404
return HttpResponseRedirect('/blog/admin/blog_list/')
else:
af = BlogForm()
return render_to_response('admin_badd.html',locals(), context_instance=RequestContext(request))
def edit(request, id):
"""
Edit an existed blog by blog's id
"""
blog = Blog.objects.get(id=id)
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
data = form.cleaned_data
blog.group = data['group']
blog.status = data['status']
blog.title = data['title']
blog.tag = data['tag']
blog.content = data['content']
blog.summary = data['summary']
blog.update_date = datetime.datetime.now()
blog.save()
return HttpResponseRedirect('/adminshow/%s/' % blog.id)
else:
form = BlogForm({
'group' : blog.group_id,
'status' : blog.status_id,
'title' : blog.title,
'tag' : blog.tag,
'content' : blog.content,
'summary' : blog.summary})
return render_to_response('new.html', {'form':form, 'blog':blog}, context_instance=RequestContext(request, processors=[new_blog, blog_group]))
def get(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk = self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(instance = self.blog)
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def create_post(request):
form = BlogForm(request.POST or None, request.FILES or None)
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, "Created successfully")
return redirect('dashboard')
context = {'form': form}
return render(request, 'create_post.html', context)
def editpost(request, id):
data = Blog.objects.get(pk=id)
form = BlogForm(request.POST or None, request.FILES or None, instance=data)
if form.is_valid():
form.save()
messages.add_message(request, messages.SUCCESS, "update successfully")
return redirect('dashboard')
context = {'form': form}
return render(request, 'edit_post.html', context)
def blog_post(request):
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/blog/save/')
else:
form = BlogForm()
return render_to_response('blog_form.html', {'form': form}, context_instance=RequestContext(request))
def post(self, request, pk):
blog = get_object_or_404(self.model, pk=pk)
form = BlogForm(request.POST, instance=blog)
if not form.is_valid():
ctx = {'title': blog.title, 'content': blog.content}
return render(request, self.template, ctx)
form.save()
return redirect(self.success_url)
def blog_update(request, id=""):
id = id
if request.method == 'POST':
form = BlogForm(request.POST)
tag = TagForm(request.POST)
if form.is_valid() and tag.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
tagname = cdtag['tag_name']
tagnamelist = tagname.split()
for taglist in tagnamelist:
Tag.objects.get_or_create(tag_name=taglist.strip())
title = cd['caption']
content = cd['content']
blog = Blog.objects.get(id=id)
if blog:
blog.caption = title
blog.content = content
blog.save()
for taglist in tagnamelist:
blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
blog.save()
tags = blog.tags.all()
for tagname in tags:
tagname = unicode(str(tagname), "utf-8")
if tagname not in tagnamelist:
notag = blog.tags.get(tag_name=tagname)
blog.tags.remove(notag)
else:
blog = Blog(caption=blog.caption, content=blog.content)
blog.save()
return HttpResponseRedirect('/myblog/blog/%s' % id)
else:
try:
blog = Blog.objects.get(id=id)
except Exception:
raise Http404
form = BlogForm(initial={
'caption': blog.caption,
'content': blog.content
},
auto_id=False)
tags = blog.tags.all()
if tags:
taginit = ''
for x in tags:
taginit += str(x) + ' '
tag = TagForm(initial={'tag_name': taginit})
else:
tag = TagForm()
return render_to_response('blog_add.html', {
'blog': blog,
'form': form,
'id': id,
'tag': tag
},
context_instance=RequestContext(request))
def post_update(request, pk):
post = get_object_or_404(Blog, pk=pk)
if post.owner == request.user:
form = BlogForm(request.POST or None, instance=post)
if form.is_valid():
form.save()
return redirect('blog_home')
else:
return redirect('blog_home')
return render(request, 'post_create.html', {'form': form})
def addblog(request):
p = request.POST
use = request.user
social = use.social_auth.get(provider= 'facebook')
blog_by = blogger.objects.get(name = str(social.user))
if p.has_key("title") and p["title"] and p.has_key("body") and p["body"]:
blog_request = blog(blogger=blog_by,slug=slugify(p["title"]))
blog_form = BlogForm(p, instance = blog_request)
blog_form.save()
return HttpResponseRedirect(reverse("blog.views.welcome"))
def blogs_query(request):
blog_form = BlogForm(request.POST)
context = {}
if blog_form.is_valid():
title_or_name = blog_form.cleaned_data['text']
blogs_all_list = Blog.objects.filter(title__contains=title_or_name)
context = get_blog_list_common_data(request, blogs_all_list)
context['title_or_name'] = title_or_name
context['blog_form'] = blog_form
return render(request, 'blog/blogs_query.html', context)
def index(request):
if request.method == "POST":
form = BlogForm(request.POST)
form.save()
return HttpResponseRedirect('blog-view/')
else:
form = BlogForm
context = {
'form': form,
}
return render(request, "blog/index.html", context)
def edit_blog(request, pk):
blog = get_object_or_404(Blog, pk=pk)
form = BlogForm(request.POST or None, instance=blog)
if form.is_valid():
blog = form.save(commit=False)
blog.save()
return redirect('blog-detail', pk=blog.pk)
context = {"form": form}
return render(request, 'blog/create_blog.html', context)
def delete(request,pk):
blog = Blog.objects.get(pk=pk)
if request.method == "POST" and request.user == blog.op: #if we are posting, and the user owns the blog, let the blog be deleted.
form = BlogForm(request.POST)
if form.is_valid():
blog.delete()
return redirect(reverse('profile'))
# if any above requirements are not satisfied, simply direct to the page.
form = BlogForm(instance = blog)
args = {'form': form}
return render(request, 'write.html', args)
def add_blog(request):
context = {}
blog_form = BlogForm()
error = ""
success = ''
authors_list = []
if request.user.is_authenticated:
if request.method == "POST":
form = BlogForm(request.POST, request.FILES)
data = request.POST
if form.is_valid():
print(form)
author_name = request.user.username
title = data.get('title')
blog_image = form.cleaned_data.get('blog_image')
email = request.user.email
description = data.get('description')
if blog_image:
blog = Blog.objects.create(author_name=author_name,
title=title,
blog_image=blog_image,
email=email,
description=description)
else:
blog = Blog.objects.create(author_name=author_name,
title=title,
blog_image=blog_image,
email=email,
description=description)
blog.save()
# form.save()
return redirect('/blog/get_blog')
return render(request, "blog/add_blog.html", {
'form': blog_form,
"success": 1
})
else:
error = 'please fill correctly'
return render(request, "blog/add_blog.html", {
'form': blog_form,
"error": error
})
else:
return render(request, "blog/add_blog.html", {'form': blog_form})
else:
error = "You must be loggedin to add your Blog! Please Register and Login"
authors_list = get_blogs_data()
return render(request, "blog/get_blog.html", {
'authors_list': authors_list,
'error': error
})
def post_update(request, slug):
blog = get_object_or_404(Blog, slug=slug)
if request.user != blog.author:
return HttpResponseForbidden()
form = BlogForm(instance=blog,
data=request.POST or None,
files=request.FILES or None)
if form.is_valid():
form.save()
return HttpResponseRedirect(blog.get_absolute_url())
context = {'form': form, 'blog': blog}
return render(request, 'blog/post_update.html', context=context)
def test_blog_form_required(self):
invalid_data = {
'title': '',
'category': '',
'content': '',
'thumbnail': '',
}
form = BlogForm(data=invalid_data)
self.assertFalse(form.is_valid())
self.assertTrue(form.errors)
self.assertIn('title', form.errors.keys())
self.assertIn('category', form.errors.keys())
self.assertIn('thumbnail', form.errors.keys())
class BlogEditView(TemplateView):
template_name = "blog/edit_blog.html"
def get(self, request, *args, **kwargs):
from blog.models import Blog
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
return super(BlogEditView, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
from blog.forms import BlogForm
from tags.models import ManagerTag
from region.models import Region
from elect.models import Elect
context = super(BlogEditView, self).get_context_data(**kwargs)
context["form"] = BlogForm(instance=self.blog)
context["blog"] = self.blog
context["tags"] = ManagerTag.objects.only("pk")
context["regions"] = Region.objects.filter(is_deleted=False)
context["elects"] = Elect.objects.filter(type="PUB")
return context
def post(self, request, *args, **kwargs):
from blog.forms import BlogForm
from blog.models import Blog
from common.templates import render_for_platform
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
self.form_post = BlogForm(request.POST,
request.FILES,
instance=self.blog)
if request.is_ajax() and self.form_post.is_valid(
) and request.user.is_supermanager():
post = self.form_post.save(commit=False)
new_post = post.edit_blog(
title=post.title,
image=post.image,
description=post.description,
comments_enabled=post.comments_enabled,
votes_on=post.votes_on,
tags=request.POST.getlist("tags"),
manager_id=request.user.pk,
region=request.POST.getlist("region"),
elect=request.POST.getlist("elect"),
attach=request.POST.getlist("attach_items"))
return HttpResponse()
else:
from django.http import HttpResponseBadRequest
return HttpResponseBadRequest()
def post(self, request, *args, **kwargs):
form = BlogForm(request.POST, request.FILES or None)
if form.is_valid():
form.save()
response = {
'success': 'true',
'message': 'Success write blog'
}
else:
response = {
'success': 'false',
'message': 'Failed write blog'
}
return Response(response)
def blog_update(request, id=""):
id = id
if request.method == 'POST':
form = BlogForm(request.POST)
tag = TagForm(request.POST)
if form.is_valid() and tag.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
tagname = cdtag['tag_name']
tagnamelist = tagname.split()
for taglist in tagnamelist:
Tag.objects.get_or_create(tag_name=taglist.strip())
title = cd['caption']
content = cd['content']
blog = Blog.objects.get(id=id)
if blog:
blog.caption = title
blog.content = content
blog.save()
for taglist in tagnamelist:
blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
blog.save()
tags = blog.tags.all()
for tagname in tags:
tagname = unicode(str(tagname), "utf-8")
if tagname not in tagnamelist:
notag = blog.tags.get(tag_name=tagname)
blog.tags.remove(notag)
else:
blog = Blog(caption=blog.caption,content=blog.content)
blog.save()
return HttpResponseRedirect('/newblog/%s' % id)
else:
try:
blog = Blog.objects.get(id=id)
except Exception:
raise Http404
form = BlogForm(initial={'caption': blog.caption,'content': blog.content}, auto_id=False)
tags = blog.tags.all()
if tags:
taginit = ''
for x in tags:
taginit += str(x) + ' '
tag = TagForm(initial={'tag_name': taginit})
else:
tag = TagForm()
return render_to_response('blog_add.html',{'blog': blog, 'form': form, 'id': id, 'tag': tag},
context_instance=RequestContext(request))
def dashboard(request):
top_ranked_events = Event.objects.order_by('-overall_rating')[:5]
top_commented_blog = Blog.objects.order_by('-overall_comment')[:5]
my_blogs = Blog.objects.filter(user=User.objects.get(username=request.user))
trending_event = Event.objects.order_by('-event_date')[:2]
trending_blog = Blog.objects.order_by('-created_date')[:3]
template = loader.get_template('dashboard.html')
context = RequestContext(request, {
'top_ranked_events': top_ranked_events,
'top_commented_blog': top_commented_blog,
'my_blogs': my_blogs,
'trending_event': trending_event,
'trending_blog': trending_blog,
'form_class': BlogForm,
'form_feedback': FeedbackForm,
'form_suggestion': SuggestionForm,
'form_rating': RatingForm,
'form_comment': CommentForm,
'template_name': 'dashboard.html',
'success_url': '/thanks/',
})
if request.method == 'POST':
if 'blog_body' in request.POST:
form = BlogForm(request.POST)
elif 'feedback_data' in request.POST:
form = FeedbackForm(request.POST)
elif 'suggestion_data' in request.POST:
form = SuggestionForm(request.POST)
elif 'rating_star' in request.POST:
form = RatingForm(request.POST)
elif 'comment_data' in request.POST:
form = CommentForm(request.POST)
if form.is_valid():
blog_form = form.save(commit=False)
if 'comment_data' in request.POST:
blog = Blog.objects.get(id=request.POST['blog'])
comment_count = blog.comment_set.aggregate(Count('comment_data')).values()
if comment_count[0] != None:
comment_count = blog.comment_set.aggregate(Count('comment_data')).values()[0]
else:
comment_count = int(request.POST['comment_data'])
blog.overall_comment = comment_count
blog.save()
elif 'rating_star' in request.POST:
event = Event.objects.get(id=request.POST['event'])
stars_average = event.rating_set.aggregate(Avg('rating_star')).values()
if stars_average[0] != None:
stars_average = event.rating_set.aggregate(Avg('rating_star')).values()[0]
else:
stars_average = float(request.POST['rating_star'])
event.overall_rating = stars_average
event.save()
# commit=False tells Django that "Don't send this to database yet.
# I have more things I want to do with it."
blog_form.user = User.objects.get(username=request.user) # Set the user object here
blog_form.save() # Now you can send it to DB
return HttpResponse(template.render(context))
def edit_post(request, blog_id):
if request.method == 'POST':
current_post = Blog.objects.get(pk=blog_id)
form = BlogForm(request.POST or None, instance=current_post)
if form.is_valid():
form.save()
messages.success(request, 'post a ete edite avec succes :')
return redirect('home')
else:
messages.success(request, 'erreur d\'edition post:')
return render(request, 'blog/edit_post.html')
else:
get_post = Blog.objects.get(pk=blog_id)
context = {'get_post': get_post}
return render(request, 'blog/edit_post.html', context)
def bloginsert(request):
html = "blog.html"
if request.method == "POST":
form = BlogForm(request.POST, request.FILES)
if form.is_valid():
data = form.cleaned_data
Blog.objects.create(blog_title=data['title'],
blog_body=data['body'],
blog_author=data['author'],
blog_image=data['image'])
return HttpResponseRedirect(reverse('homepage'))
else:
form = BlogForm()
context = {'form': form}
return render(request, html, context)
def create_blog(request):
form = BlogForm(request.POST or None, request.FILES or None)
if request.method=="POST":
if form.is_valid():
form.instance.user=request.user
form.instance.featured=0
form.instance.comments=0
form.save()
return redirect('/blog/')
context={
'form':form,
'heading':'Create a blog post',
'subheading':'Engage with our community'
}
return render(request,'blog/create_blog.html',context)
def blogwrite(request):
try:
if request.user.usertype == 'normal':
profile = NormalUser.objects.get(user=request.user)
else:
profile = DoctorUser.objects.get(user=request.user)
except ValueError:
profile.avatar = NormalUser.objects.get(user_id=3).avatar
if request.method == 'GET':
ck = CKEditorForm()
return render(request, 'blog/blog-write.html', {'ck':ck, 'profile':profile})
else:
blog = BlogForm(request.POST)
if blog.is_valid():
Blog(essay=request.POST['content'], label=request.POST['label']).save()
return HttpResponseRedirect('/blog/bloghome/1')
def edit_blog(request,id):
blog = get_object_or_404(BlogModel,id=id)
form = BlogForm(request.POST or None, request.FILES or None, instance=blog)
if request.method=="POST":
if form.is_valid():
form.instance.user=request.user
form.save()
return redirect('/blog/')
context={
'form':form,
'heading':'Edit your post',
'subheading':'Edit and Update your post',
}
return render(request,'blog/create_blog.html',context)
def create_blog(request):
if request.POST:
form = BlogForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/blog/')
else:
form = BlogForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['sidebar'] = Sidebar.objects.filter(
pub_date__lte=timezone.now()).order_by('-pub_date')
return render(request, 'blog/create_blog.html', args)
def blog_add(request):
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
title = cd['caption']
author = Author.objects.get(id=1)
content = cd['content']
blog = Blog(caption=title, author=author, content=content)
blog.save()
id = Blog.objects.order_by('-publish_time')[0].id
return HttpResponseRedirect('/blog/%s' % id)
else:
form = BlogForm()
return render_to_response('blog/blog_add.html',
{'form': form}, context_instance=RequestContext(request))
def post(self, request):
form = BlogForm(request.POST)
if form.is_valid():
data = form.cleaned_data
FirstName = data['first_name']
LastName = data['last_name']
UserName = data['username']
Email = data['email']
print "post"
User.objects.create(first_name=FirstName,
last_name=LastName,
username=UserName,
email=Email)
return HttpResponseRedirect('/list/')
return render(request, 'Blog_templates/Blog.html', {"form": form})
def get(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(instance=self.blog)
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def update_blog(request, pk):
blog = get_object_or_404(Blog, pk=pk)
columns = Column.objects.all()
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
blog.column = cd['column']
blog.title = cd['title']
blog.body = cd['body']
blog.save()
tags = request.POST.getlist('tags[]', [])
tags_prev = list(
Tag.objects.filter(blog=blog).values_list('name', flat=True))
tags_add = list(set(tags).difference(set(tags_prev)))
tags_rm = list(set(tags_prev).difference(set(tags)))
Tag.objects.filter(name__in=tags_rm).delete()
if tags_add:
add_tag = []
for add in tags_add:
add_tag.append(Tag(name=add, blog=blog))
Tag.objects.bulk_create(add_tag)
return JsonResponse({
"code":
200,
'msg':
'Updated',
'url':
reverse('blog:blog_detail', kwargs={"slug": blog.slug})
})
elif request.method == 'DELETE':
blog.status = False
blog.save()
return JsonResponse({"code": 200, 'pk': blog.pk})
elif request.method == 'GET':
tags = ','.join(
list(Tag.objects.filter(blog=blog).values_list('name', flat=True)))
return render(request, 'myadmin/blog/blog.html', {
"blog": blog,
"columns": columns,
"tags": tags
})
def add_blog(request):
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
print('blog form is valid')
cd = form.cleaned_data
title = cd['title']
keyword = cd['keyword']
content = cd['content']
blog = Blog(title=title, keyword=keyword, content=content)
blog.author = request.user
blog.createDate = datetime.now()
blog.save()
return HttpResponseRedirect('/blog')
else:
form = BlogForm()
return render(request, 'blog/add_blog.html', {'form': form})
def add(request,host_id):
if request.method == 'POST':
blogform = BlogForm(request.POST)
if blogform.is_valid():
title = blogform.cleaned_data['title']
content = blogform.cleaned_data['content']
author = Profile.objects.get(user=request.user)
new_blog = Blog(
author=author,
title=title,
content=content,
)
new_blog.save()
return HttpResponseRedirect("/blog/"+str(request.user.id) )
else:
blogform = BlogForm()
return render_to_response("blog/add_blog.html", {'blogform': blogform}, context_instance=RequestContext(request))
def view_makepost(request):
form = BlogForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
#
author = form.cleaned_data.get("author")
article = form.cleaned_data['article']
if not author:
author = request.user.username
instance.author = author
#
instance.save()
#messages.success(request, "<a href='#'>Item</a> Saved", extra_tags='html_safe')
return HttpResponseRedirect(instance.get_absolute_url())
context = {
'form': form,
}
return render(request, 'blog/makepost.html', context)
def blog_entry_form(request, id=None):
if id:
obj = get_object_or_404(Blog, id=id, author=request.user)
scenario = 'Update'
else:
obj = Blog()
scenario = 'Create'
if request.POST:
form = BlogForm(data=request.POST, instance=obj)
if form.is_valid():
item = form.save(commit=False)
item.author = request.user
item.save()
return redirect(reverse('list_blog_entries'))
else:
form = BlogForm(instance=obj)
return render(request, 'blog_form.html', {
'scenario': scenario,
'form': form,
})
class BlogUpdate(PermissionRequiredMixin, PageNumberView, TemplateView, SearchMixin, PageNumberMixin):
permission_required = 'blog.change_blog'
blog = None
template_name = "blog_edit.html"
form = None
def get(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(instance=self.blog)
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def get_context_data(self, **kwargs):
context = super(BlogUpdate, self).get_context_data(**kwargs)
context["blog"] = self.blog
context["form"] = self.form
return context
def post(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(request.POST, instance=self.blog)
if self.form.is_valid():
self.form.save()
messages.add_message(request, messages.SUCCESS, "Статья успешно изменена")
redirect_url = reverse("blog_index") + "?page=" + self.request.GET["search"]
try:
redirect_url = redirect_url + "&search=" + self.request.GET["search"]
except KeyError:
pass
try:
redirect_url = redirect_url + "&tag=" + self.request.GET["tag"]
except KeyError:
pass
return redirect(redirect_url)
else:
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def create_post(request):
warn_already_made = False
if request.POST:
formf = BlogForm(request.POST)
form = formf.save(commit=False)
if Blog.objects.filter(title=form.title).count() == 0:
form.slug = slugify(form.title)
form.save()
return HttpResponseRedirect('/')
else:
warn_already_made = True
form = BlogForm()
else:
form = BlogForm()
args = {}
args.update(csrf(request))
args['form'] = form
args['throw_duplicity_error'] = warn_already_made
return render_to_response('create_post.html', args)
def view_updatepost(request, slug=None):
if not request.user.is_staff or not request.user.is_superuser:
raise Http404
#post = Blog.objects.get(pk=blog_id)
#blog_id = blog_id - 1
post_to_be_changed = get_object_or_404(Blog, slug=slug)
form = BlogForm(request.POST or None, instance=post_to_be_changed)
print(post_to_be_changed.title)
if form.is_valid():
post_to_be_changed = form.save(commit=False)
#
#
post_to_be_changed.save()
#messages.success(request, "<a href='#'>Item</a> Saved", extra_tags='html_safe')
return HttpResponseRedirect(post_to_be_changed.get_absolute_url())
context = {
'post_to_be_changed': post_to_be_changed,
'form': form,
}
return render(request, 'blog/makepost.html', context)
def blogEdit(request,id):
page = {
'title' : "Edit blog",
'choices' : [
('Blog menu',reverse('admin_blogMain')),
],
}
blog = get_object_or_404(Blog,pk=id)
if request.method == 'POST': # If the form has been submitted...
form = BlogForm(request.POST,instance=blog)
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
form.save()
return HttpResponseRedirect(reverse('admin_blogMain')) # Redirect after POST
else:
form = BlogForm(instance=blog)
return render(request,
'admin/formpage.html',
{'form': form,
'formAction': reverse('admin_blogEdit',kwargs={'id':id}),
'page': page})
def blogCreate(request):
page = {
'title' : "Create new blog",
'choices' : [
('Blog menu',reverse('admin_blogMain')),
],
}
if request.method == 'POST': # If the form has been submitted...
form = BlogForm(request.POST) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
form.save()
return HttpResponseRedirect(reverse('admin_blogMain')) # Redirect after POST
else:
form = BlogForm() # An unbound form
return render(request,
'admin/formpage.html',
{'form': form,
'formAction': reverse('admin_blogCreate'),
'page': page})
def create_blog(request):
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
blog = form.save(commit=False)
slug = generate_slug(blog.title)
conflicts = Blog.objects.filter(slug__startswith=slug)
if conflicts:
slug = get_unique_slug(slug, conflicts)
blog.slug = slug
blog.owner = request.user
blog.save()
return redirect('view_blog', blog.slug)
else:
form = BlogForm()
context = {
'blog_form': form,
}
return render_to_response('blog/create_blog.html', context, RequestContext(request))
def create_blog(request):
if request.POST:
form = BlogForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/blog/')
else:
form = BlogForm()
args = {}
args.update(csrf(request))
args['form'] = form
if request.user.is_authenticated():
args['sidebar'] = Sidebar.objects.filter(pub_date__lte=timezone.now()).order_by('-pub_date')
args['username'] = request.user.username
args['full_name'] = request.user.first_name + ' ' + request.user.last_name
args['form'] = args['form']
return render(request, 'blog/create_blog.html', args)
else:
args['form'] = args['form']
args['sidebar'] = Sidebar.objects.filter(pub_date__lte=timezone.now()).order_by('-pub_date')
return render(request, 'blog/create_blog.html', args)
def new(request):
"""
Add a new blog
"""
if request.method == 'POST':
form = BlogForm(request.POST)
if form.is_valid():
data = form.cleaned_data
blog = Blog()
blog.group = data['group']
blog.status = data['status']
blog.title = data['title']
blog.tag = data['tag']
blog.content = data['content']
blog.summary = data['summary']
blog.access_count = 0
blog.comment_count = 0
blog.create_date = datetime.datetime.now()
blog.update_date = datetime.datetime.now()
blog.save()
return HttpResponseRedirect('/adminshow/%s' % blog.id)
else:
form = BlogForm()
return render_to_response('new.html', {'form':form}, context_instance=RequestContext(request, processors=[new_blog, blog_group]))
def post(self, request, *args, **kwargs):
self.blog = Blog.objects.get(pk=self.kwargs["pk"])
if self.blog.user == request.user or request.user.is_superuser:
self.form = BlogForm(request.POST, instance=self.blog)
if self.form.is_valid():
self.form.save()
messages.add_message(request, messages.SUCCESS, "Статья успешно изменена")
redirect_url = reverse("blog_index") + "?page=" + self.request.GET["search"]
try:
redirect_url = redirect_url + "&search=" + self.request.GET["search"]
except KeyError:
pass
try:
redirect_url = redirect_url + "&tag=" + self.request.GET["tag"]
except KeyError:
pass
return redirect(redirect_url)
else:
return super(BlogUpdate, self).get(request, *args, **kwargs)
else:
return redirect(reverse("login"))
def blog_save(request, slug=None):
blog = None
if slug:
blog = Blog.objects.get(slug=slug)
if not blog or blog.author_id != request.user.id:
raise Http404
if request.POST:
form = BlogForm(request.POST, instance=blog)
if form.is_valid():
blog = BlogForm(form.cleaned_data, instance=blog).save(commit=False)
if not slug:
blog.is_active = True
blog.author = request.user
blog.save()
return HttpResponseRedirect(
reverse('blog.views.blog', kwargs={'slug': blog.slug}))
else:
form = BlogForm(instance=blog)
return render_to_response(request, 'blog/blog_save.html', {
'form': form,
'blog': blog,
})
