def addArticle(request):
'''
添加文章
:param request:
:return:
'''
if request.method == "GET":
article_form = ArticleForm()
cate_list = models.Category.objects.filter(blog__user = request.user)
tag_list = models.Tag.objects.filter(blog__user = request.user)
return render(request,"addArticle.html",locals())
if request.method == "POST":
article_form = ArticleForm(request.POST)
if article_form.is_valid():
title = article_form.cleaned_data.get("title")
content = article_form.cleaned_data.get("content")
cate_obj = request.POST.get("cate_list")
tag_obj_list = request.POST.getlist("tag_list")
soup = BeautifulSoup (content,'html.parser')
content_desc = soup.get_text () [:100]
with transaction.atomic():
article_obj = models.Article.objects.create(title=title,desc = content_desc,create_time=datetime.datetime.now(),user=request.user,category_id=cate_obj)
models.ArticleDetail.objects.create(content=content,article=article_obj)
if tag_obj_list:
for i in tag_obj_list:
models.Article_Tag.objects.create(article_id=article_obj.id,tag_id=i)
return HttpResponse("添加成功")
else:
return render(request,'addArticle.html',locals())
def article_update(request, slug=None):
user = request.user
#if not user.is_staff or not user.is_superuser:
# raise Http404
instance = get_object_or_404(Article, slug=slug)
if instance.author != user:
raise Http404
# Para poder actualizar un articulo, su imagen es necesario request.FILES or NOne
form = ArticleForm(request.POST or None, request.FILES or None, instance=instance)
if form.is_valid():
instance = form.save(commit=False)
# form.instance.author = request.user
instance.save()
# message success
# messages.success(request, "<a href='#'>Item</a>Saved", extra_tags='html_safe')
messages.success(request, "Tu artículo ha sido actualizado")
return HttpResponseRedirect(instance.get_absolute_url())
context = {
'title': instance.title,
'instance': instance,
'form': form,
}
if user.is_authenticated():
context['userprofile'] = user.profile
return render(request, 'blog/article_form.html', context)
def articleform(request):
if request.method == 'POST': # S'il s'agit d'une requete POST
form = ArticleForm(request.POST) # Nous reprenons les donnees
if form.is_valid(): # Nous verifions que les donnees envoyees sont valides
# Ici nous pouvons traiter les donnees du formulaire
#titre = form.cleaned_data['titre']
#slug = form.cleaned_data['slug']
#auteur = form.cleaned_data['auteur']
#contenu = form.cleaned_data['contenu']
#date = form.cleaned_data['date']
#categorie = form.cleaned_data['categorie']
#Sujet = form.cleaned_data['Sujet']
#message = form.cleaned_data['message']
#envoyeur = form.cleaned_data['envoyeur']
#renvoi = form.cleaned_data['renvoi']
# Nous pourrions ici envoyer l'e-mail grace aux donnees que nous venons de recuperer
envoi = True
form.save()
else: # Si ce n'est pas du POST, c'est probablement une requete GET
form = ArticleForm() # Nous creons un formulaire vide
return render(request, 'blog/articleform.html', locals())
def post_article(request):
if request.POST and request.method == "POST" and request.user.is_authenticated:
f = ArticleForm(request.POST)
new_article = f.save()
return HttpResponseRedirect("/blog/superuser")
else:
return HttpResponseRedirect("/blog/superuser")
def add_article(request):
# context = RequestContext(request)
topic_tags, other_tags = get_tag_lists()
current_user = request.user
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
new_article = form.save()
raw_tags = form.cleaned_data['tags'].split(',')
if raw_tags:
for raw_tag in raw_tags:
raw_tag = raw_tag.strip().replace(' ', '_').lower()
tag_name = urllib.quote(raw_tag)
tag, created = Tag.objects.get_or_create(name=tag_name)
if created:
tag.article_count=1
else:
tag.article_count +=1
tag.save()
tag.articles.add(new_article)
return redirect(index)
else:
print form.errors
else:
form = ArticleForm(initial={'author': current_user})
context = {
'form': form,
'topic_tags': topic_tags,
'other_tags': other_tags,
}
return render(request, 'add_article.html', context)
def update_article(request, id):
"""Enables Article update"""
article = Article.get_by_id(int(id))
if article:
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article.title = form.cleaned_data['title']
article.content = form.cleaned_data['content']
article.put()
messages.add_message(request,
messages.INFO,
u'Article %s created'
% form.cleaned_data['title'])
time.sleep(1)
return redirect('home')
else:
form = ArticleForm({'title': article.title,
'content': article.content})
return render(request, 'article/create.html', locals())
else:
messages.add_message(request,
messages.ERROR,
u'Article not found')
return redirect('home')
def edit_one_article(request, article_pk=0):
try:
article = Article.objects.get(pk=article_pk, author=request.user.get_profile())
except Article.DoesNotExist:
article = None
if request.method == 'POST':
form = ArticleForm(request.POST, instance=article)
if form.is_valid():
art = form.save(commit=False)
art.author = request.user.get_profile()
art.save()
messages.add_message(request, messages.INFO,
_('Your edits have been saved successfully.'))
return render_to_response('blog/edit_one_article.html',
{'article_pk': article_pk, 'form': form},
context_instance=RequestContext(request))
else:
try:
article = Article.objects.get(pk=article_pk, author=request.user.get_profile())
except Article.DoesNotExist:
form = ArticleForm()
return render_to_response('blog/edit_one_article.html',
{'article_pk': article_pk, 'form': form},
context_instance=RequestContext(request))
def article(request):
# Create Article
current_date = date.today()
if request.method == "POST":
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.author = request.user
article.published_date = timezone.now()
article.save()
return redirect('blog_details', id=article.id)
else:
return render(request, 'post_edit.html', {
'form': form,
'date': current_date
})
# Viewing an Article
else:
form = CommentForm()
return render(request, 'post_edit.html', {
'form': form,
'date': current_date
})
def article_add(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
tag = TagForm(request.POST)
classification = ClassificationForm(request.POST)
if form.is_valid() and tag.is_valid() and classification.is_valid():
cd = form.cleaned_data
cdtag = tag.cleaned_data
cdclassification = classification.cleaned_data
tagname = cdtag['tag_name']
classification_name = cdclassification["classification_name"]
for taglist in tagname.split():
Tag.objects.get_or_create(tag_name=taglist.strip())
if classification_name != "":
Classification.objects.get_or_create(name=classification_name.strip())
title = cd['caption']
author = Author.objects.get(id=1)
content = cd['content']
article = Article(caption=title, author=author, content=content)
article.classification = Classification.objects.get(name=classification_name.strip())
article.save()
for taglist in tagname.split():
article.tags.add(Tag.objects.get(tag_name=taglist.strip()))
article.save()
id = Article.objects.order_by('-publish_time')[0].id
return HttpResponseRedirect('/blog/article/%s/%s/' % ('/'.join(str(article.publish_time).split()[0].split('-')), id))
else:
form = ArticleForm()
tag = TagForm(initial={'tag_name': 'notags'})
classification = ClassificationForm()
return render_to_response('article_add.html',
{}, context_instance=RequestContext(request))
def update_article(request, id):
if request.method == 'POST':
try:
form = ArticleForm(request.POST, request.FILES)
# print(form)
# print(id)
if form.is_valid():
# form.save()
update_article = Article.objects.get(article_id=id)
update_article.article_title = form.cleaned_data[
'article_title']
update_article.article_description = form.cleaned_data[
'article_description']
update_article.article_image = form.cleaned_data[
'article_image']
print(form.cleaned_data['article_image'])
update_article.save()
return JsonResponse({"err": "false", "message": "data added"})
else:
return JsonResponse({
"err": "true",
"message": "data not added"
})
except Exception as err:
errMessage = f"Oops! {sys.exc_info()[1]}"
return JsonResponse({'err': 'true', 'message': errMessage})
def create_article(request): # User creating a new article.
form = ArticleForm(request.POST)
if form.is_valid():
form.save()
return redirect(reverse('show_all'))
else: # Else sends user back to article_form page.
return render(request, 'article_form.html', {'form': form})
def add_article(request): if request.method == 'POST': form = ArticleForm(request.POST) if form.is_valid(): envoi = True else: form = ArticleForm() return render(request, 'blog/add_article.html', locals())
def post(request, pk):
_id = pk
article_obj = Article.objects.filter(id=_id).first()
form_obj = ArticleForm(request.POST, instance=article_obj)
if form_obj.is_valid():
form_obj.save()
_next_url = reverse('blog:article', kwargs={'pk': 0})
return redirect(_next_url)
return render(request, 'blog/addblog.html', {'form_obj': form_obj, 'id': _id})
def newForm(request):
form = ArticleForm()
if request.POST :
form = ArticleForm(request.POST)
if form.is_valid():
print(form.cleaned_data, form.errors)
form.save()
return redirect('/form/')
return render(request, 'forms.html', {"form": form,'username': auth.get_user(request).username})
def ajout(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
#prepopulated_fields = {'Article.slug': ('Article.titre', ), }
if form.is_valid():
form.save()
return redirect(view_redirection)
else:
form = ArticleForm
return render(request, 'blog/ajout.html', locals())
def post(self, request):
"""发布文章提交表单处理，验证通过则添加记录重定向到文章详情页面，否则回到发布文章页面显示错误"""
article_form = ArticleForm(request.POST)
if article_form.is_valid():
article_form.instance.user_id = request.session['user']['id']
article_form.save()
return redirect(
reverse('blog:article_detail',
args=[article_form.instance.id]))
return render(request, 'publish_article.html', {'form': article_form})
def edit_article(request, id_article): if request.method == 'POST': form = ArticleForm(request.POST) if form.is_valid(): envoi = True else: article = get_object_or_404(Article, id=id_article) form = ArticleForm(instance=article) return render(request, 'blog/add_article.html', locals())
def create(request):
if request.method == "POST":
form = ArticleForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/all')
c = {}
c.update(csrf(request))
c['form'] = ArticleForm()
return render_to_response('create.html', c)
def article(request): if request.method == 'POST': form = ArticleForm(request.POST) if form.is_valid(): form.save() else: form = ArticleForm() return render(request, 'blog/article.html', locals())
def nouvel_article(request):
"""AJout d'un article via formulaire"""
if request.method == "POST":
form = ArticleForm(request.POST)
if form.is_valid():
form.save()
envoi = True
else:
form = ArticleForm()
return render(request, "blog/nouvel-article.html", locals())
def create(request):
title = request.POST.get('title')
content = request.POST.get('content')
form = ArticleForm(dict(title=title,
content=content,))
if form.is_valid():
article = Article(title=title, content=content,)
article.save()
#else:
#return
return redirect(show, article_id=article.id)
def edit_article(request, id):
if request.method == 'POST': # S'il s'agit d'une requête POST
article = get_object_or_404(Article, id=id)
article_form = ArticleForm(request.POST, instance=article)
if article_form.is_valid():
article_form.save()
return redirect('blog.views.edit_article', id)
else:
article = get_object_or_404(Article, id=id)
article_form = ArticleForm(instance=article)
return render(request, 'blog/edit_article.html', {'article_form': article_form, 'id': id})
def addArticle(request):
if request.method == 'POST':
print(request.POST)
print(request.FILES)
form = ArticleForm(request.POST, request.FILES)
# print(form)
if form.is_valid():
form.save()
return JsonResponse({"err": "false", "message": "data added"})
else:
return JsonResponse({"err": "true", "message": "data not added"})
def post(request):
if request.method == 'POST':
form = ArticleForm(request.POST, request.FILES)
if form.is_valid():
article = form.save(commit=False)
article.user = request.user
article.fileItem_id = request.POST['id_file']
article.save()
else:
print(form.errors)
return view_media(request)
def update_post(request, slug, template="create_post.html"):
post = get_object_or_404(Post.objects.select_related("user"), slug=slug)
if post.user != request.user:
raise Http404
if request.method == "POST":
form = ArticleForm(instance=post, data=request.POST, files=request.FILES)
if form.is_valid():
form.save()
return redirect("detail", post.slug)
else:
form = ArticleForm(instance=post)
return render(request, template, {"form": form, "is_deletable": True, "slug": slug})
def post(self, request):
if request.method == 'POST':
newArticle = ArticleForm(request.POST)
if newArticle.is_valid():
article = newArticle.save(commit=False)
article.body = newArticle.cleaned_data['body']
article.title = newArticle.cleaned_data['title']
article.author = request.user
if request.user.is_redactor:
article.status = 'approve'
article.save()
return redirect('all')
def post(self, request):
post = Post(author_id=request.user)
form = ArticleForm(request.POST, request.FILES, instance=post)
if form.is_valid():
form.save()
return redirect('blog:article_admin')
else:
error = form.errors
return render(request, 'blog/articles/admin/create.html', {
'form': form,
'error': error
})
def add(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
titre = form.cleaned_data['titre']
auteur = form.cleaned_data['auteur']
contenu = form.cleaned_data['contenu']
categorie = form.cleaned_data['categorie']
form.save()
return HttpResponseRedirect('/blog/facts')
else:
form = ArticleForm()
return render(request, 'blog/add_fact.html', {'title': 'Ajouter !', 'form': form})
def article_add(request):
# sticks in a POST or renders empty form
form = ArticleForm(request.POST or None)
if form.is_valid():
cmodel = form.save()
#This is where you might chooose to do stuff.
#cmodel.name = 'test1'
cmodel.save()
return HttpResponse('Record Saved!')
return render_to_response('blog/contact.html',
{'article_form': form},
context_instance=RequestContext(request))
def update(request, article_id):
article = get_object_or_404(Article, pk=article_id)
title = request.POST.get('title')
content = request.POST.get('content')
form = ArticleForm(dict(title=title,
content=content,))
if form.is_valid():
article.title = title
article.content = content
article.save()
#else:
#return
return redirect(show, article_id=article.id)
def add(request):
if request.method == 'POST':
formData = ArticleForm(request.POST, request.FILES)
if formData.is_valid():
edited = formData.save(commit=False)
edited.user = request.user
edited.save()
return redirect("list")
view_url = reverse("add")
upload_url, upload_data = prepare_upload(request, view_url)
return render(request, "add.html", {"form": ArticleForm, "action": "Add new", 'upload_url': upload_url, 'upload_data': upload_data})
def create_post(request):
form = ArticleForm(request.POST)
if form.is_valid():
new_article = form.instance
new_article.user = request.user
new_article.save()
return HttpResponseRedirect("/posts/")
else:
html_string = render(
request, 'new_post.html', {
'title': 'Create a new post',
'article_form': ArticleForm(request.POST)
})
return HttpResponse(html_string)
def article_update(request, year='', month='', day='', id=""):
id = id
if request.method == 'POST':
form = ArticleForm(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']
article = Article.objects.get(id=id)
if article:
article.caption = title
article.content = content
article.save()
for taglist in tagnamelist:
article.tags.add(Tag.objects.get(tag_name=taglist.strip()))
article.save()
tags = article.tags.all()
for tagname in tags:
tagname = unicode(str(tagname), "utf-8")
if tagname not in tagnamelist:
notag = article.tags.get(tag_name=tagname)
article.tags.remove(notag)
else:
article = Article(caption=article.caption, content=article.content)
article.save()
return HttpResponseRedirect('/blog/article/%s/%s/' % ('/'.join(str(article.publish_time).split()[0].split('-')), id))
else:
try:
article = Article.objects.get(id=id)
if [year, month, day] != str(article.publish_time).split()[0].split('-'):
raise Article.DoesNotExist
except Exception:
raise Http404
tags = article.tags.all()
if tags:
taginit = ''
for x in tags:
taginit += str(x) + ' '
tag = taginit
else:
tag = ''
return render_to_response('article_add.html',
{'article': article, 'id': id, 'tag': tag},
context_instance=RequestContext(request))
def addarticle():
form = ArticleForm()
if form.validate_on_submit():
article = Article(title=form.title.data,
content=form.content.data,
author=current_user)
db.session.add(article)
db.session.commit()
flash("Your article has been created.", "success")
return redirect(url_for("dashboard"))
return render_template("addarticle.html",
title="New Article",
form=form,
legend="New Article")
def new_article(request):
"""
Add a new article to the DB
"""
form = ArticleForm()
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.validate():
article = Article()
form.populate_obj(article)
article.put()
return redirect('index')
context_dict = {'form': form}
return render(request, 'new_article.html', context_dict)
def post_new(request):
if request.method == "POST":
form = ArticleForm(request.POST, request.FILES)
if form.is_valid():
blog = Blog()
blog.author = request.user
blog.blog_type = form.cleaned_data['content_type']
blog.title = form.cleaned_data['title']
blog.content = form.cleaned_data['text']
blog.blog_img = request.FILES.get('cover')
blog.save()
return redirect('home')
else:
form = ArticleForm()
return render(request, 'blog/blog_post_edit.html', {'form': form})
def post(self, request):
pk = request.GET.get("id")
article_obj = Article.objects.get(id=pk) if pk else None
dic = request.POST.dict()
date = dic.pop("add_date")
dic.update({"add_date": datetime.strptime(date, '%Y-%m-%d')})
form_obj = ArticleForm(dic, request.FILES, instance=article_obj)
if form_obj.is_valid():
form_obj.save()
self.make_md()
AJAX_DATA["path"] = "/cms/article"
return JsonResponse(AJAX_DATA)
else:
AJAX_DATA["status"] = form_obj.errors
return JsonResponse(AJAX_DATA)
def articleform(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
form.save() #sauvegarder l'article creer
form = ArticleForm()
envoi = True
else:
form = ArticleForm()
return render(request, 'blog/articleform.html', locals())
def edit(request):
if request.method != 'POST':
form = ArticleForm()
else:
return HttpResponse('失败')
context = {'form': form}
return render(request, 'blog/edit1.html', context)
def create_post(request, template="create_post.html"):
if request.method == "POST":
form = ArticleForm(data=request.POST, files=request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.date = date.today()
post.is_active = False
post.save()
send_mail_with_template(
u"Yeni yazı var", settings.MY_MAIL, "mails/newpost.html", {"post": post, "user": request.user}
)
return redirect("detail", post.slug)
else:
form = ArticleForm()
return render(request, template, {"form": form})
def post(self, request):
if not request.user.is_staff or not request.user.is_superuser:
raise Http404
form = ArticleForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = request.user
instance.save()
# message success
messages.success(request, "Successfully Created")
return HttpResponseRedirect(instance.get_absolute_url())
context = {
"form": form,
}
return render(request, self.template, context)
def edit(request, pk):
article = get_object_or_404(Article, pk=pk)
form = ArticleForm(instance=article)
if request.method == 'POST':
formData = ArticleForm(request.POST, request.FILES, instance=article)
if formData.is_valid():
edited = formData.save(commit=False)
edited.user = request.user
edited.save()
return redirect("list")
view_url = reverse("edit", kwargs={"pk":pk})
upload_url, upload_data = prepare_upload(request, view_url)
return render_to_response("add.html", {"form": form, "action": "Edit", 'upload_url': upload_url, 'upload_data': upload_data})
def article(request, pk):
obj = get_object_or_404(Article, pk=pk)
print(obj)
if request.method == 'POST':
if 'comment' in request.POST:
form = CommentForm(request.POST)
if form.is_valid():
comment = form.save(commit=False)
comment.user = request.user
comment.article = obj
comment.save()
elif 'edit' in request.POST:
form = ArticleForm(request.POST)
if form.is_valid():
edit_article = form.save(commit=False)
obj.title = edit_article.title
obj.text = edit_article.text
obj.save()
messages.success(request, '編集が完了しました')
elif 'delete' in request.POST:
obj.delete()
messages.success(request, '削除が完了しました')
return redirect('articles')
comments = Comment.objects.filter(article=pk)
like_count = Like.objects.filter(article=pk).count()
context = {'article': obj, 'comments': comments, 'like_count': like_count}
print(obj.author, request.user)
return render(request, 'blog/article.html', context)
def edit(request):
form = EditForm(request.POST)
if form.is_valid():
try:
article_pk = form.cleaned_data['pk']
article = Article.objects.get(pk=article_pk,
author=request.user.get_profile())
form = ArticleForm(instance=article)
return render_to_response('blog/edit_one_article.html', {
'article_pk': article_pk,
'form': form,
'is_good': False
},
context_instance=RequestContext(request))
except Article.DoesNotExist:
return render_to_response('blog/edit_one_article.html', {
'article_pk': 0,
'is_good': False
},
context_instance=RequestContext(request))
else:
return HttpResponseForbidden()
def new(request):
if request.user.is_authenticated():
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
blag = form.save(commit=False)
blag.author = request.user
blag.save()
return index(request)
else:
print form.errors
else:
form = ArticleForm()
else:
return HttpResponse("You must be an autheticated user to be here.")
return render(request, 'blog/new.html', {'form': form})
def New_Article():
subjects = Subject.query.filter(Subject.status == 'Approved').all()
subjects_list = [(0, "-- Please select subject --")] + [(i.id, i.name)
for i in subjects]
form = ArticleForm()
form.subject.choices = subjects_list
if form.validate_on_submit():
articlefile = save_articlefile(form.articlefile.data)
article = Article(title=form.title.data,
body=form.body.data,
subject_id=form.subject.data,
authorEmail=form.authorEmail.data)
db.session.add(article)
db.session.commit()
flash('Article created successfully', 'success')
return redirect(url_for('Subjects'))
return render_template('Create_Article.html', form=form, subjects=subjects)
def formulaire(request):
# Construire le formulaire, soit avec les données postées,
# soit vide si l'utilisateur accède pour la première fois
# à la page.
form = ArticleForm(request.POST or None)
# Nous vérifions que les données envoyées sont valides
# Cette méthode renvoie False s'il n'y a pas de données
# dans le formulaire ou qu'il contient des erreurs.
if form.is_valid():
"""Permet de créer un arcticle sans l'enregistrer en base. Pratique si besoin de traitement avant
enregistrement."""
article = form.save(commit=False)
article.slug = slugify(article.title)
article.save()
return render(request, 'blog/formulaire.html', locals())
def post_edited_article(request, pk):
if request.POST and request.method == "POST" and request.user.is_authenticated:
f = ArticleForm(request.POST)
a = get_object_or_404(Article, pk=pk)
print("inside")
if f.is_valid():
f.save(commit=False)
cd = f.cleaned_data
a.title = cd["title"]
a.short = cd["short"]
a.content = cd["content"]
a.save()
return HttpResponseRedirect("/blog/superuser")
else:
print("not valid")
else:
print("not logged")
def create_article(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
form.user = request.user
form.save()
return HttpResponseRedirect('/home/')
else:
form = ArticleForm()
return render(request, 'create_article.html', {'form': form})
def create_blog(request):
form = ArticleForm(request.POST)
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = ArticleForm(request.POST, request.FILES)
# check whether it's valid:
if form.is_valid():
title = form.cleaned_data['title']
lead_paragraph = form.cleaned_data['lead_paragraph']
content = form.cleaned_data['content']
title = request.POST['title']
lead_paragraph = request.POST['lead_paragraph']
image = request.FILES['image']
content = request.POST['content']
#create slug from title-input
slug = create_slug_text(title)
new_article = BlogPost(title=title,
lead_paragraph=lead_paragraph,
image=image,
slug=slug,
meta_title=title,
meta_description=lead_paragraph,
content=content)
new_article.save()
# redirect to a blog_post_url:
return redirect('blog_thanks')
# if a GET (or any other method) we'll create a blank form
else:
form = ArticleForm()
context = {
'form': form
}
return render(request, "blog/edit/form.html", context)
def edit_article(request, id):
next = get_next(request)
try:
article = Article.objects.get(id=id)
except ObjectDoesNotExist:
return HttpResponseRedirect(next)
if request.method == 'POST':
if not request.user.is_authenticated(
) or not request.user.is_staff or not request.user.is_active:
return HttpResponseRedirect('/')
if request.user != article.user:
return HttpResponseRedirect('/')
form = ArticleForm(request.POST, instance=article)
if form.is_valid():
form.save()
return HttpResponseRedirect(next)
else:
form = ArticleForm(instance=article)
return render_to_response('blog/edit_article.html', {
'form': form,
'article': article,
'next': next,
},
context_instance=RequestContext(request))
def article_create(request):
user = request.user
#if not user.is_staff or not user.is_superuser:
# raise Http404
#if not user.is_authenticated:
# raise Http404
# Tomamos el request dentro del formulario
# Para poder crear un articulo, adjuntar su imagen es necesario request.FILES or NOne
form = ArticleForm(request.POST or None, request.FILES or None)
if form.is_valid():
instance = form.save(commit=False)
instance.author = request.user
instance.publish = timezone.now()
# print(form.cleaned_data.get('title'))
# print(form.cleaned_data.get('content'))
instance.save()
# message success
messages.success(request, "Tus artículo ha sido creado con éxito")
return HttpResponseRedirect(instance.get_absolute_url())
# Rendering form errors in a view
if form.has_error:
# print(form.errors.as_json())
# print(form.errors.as_text())
data = form.errors.items()
for key, value in data:
# print(dir(value))
error_str = "{field}: {error}".format(
field=key,
error=value.as_text()
)
# print(error_str)
# print(form.non_field_errors)
# Falta que se limpien los campos delmformulario
#title = form.cleaned_data.get('title')
#form.cleaned_data.get('title')
#form.cleaned_data.get('title')
context = {
'form': form,
}
if user.is_authenticated():
context['userprofile'] = user.profile
return render(request, 'article_form.html', context)
def change_visible(request, article_id):
try:
article = Article.objects.get(id=article_id)
state_now = article.hiden
except Article.DoesNotExist:
raise Http404
if request.method == "POST":
form = ArticleForm(request.POST,
request.FILES,
instance=article,
article_id=article_id)
if form.is_valid():
article = form.save(commit=False)
article.hiden = not state_now
article.save()
url = reverse('my_articles')
return HttpResponseRedirect(url)
def edit_article(request, article_id):
if request.method == 'POST':
article_form = ArticleForm(request.POST)
context_dict = {'article_form': article_form}
if article_form.validate():
article = Article()
article_form.populate_obj(article)
article.put()
return redirect('index')
else:
# Get the details of the article
article_id = int(article_id)
article = Article.get_by_id(article_id)
article_form = ArticleForm(obj=article)
context_dict = {'article_form': article_form}
return render(request, 'edit_article.html', context_dict)
def update(self,request, *args, **kwargs):
'''
更新收藏
URL ： /iapi/blog/article/(?P<id>d+)/
参数：
所有参数均可选填
'''
f = ArticleForm(request.POST,request=request)
if f.is_valid():
try:
request.data = f.request.data.copy()
return super(ArticleHandler,self).update(request,*args,**kwargs)
except:
log.error('article_edit_error',exc_info=traceback)
return rc.NOT_FOUND
else:
log.debug('article update error')
raise FormValidationError(f)
def add_article(request):
if request.method == 'POST':
if not request.user.is_authenticated() or not request.user.is_staff or not request.user.is_active:
return HttpResponseRedirect('/')
form = ArticleForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
slug = form.cleaned_data['slug']
text = form.cleaned_data['text']
article=Article(title=title, slug=slug, text=text, user=request.user)
article.save()
return HttpResponseRedirect('/')
else:
form = ArticleForm()
return render_to_response('blog/add_article.html', {
'form': form,
},context_instance=RequestContext(request))
def formulaire(request):
if request.method == 'POST': # S'il s'agit d'une requête POST
form = ArticleForm(request.POST) # Nous reprenons les données
if form.is_valid(): # Nous vérifions que les données envoyées sont valides
# Ici nous pouvons traiter les données du formulaire
titreM = form.cleaned_data['titre']
auteurM = form.cleaned_data['auteur']
contenuM = form.cleaned_data['contenu']
categorieM=form.cleaned_data['categorie']
article = Article(titre=titreM, auteur=auteurM,contenu=contenuM,categorie=categorieM).save()
# Nous pourrions ici envoyer l'e-mail grâce aux données que nous venons de récupérer
envoi = True
else: # Si ce n'est pas du POST, c'est probablement une requête GET
form = ArticleForm() # Nous créons un formulaire vide
return render(request, 'blog/formulaire.html', locals())
def addArticle(request): categories=Category.objects.all(); if request.method=='POST': form=ArticleForm(request.POST,request.FILES) if form.is_valid(): title=form.cleaned_data['title'];summary=form.cleaned_data['summary'];paragraph=form.cleaned_data['paragraph'] caption=form.cleaned_data['caption'];link=form.cleaned_data['link'];linkText=form.cleaned_data['linkText']; image=form.cleaned_data['image'];category=form.cleaned_data['category']; envoi=True #creation of the section object article=Article(title=title,summary=summary,paragraph=paragraph,caption=caption,image=image,link=link,linkText=linkText) article.category=category; article.save(); return home(request); #return page(request,category); else: addArticle=True; displayForm=True; form=ArticleForm() return render(request, 'blog/blogForm.html',locals())
def add_article(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
title = request.POST.get('title')
summary = request.POST.get('summary')
content = request.POST.get('content')
type_id = request.POST.get('article_type_id')
if form.is_valid():
Article.objects.get_or_create(title=title, summary=summary, content=content,
article_type_id=type_id, author_id=request.user.id)
request.session['notice'] = u'%s发布成功' % title
return redirect('/blog/')
else:
print form.errors
error = form.errors.as_data().values()[0][0].messages[0]
return render(request, 'blog/article/add_article.html',
{'error': error, 'title': title, 'summary': summary,
'content': content})
else:
return render(request, 'blog/article/add_article.html')
def create(self,request, *args, **kwargs):
"""
创建收藏：
URL:/iapi/blog/article/
参数：
title : 收藏标题
content ： 收藏内容
desc ：收藏描述（可选）
like ： 赞
source ： 收藏来源
ctype : 收藏内容类型 （链接：link） （可选） 默认是按照纯文字展现
"""
f = ArticleForm(request.POST)
if f.is_valid():
try:
instance = f.save()
except:
log.error('article_create_error',exc_info=traceback)
else:
raise FormValidationError(f)
return instance
