def create_post(request): """ Muestra un formulario para crear un nuevo post y lo crea si la petición es POST :param request: HttpRequest :return: HttpResponse """ success_message = [] if request.method == 'GET': form = PostForm() else: form = PostForm(request.POST) if form.is_valid(): post_with_owner = Post() post_with_owner.owner = request.user # asigno como propietario del post, el usuario autenticado form = PostForm(request.POST, instance=post_with_owner) if form.is_valid(): new_post = form.save() # Guarda el objeto Post y lo devuelve form = PostForm() success_message = '¡Post creado con éxito!' success_message += '<br><a href="{0}">'.format( reverse('post_detail', args=[new_post.pk]) ) success_message += 'Ver foto' success_message += '</a>' context = { 'form': form, 'success_message': success_message } return render(request, 'posts/new_post.html', context)
def post(self, request, pk, idPost): """ Actualiza un post en base a la información POST :param request: HttpRequest :return: HttpResponse """ success_message = '' blog = UserUtils.getUserBlog(request.user.username) post_with_blog = Post() post_with_blog.blog = blog form = PostForm(request.POST, instance=post_with_blog) # Coge los datos del formulario sobreescribe los campos que tiene el objeto 'photo_with_owner' if form.is_valid(): new_post = form.save() # Guarda el objeto en BB.DD. y me lo devuelve form = PostForm() # Forzamos a que el formulario se vacie si la creacion de la foto ha sido satisfactoria success_message = 'Guardado con éxito!' success_message += '<a href = "{0}">'.format( reverse('post_detail', args=[new_post.blog.author.username,new_post.pk]) ) success_message += 'Ver post' success_message += '</a>' blog = UserUtils.getUserBlog(pk) possible_posts = self.get_posts_queryset(request).filter(blog__name=blog.name, pk=idPost).order_by('-publication_date') post_to_delete = possible_posts[0] if len(possible_posts) >= 1 else None if post_to_delete is not None: post_to_delete.delete() context = { 'form': form, 'success_message': success_message } return self.render(request, context)
def post(self, request): """ Crea un post en base a la información POST :param request: HttpRequest :return: HttpResponse """ success_message = '' blog = UserUtils.getUserBlog(request.user.username) post_with_blog = Post() post_with_blog.blog = blog form = PostForm(request.POST, instance=post_with_blog) # Coge los datos del formulario sobreescribe los campos que tiene el objeto 'photo_with_owner' if form.is_valid(): new_post = form.save() # Guarda el objeto en BB.DD. y me lo devuelve form = PostForm() # Forzamos a que el formulario se vacie si la creacion de la foto ha sido satisfactoria success_message = 'Guardado con éxito!' success_message += '<a href = "{0}">'.format( reverse('post_detail', args=[new_post.blog.author.username,new_post.pk]) ) success_message += 'Ver post' success_message += '</a>' context = { 'form': form, 'success_message': success_message } return self.render(request, context)
def newPost(request): """ :param request: :return: """ success_message='' categorias =Categoria.objects.all() if request.method == 'GET': form=PostForm() else: post_with_owner = Post() post_with_owner.owner=request.user form=PostForm(request.POST,instance=post_with_owner) if form.is_valid(): new_post=form.save() username=new_post.owner postid=new_post.pk success_message = 'Guardado con éxito' success_message += '<a href="{0}">'.format(reverse('post_detail',kwargs={'username':username,'postid':postid})) success_message += 'Ver Post' success_message += '</a>' form = PostForm() context = { 'form' : form, 'categorias' : categorias, 'success_message' : success_message } return render(request, 'posts/new-post.html',context)
def elo(request, slug): elo = get_object_or_404(Elo, slug=slug) ctx = {'elo':elo, } if elo.tipo == 'A' or request.user in elo.membros.all(): if request.user in elo.membros.all(): if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): form.instance.user = request.user form.save() form.instance.elos.add(elo) form = PostForm() else: form = PostForm(request.GET) ctx['form'] = form post_id = request.GET.get('post_id') if post_id: posts_list = Post.objects.filter(elos=elo, id=post_id).order_by('-data_de_atualizacao', '-data_de_criacao') else: posts_list = Post.objects.filter(elos=elo).order_by('-data_de_atualizacao', '-data_de_criacao') paginator = Paginator(posts_list, 10) posts = paginator.page(1) ctx['posts'] = posts return direct_to_template(request, 'elos/elo_posts.html', ctx) return HttpResponseRedirect(reverse('usuarios_elo', kwargs={'slug': slug}))
def post(self, request): """ Muestra un formulario para crear un nuevo post. :param request: HttpRequest :return: HttpResponse """ success_message = '' form_with_blog = Post() posible_blog = Blog.objects.filter(owner=request.user) blog = posible_blog[0] if len(posible_blog) == 1 else None if blog is not None: form_with_blog.blog = blog form = PostForm(request.POST, instance=form_with_blog) if form.is_valid(): new_post = form.save() form = PostForm() success_message = 'Guardado con éxito!' else: form = PostForm() context = { 'form': form, 'success_message': success_message } return render(request, 'posts/new_post.html', context)
def add_post(request): """Submit a new post. """ if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): # Save the submission post = form.save(commit=False) post.created_by = request.user post.save() # Notify managers of new submission c = Context({'post': post}) t = loader.get_template('posts/post_email.txt') text_message = t.render(c) t = loader.get_template('posts/post_email.html') html_message = t.render(c) mail_managers('New post submission', text_message, fail_silently=True, html_message=html_message) # Confirm submission messages.success(request, 'Thank you. Your post has been submitted.') return HttpResponseRedirect(reverse('post_list_view')) else: form = PostForm() return render_to_response('posts/post_add.html', {'form': form}, context_instance=RequestContext(request))
def form_valid(self, form): form = PostForm(self.request.POST) if form.is_valid(): soup = BeautifulSoup(form.instance.content, 'html.parser') form.instance.image = soup.img.get('src') form.instance.user = self.request.user form.save() return super(PostCreateView, self).form_valid(form)
def post(self, request, post_id): # This method submits the edits made to the post and redirects to the # main post page if valid post = Post.objects.get(id=post_id) form = PostForm(request.POST or None, instance=post) if form.is_valid(): form.save() return redirect("/posts/{}".format(post.titleslug)) else: return render(request, "posts/editpost.html", {"form": form})
def post(self, request): # This method creates the new blog post if the entries are valid and # redirects the user to the main page # If the form entries are not valid, errors are shown on the same page form = PostForm(request.POST) if form.is_valid(): form.save() return redirect("/posts") else: return render(request, "posts/newpost.html", {"form": form})
def create_view (request): if request.method == 'POST': form = PostForm (request.POST) if (form.is_valid()): save_form_data (form, Post()) return HttpResponseRedirect ('/posts') else: form = PostForm () return render (request, 'posts/edit.html', { 'form': form })
def submit(request): if request.method == 'POST': post = Post() form = PostForm(request.POST, instance=post) if form.is_valid(): p = form.save() messages.success(request, "Submission successful!") return redirect('posts:index') else: form = PostForm() return render(request, 'submit.html', {'form': form})
def edit(request, post_id): instance = get_object_or_404(Post, id=post_id) form = PostForm(request.POST or None, instance=instance) if form.is_valid(): form.save() for cat in form.cleaned_data.get("categories"): instance.categories.add(PostsCategories.objects.get(title=cat)) instance.save() return redirect("posts:get_post", post_id=post_id) return render(request, 'posts/create.html', {'form': form, 'button_name': "Змінити", "title": "Створити лист"})
def edit_view (request, post_id): post = Post.objects.get(id=post_id) if request.method == 'POST': form = PostForm (request.POST) if (form.is_valid()): save_form_data (form, post) return HttpResponseRedirect ('/posts/%s' % post_id) else: form = PostForm ({'title': post.title, 'author': post.author.id, 'content': post.content}) return render (request, 'posts/edit.html', { 'form': form })
def new(request): """ Used to add new posts """ post = Post(author = request.user) form = PostForm(request.POST or None, instance = post) if form.is_valid(): form.save() messages.success(request, u'Post deleted successfully') return redirect('posts:my_posts') return render(request, 'posts/new.html', locals())
def post(request): if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): post = form.save(commit=False)#creating the post but do not save yet to the database so we could set the user_posting just before we commit # post.user_posting = request.user post.save() return HttpResponseRedirect('/')#in case of successfull same go bak to the wall page with the new post in it# else: form = PostForm return render_to_response('posts/post.html', {'form': form}, context_instance=RequestContext(request))
def school(request, internalName): user = request.user posts = Post.objects.filter(school = School.objects.get(internalName = internalName)) if request.method == 'POST': postForm = PostForm(request.POST) if postForm.is_valid(): post = Post(title = postForm.cleaned_data['title'], user = user, school = user.get_profile().school, seekingFemale = postForm.cleaned_data['seekingFemale'], seekingMale = postForm.cleaned_data['seekingMale'], seekingTransgendered = postForm.cleaned_data['seekingTransgendered'], type = postForm.cleaned_data['hookupType'], allowOtherSchools = postForm.cleaned_data['allowOtherSchools'], text = postForm.cleaned_data['text']) post.save() return HttpResponseRedirect('') else: return render_to_response('schools/school.html', {'posts': posts, 'postForm': postForm, 'user': user, 'loginform': AuthenticationForm, 'logoSize': 50}, context_instance = RequestContext(request)) else: return render_to_response('schools/school.html', {'posts': posts, 'postForm': PostForm(), 'user': user, 'loginform': AuthenticationForm, 'logoSize': 50}, context_instance = RequestContext(request))
def post_update(request, id=None): instance = get_object_or_404(Post, id=id) form = PostForm(request.POST or None, instance=instance) if form.is_valid(): instance = form.save(commit=False) instance.save() messages.success(request, "Successfully Updated") return HttpResponseRedirect(instance.get_absolute_url()) else: messages.error(request, "Failed to Update") context_data = {'title':instance.title, 'instance':instance, 'form':form} return render(request, 'post_forms.html', context_data)
def create(request): if request.POST: form = PostForm(request.POST) if form.is_valid(): print(form.cleaned_data) new_user = form.new_user(request.user) new_user.save() for cat in form.cleaned_data.get("categories"): new_user.categories.add(PostsCategories.objects.get(title=cat)) new_user.save() return redirect("posts:all") else: form = PostForm() return render(request, "posts/create.html", {"form": form, "button_name": "Створити"})
def create(request): context = {} if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): context['post'] = form.save(commit=False) form.save() """ if 'post' in context: return render(request, 'posts/_post.html', context) else: return HttpResponse() """ return HttpResponseRedirect(reverse('index'))
def post_update(request, id=None): instance = get_object_or_404(Post, id=id) form = PostForm(request.POST or None, instance=instance) if form.is_valid(): instance = form.save(commit=False) instance.save() # message success messages.success(request, "Successfully updated") return HttpResponseRedirect(instance.get_absolute_url()) context = { "title": "Detail", "instance": instance, "form": form, } return render(request, "post_form.html", context)
def create_post_view(request): params = dict(current_page='create_post') if request.method == 'POST': form = PostForm(request.POST, auto_id=False) if form.is_valid(): slug = form.cleaned_data['slug'] text = form.cleaned_data['text'] post = Post(slug=slug, text=text) try: post.user = request.user post.save() return redirect('post_detail_view', post.slug) except Exception, e: messages.error(request, "create post errors: %s" % e) else: messages.error(request, "form errors: %s" % form.errors)
def post_create(request): if request.method == 'POST': print request.POST.get('title') print request.POST.get('content') form = PostForm(request.POST or None) if form.is_valid(): instance = form.save(commit=False) instance.save() messages.success(request, "Successfully Created") return HttpResponseRedirect(instance.get_absolute_url()) else: messages.error(request, "Not Successfully Created") context_data = {'form':form} # return HttpResponse("<h1>hello create</h1>") return render(request, 'post_forms.html', context_data)
def write_post(request): layout = 'vertical' if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): new_post = form.save(commit=False) new_post.author = request.user new_post.save() return show_timeline(request) else: form = PostForm() return render_to_response('posts/form.html', RequestContext(request, { 'form': form, 'layout': layout, }))
def post(self, request): post_with_owner = Post() post_with_owner.owner = request.user form = PostForm(request.POST, instance=post_with_owner) if form.is_valid(): new_post = form.save() form = PostForm() context = { 'form': form, } return render(request, 'posts/new_post.html',context)
def post_publish(request): if(request.method == 'POST'): form = PostForm(request.POST) if(form.is_valid()): ctx = BlogInfoContext(request, { 'form': form }) post = Post() post.content = form['content'].value() post.title = form['title'].value() post.published = datetime.datetime.now() post.save() return HttpResponseRedirect("/") else: form = PostForm() return render_to_response('post_create.html',{ 'form': form })
def get_post(request): if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): # process data in form.cleaned_data name = form.cleaned_data['name'] link = form.cleaned_data['link'] p = Post(name=name, link=link, publisher_id=request.user.id) p.save(); #redirect return HttpResponseRedirect('/posts') else: form = PostForm() return render(request, 'posts/post.html', {'form': form})
def post_create(request): if not request.user.is_authenticated(): raise Http404 # if not request.user.is_staff or not request.user.is_superuser: # raise Http404 form = PostForm(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, "post_form.html", context)
def post_create(request): if not request.user.is_staff: #or not request.user.is_admin: raise Http404 form = PostForm(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 pops out messages.success(request, 'Post Created Successfully!') return HttpResponseRedirect(instance.get_absolute_url()) if request.method == "POST": print request.POST context = { "form": form, } return render (request, "post_form.html", context)
def post(self, request): """ Crea un post en base a la información POST. Con el decorador @login_required() nos va a ejecutar esta función solamente en el caso de que el usuario esté autenticado. En caso contrario, redirigirá a una url del paquete django.contrib.auth que redefinimos en el settings.py LOGIN_URL. Esta es la magia que hace Django para redireccionar al usuario a una url en el caso de que intente acceder a una url protegida sólo accesible si está autenticado. :param request: Objeto HttpRequest con la petición :return: HttpResponse """ success_message = '' # Creo un post vacío y le asigno el blog actual. post_with_blog = Post() post_with_blog.blog = request.user.blog # Le pedimos al formulario que en vez de usar la instancia que él crea, utilice la que le # indicamos con el post_with_blog. Con esto, guarda la instancia con todos los campos del # formulario, excepto del blog, que coge el que le indicamos nosotros que ha sido creado. form = PostForm(request.POST, instance=post_with_blog) if form.is_valid(): # Si se valida correctamente creamos objeto post, lo guardamos en DB y lo devolvemos # Obtenemos el blog del usuario autenticado para guardarlo automáticamente. new_post = form.save() # Reiniciamos formulario y componemos mensaje con enlace al nuevo post creado. Para acceder a una url # nombrada en un controlador utilizamos la función reverse, con los argumentos de la url nombrada, en este # caso, el nombre del blog, y la pk del post. # Como por defecto Django escapa el HTML, necesitamos indicar que el enlace al nuevo post no escape HTML. # Lo indicamos en la plantilla con el |safe en el mensaje. Lo normal es que este trabajo se haga en el # template form = PostForm() success_message = '¡Post creado con éxito! ' success_message += '<a href="{0}">'.format(reverse('post_detail', args=[new_post.blog, new_post.pk])) success_message += 'Ver post' success_message += '</a>' context = { 'form': form, 'success_message': success_message } return self.renderize(request, context)
def p_create(request): if request.method == 'POST': # POST 방식으로 호출 될 때 post_form = PostForm(request.POST) if post_form.is_valid(): user_id = request.session.get('user') user = User.objects.get(username=user_id) new_post = Post(author=user, title=post_form.cleaned_data['title'], contents=post_form.cleaned_data['contents']) new_post.save() return redirect('posts:list') else: # GET 방식으로 호출 될 때 post_form = PostForm() return render(request, 'create.html', {'post_form': post_form})
def post_edit(request, username, post_id): edit_post = get_object_or_404(Post, pk=post_id) if edit_post.author == request.user: if request.method == "POST": form = PostForm(request.POST, files=request.FILES or None, instance=edit_post) if form.is_valid(): form.save() return redirect("post", username, post_id) form = PostForm(instance=edit_post) return render( request, "new_post.html", { "form": form, "username": username, "post_id": post_id, "edit_post": edit_post }) return redirect("post", username, post_id)
def post(self, request): # Nos definimos previamente un formulario con el valor del usuario que hemos excluido de la página. new_post_in = Post(owner=request.user) # Coge los datos del formulario y de los ficheros form = PostForm(request.POST, request.FILES, instance=new_post_in) if form.is_valid(): new_blog_in = form.save() messages.success(request, 'El post: {0} ha sido creado con éxito.'.format(new_post_in.title)) # Se limpia el formulario para una nueva inserción form = PostForm() else: storage = generate_new_html_errors(form.errors) for msg in storage: messages.error(request, storage.get(msg)) return render(request, 'posts/new_post.html', {'form': form})
def create_post(request): """ Create new post view """ if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() return redirect('posts:feed') else: form = PostForm() return render(request=request, template_name='posts/new.html', context={ 'form': form, 'user': request.user, 'profile': request.user.profile })
def post_create(request): form = PostForm(request.POST or None,request.FILES or None) if form.is_valid(): instance=form.save(commit=False) instance.save() messages.success(request,"Successfully Posted") return HttpResponseRedirect(instance.get_absolute_url()) context={ "form":form, "title":"create view", } return render(request,"postform.html",context)
def ajax_publication_date(request, post_id): if request.is_ajax(): post = get_object_or_404(Post, id=post_id) form = PostForm(request.POST, instance=post) if form.is_valid(): form.save() data = { 'message' : 'The publication date has been saved.' } else: publication_date_errors = form.errors.get('publication_date') if publication_date_errors == None: data = { 'message' : 'The publication date has not been saved.' } else: data = { 'message' : form.errors['publication_date'][0] } return JsonResponse(data)
def post_update(request, slug=None): if not request.user.is_staff or not request.user.is_superuser: raise Http404 instance = get_object_or_404(Post, slug=slug) form = PostForm(request.POST or None, request.FILES or None, instance=instance) if form.is_valid(): instance = form.save(commit=False) instance.save() messages.success(request, "<a href='#'>Successfully</a> Saved", extra_tags="html_safe") return HttpResponseRedirect(instance.get_absolute_url()) context = { "title": instance.title, "instance": instance, "form": form, } return render(request, "post_form.html", context)
def write_post(request): layout = 'vertical' if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): new_post = form.save(commit=False) new_post.author = request.user new_post.save() return show_timeline(request) else: form = PostForm() context = RequestContext( request, { 'form': form, # The Django form instance 'layout': layout, # For bootstrap toolkit UI rendering }) return render_to_response('posts/form.html', context)
def post(self, request): """ Procesa el formulario para crear un usuario :param request: objeto HttpRequest :return: HttpResponse con la respuesta """ post = Post() post.owner = request.user form = PostForm(request.POST, instance=post) if form.is_valid(): # creamos el post post = form.save() # limpiar el formulario form = PostForm() # Devolvemos un mensaje de OK messages.success(request, 'Post creado correctamente') context = {'form': form} return render(request, 'posts/form.html', context)
def new_post(request): profile = request.user.profile if request.method == 'POST': form = PostForm(profile, request.POST, request.FILES) if form.is_valid(): post = form.save(commit=False) post.user = request.user post.content = request.POST.get('content') if request.POST.get('action') == "save": post.save() post.tag_save() return redirect('edit_post', pk=post.pk, slug=post.slug) elif request.POST.get('action') == "submit": post.published = True post.save() post.tag_save() return redirect('detail', pk=post.pk, slug=post.slug) else: form = PostForm(profile) return render(request, 'new_post.html', {'form': form, })
def create_post(request): """Create new post view.""" if request.method == "POST": form = PostForm(request.POST, request.FILES) if form.is_valid(): form.save() return redirect("feed") else: form = PostForm() return render( request=request, template_name="posts/new.html", context={ "form": form, "user": request.user, "profile": request.user.profile }, )
def post_create(request): if not request.user.is_authenticated: raise Http404 if not request.user.is_staff or not request.user.is_superuser: raise Http404 form = PostForm(request.POST or None, request.FILES or None) if form.is_valid(): instance = form.save(commit=False) instance.content = instance.content.replace(u"\u2018", "'").replace( u"\u2019", "'").strip() instance.user = request.user if not instance.publish: instance.publish = timezone.now().date() instance.save() messages.success(request, 'Post successfully created!') return HttpResponseRedirect(instance.get_absolute_url()) context = {'title': 'Create Post', 'form': form} return render(request, 'post_form.html', context)
def post_update(request, slug=None): if not request.user.is_staff or not request.user.is_superuser: raise Http404 post = get_object_or_404(Post, slug=slug) form = PostForm(request.POST or None, request.FILES or None, instance=post) if form.is_valid(): post = form.save(commit=False) post.save() # message success messages.success(request, 'Post was successfully edited', extra_tags="some-tags") # link = '/post/'+post.id return redirect('posts:detail', post.slug) context = { "title": post.title, "post": post, "form": form, } return render(request, 'posts/post_form.html', context)
def write_post(request, p_idx): park_post = get_object_or_404(Park_number, p_idx=p_idx) if request.method == 'POST': if request.FILES: post = Post(p_idx=park_post, author=request.user, images=request.FILES['images']) else: post = Post(p_idx=park_post, author=request.user, images=None) post_form = PostForm(request.POST, instance=post) if post_form.is_valid(): post_form.save() path = '/posts/{}/detail'.format(p_idx) return redirect(path) # post_form = Post(p_idx=p_idx, author=request.user, starpoint=request.POST['starpoint'], contents=request.POST['contents'], images=request.FILES['images']) # post_form.save() # return redirect('posts:detail') else: post_form = PostForm() return render(request, 'write.html', {'post_form': post_form})
def edit_post(request, post_id): """ Renders form to edit post with specified post_id. Only author of the post can edit the form otherwise user will be redirected to post page """ post = get_object_or_404(Post, pk=post_id) if request.user != post.author: return redirect('index') form = PostForm(request.POST or None, files=request.FILES or None, instance=post) if request.method == 'POST': if form.is_valid(): form.save() return redirect('post', post_id=post.pk) return render(request, 'new_post.html', {"form": form, "post": post})
def post_create(request): form = PostForm(request.POST or None) if form.is_valid(): instance = form.save(commit=False) #print (form.cleaned_data.get("title")) instance.save() #message success messages.success(request, "Successfully Created") return HttpResponseRedirect(instance.get_absolute_url()) #else: #messages.success(request," Not Successfully Created") #if request.method=="POST": # print request.POST.get("content") # print request.POST.get("title") # Post.objects.create(title=title) context = { "form": form, } return render(request, "post_form.html", context)
def post_edit(request, username, post_id): author = get_object_or_404(User, username=username) post = get_object_or_404(Post, author=author, id=post_id) user = request.user if user != author: return redirect("post", username=post.author, post_id=post.id) form = PostForm(request.POST or None, files=request.FILES or None, instance=post) if request.method == "POST": if form.is_valid(): form.save() return redirect("post", username=post.author, post_id=post.id) return render(request, "new_post.html", { "form": form, "edit": True, "post": post, "author": author })
def update(request, pk): if request.method == "POST": post = get_object_or_404(Post, pk=pk) form = PostForm(request.POST) if form.is_valid(): data = form.cleaned_data post.title = data['title'] post.content = data['content'] post.language = data['language'] post.category = data['category'] post.save() print(repr(post)) return redirect("posts:detail", pk=pk) elif request.method == "GET": post = get_object_or_404(Post, pk=pk) context = { "post" : post } return render(request, 'editpost.html', context=context)
def post(self, request): current_page = 'home' form = PostForm(request.POST, request.FILES or None, auto_id=False) if form.is_valid(): post = form.save(commit=False) post.user = request.user post.save() messages.success(request, "Post successfully created!") text = form.cleaned_data['post'] else: messages.error(request, "Post not created!") form = PostForm() return redirect('home:home') args = { 'form': form, 'text': text, 'current_page': current_page, } return render(request, self.template_name, args)
def post_update(request, slug=None): if not request.user.is_authenticated: #request.user.is_staff or not request.user.is_superuser: raise Http404("please login first, to update your post") instance = get_object_or_404(Post, slug=slug) form = PostForm(request.POST or None, request.FILES or None, instance=instance) if form.is_valid(): instance = form.save(commit=False) # instance.category = form.cleaned_data.get("category") instance.save() # Without this next line the tags won't be saved. form.save_m2m() messages.success(request, "Post Updated", extra_tags='html_safe') return HttpResponseRedirect(instance.get_absolute_url_jb_app()) context = { "title": instance.title, "instance": instance, "form": form, } return render(request, "jb_app_posts/posts_form.html", context)
def group(request, grpid): # If the user viewing is not a member of this group, # tell them it's a 404. try: group = request.user.group_set.get(id=grpid) except: raise Http404 if request.method == 'POST': form = PostForm(request.POST) if form.is_valid(): post = form.save(commit=False) # author = from the current user's set of memberships, the one that # has a group with matching group id (pk) post.author = request.user.membership_set.get(group__pk=grpid) post.save() return HttpResponseRedirect("") else: # not POST, so give a form with some prepopulated stuff form = PostForm() '''relations are represented by double underscores (i heart django)''' post_list = list(Post.objects.filter(author__group__pk=grpid)) # Is the user an admin for this group? is_admin = request.user.membership_set.get(group__pk=grpid).is_admin # if the user is an admin, give them a list of the current invites invites = [] if (is_admin): invites = EmailInvite.objects.filter(group__pk=int(grpid)) return render( request, 'group_view.html', { 'post_list': post_list, 'group': group, 'user': request.user, 'form': form, 'is_admin': is_admin, 'invites': invites })
def account_detail(request, slug=None): user = get_object_or_404(User, username=slug) query_list_posts = Post.objects.filter(to_user=user).filter(wait=False) paginator = Paginator(query_list_posts, 2) page = request.GET.get('page') try: contacts = paginator.page(page) except PageNotAnInteger or EmptyPage: contacts = paginator.page(1) form_post = PostForm(request.POST or None) form_comment = CommentForm(request.POST or None) if request.method == 'POST' and 'btnform2' in request.POST: if form_comment.is_valid() and request.user.is_authenticated(): comment_parent_id = request.POST.get("comment_parent") # comment_parent = get_object_or_404(Post, id=int(comment_parent_id)) comment = form_comment.save(commit=False) comment.from_user = request.user comment.to_user = user comment.parent = int(comment_parent_id) comment.save() return redirect(reverse("accounts:detail", kwargs={"slug": slug})) elif request.method == 'POST' and 'btnform1' in request.POST: if form_post.is_valid() and request.user.is_authenticated(): post = form_post.save(commit=False) post.from_user = request.user post.to_user = user post.save() return redirect(reverse("accounts:detail", kwargs={"slug": slug})) # comments = Comment.objects.filter(to_user=user) context = { "user": user, "posts": query_list_posts, 'form_post': form_post, 'form_comment': form_comment, "contacts": contacts, } return render(request, "account.html", context)
def post_create(request): if not request.user.is_staff or not request.user.is_superuser: raise Http404 # if not request.user.is_authenticated(): # raise Http404 form = PostForm(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()) else: messages.error(request, "Not Created!") context = { "form": form, } return render(request, "post_form.html", context)
def post_update(request, slug=None): if not request.user.is_authenticated(): messages.error(request, "You need to login first") # return redirect(reverse('posts:login')) return redirect(reverse('posts:homepage')) post = get_object_or_404(Post, slug=slug) if post.user.username == request.user.username: form = PostForm(request.POST or None, request.FILES or None, instance=post) if form.is_valid(): instance = form.save(commit=False) instance.save() messages.success(request, "Updated: %s" % (str(instance.updated))) messages.success(request, "Notice Successfully updated") return HttpResponseRedirect(instance.get_absolute_url()) context = {"post": post, "form": form} return render(request, "post_form.html", context) else: messages.error(request, "You cannot edit this post!") return redirect(post.get_absolute_url())
def post(self, request, *args, **kwargs): form = PostForm(request.POST) if form.is_valid(): title = request.POST.get('title') description = request.POST.get('description') if 'photo' in request.FILES: photo = request.FILES.get('photo') id = request.POST.get('id') user = User.objects.get(id=id) if 'photo' in request.FILES: blogpost = Post(title=title, description=description, photo=photo, post_user=user) else: blogpost = Post(title=title, description=description, post_user=user) blogpost.save() messages.success(request, 'You have successfully made a new post...') return redirect('dashboard')
def view_user_profile(request, username): user = User.objects.get(username = username) post_list = UserPost.objects.filter(user_id = user.id).order_by('-date') if request.method == 'POST': post_form = PostForm(request.POST, request.FILES, ) if post_form.is_valid(): instance = post_form.save(commit = False) instance.user = request.user instance.save() messages.success(request, f'New post created!') return redirect('user-profile', username = user) else: post_form = PostForm() context = {'user':user, 'post_list': post_list, 'post_form':post_form} return render(request, 'users/user_profile.html', context)
def post_edit(request, username, post_id): post = Post.objects.get(pk=post_id) if post.author != request.user: return redirect('post', username, post_id) if request.method == 'POST': form = PostForm(request.POST, instance=post) if form.is_valid(): post.author = request.user form.save() return redirect( reverse('post', kwargs={ 'username': username, 'post_id': post_id })) else: form = PostForm(instance=post) form = PostForm(instance=post) return render(request, 'newpost.html', { 'form': form, 'post': post, 'is_edit': True })
def post(self, request): # Define new instance post = Post() # Add user logged post.owner = request.user # Create form form = PostForm(request.POST, request.FILES, instance=post) # Validate form if form.is_valid(): # Create add post = form.save() # Clear form form = PostForm() # Redirect return redirect('blogs') context = {'form': form} return render(request, 'posts/new_post.html', context)
def post_update(request, id=None): instance = get_object_or_404(Post, id=id) form = PostForm(request.POST or None, request.FILES or None, instance=instance) print(request.user, instance.user) if not (request.user == instance.user): return redirect("posts:list") if form.is_valid(): instance = form.save(commit=False) instance.save() messages.success(request, "Successfully updated") return HttpResponseRedirect(instance.get_absolute_url()) else: messages.error(request, "Something went wronge") context = { "instance": instance, "form": form, } return render(request, "post_form.html", context)
def user_account(request): username = request.user user = User.objects.get(username = username) if request.method == 'POST': form = PostForm(request.POST, request.FILES) if form.is_valid(): new_post = form.save(commit=False) new_post.author = request.user new_post.post_time = timezone.now() new_post.save() return HttpResponseRedirect(request.path) else: form = PostForm() user_posts = Post.objects.filter(author = user).order_by("-post_time") page = request.GET.get('page', 1) paginator = Paginator(user_posts, 10) try: post_list = paginator.page(page) except PageNotAnInteger: post_list = paginator.page(1) except EmptyPage: post_list = paginator.page(paginator.num_pages) context = {'user': user, 'form':form, 'user_posts': post_list} return render(request, 'account/account.html', context)