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