def post(self, request): post = Post() form = PostForm(request.POST, instance=post) try: author_blog = Blog.objects.get(user=request.user) # Asignamos el post al blog del usuario autenticado post.blog = author_blog if form.is_valid(): post = form.save() form = PostForm() url = reverse("post_detail_page", args=[request.user, post.pk]) message = "¡Post creado con éxito!" message += mark_safe('<a href={0}> Ver post </a>'.format(url)) messages.success(request, message) except ObjectDoesNotExist: messages.add_message( request, messages.ERROR, "Este usuario no dispone de un blog asociado. Consulte con el administrador" ) form = PostForm() return render(request, "post_form.html", {'form': form})
def post(self, request): success_message = "" blogs_list = Blog.objects.filter(owner__username__exact=request.user.username) if len(blogs_list) == 1: post_in_blog = Post() post_in_blog.blog = blogs_list[0] # asigno como propietario de la foto el usuario autenticado form = PostForm( request.POST, instance=post_in_blog ) # basa la instancia de la petición en la que yo te paso. Mezcla campos!! if form.is_valid(): new_post = form.save() # Crea, guarda y devuelve el objeto form = PostForm() # lo inicializamos tras guardar para que aparezca vacío de nuevo # Creamos nuestro mensaje de éxito con el link a la foto success_message = "Guardado con éxito!!" success_message += '<a href="{0}">'.format( reverse("post_detail", args=[request.user.username, new_post.pk]) ) success_message += "See post" success_message += "</a>" context = {"form": form, "success_message": success_message} return render(request, "blogs/new_post.html", context) else: return HttpResponseNotFound("Houston, we have a problem")
def validate_attachment(self): post = Post() post.attachment = self.initial_data.get("file") if post.get_attachment_type() == post.NONE: raise serializers.ValidationError(_("Fichero de tipo incorrecto"))
def post(self, request): post = Post() post.user = request.user #select user autenticated form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): form.save() return redirect("home_page") return render(request, "create_post_form.html", {"form": form})
def create(self, request): post = Post() post.user = request.user serializer = PostCreateSerializer(data=request.data, instance=post) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): post = Post() post.owner = request.user form = PostForm(request.POST, instance=post) if form.is_valid(): new_post = form.save() messages.success(request, 'Post creado correctamente con ID {0}'.format(new_post.pk)) form = PostForm() context = {'form': form} return render(request, 'blogs/new_post.html', context)
def post(self, request): blog_post = Post() blog_post.user = request.user form = PostForm(request.POST, instance=blog_post) if form.is_valid(): post = form.save() form = PostForm() url = reverse("post_detail_page", args=[request.user, post.pk]) message = "Post created successfully! " message += '<a href="{0}">View</a>'.format(url) messages.success(request, message) return render(request, "post_form.html", {'form': form})
def create_tutorial_post_for_new_blog(sender, instance, created, **kwargs): if created: t = Tag.objects.get_or_create(blog=instance, name='Site Info')[0] post_template = get_template('blogs/rendered/post_sample_body.md') context = Context({}) p = Post( blog=instance, title='Hello, World', body=post_template.render(context) ) p.save() p.tags.add(t)
def post(self, request): post = Post() post.user = request.user # post.id = pk form = PostForm(request.POST, instance=post) if form.is_valid(): post = form.save() form = PostForm() url = reverse("post_detail_page", args=[post.user.username, post.pk]) message = "¡¡ Se ha creado una nueva entrada !!" message += '<a href="{0}">Ver</a>'.format(url) messages.success(request, message) return render(request, "post_form.html", {'form': form})
def addBlog(request): if request.method == "POST": postTitle = request.POST['postTitle'] postcontent = request.POST['postContent'] postAuthorName = request.user #request.POST['postAuthorName'] postSlug = postTitle.replace(' ', '-') post = Post(title=postTitle, author=postAuthorName, content=postcontent, slug=postSlug) post.save() return redirect('/blogs') else: return redirect('home')
def post(self, request): post = Post() post.user = request.user post.blog = request.user.blog form = PostForm(request.POST, instance=post) if form.is_valid(): post = form.save() #vaciamos el formulario form = PostForm() url = reverse("post_detail", args=[post.user,post.pk]) #reverse genera url pasandole el tipo de URL message = " created successfully!" message += '<a href="{0}">Create your first post</a>'.format(url) #enviamos mensaje de exito con un enlace a la pelicula que acabamos de cr messages.success(request, message) return render(request, "post_form.html", {'form':form})
def add_blog(request): if request.method == 'POST': form = BLOGENTRY(request.POST) if form.is_valid(): form = form.cleaned_data a, b = Author(), Post() a.name, a.email = form['name'], form['email'] if Author.objects.filter(email=form['name'], name=form['name']).count() == 0: a.save() b.title = form['title'] b.date = timezone.now() b.author = a b.body = form['blog'] b.save() return index(request) else: form = BLOGENTRY() return render(request, 'add_blog.html', {'form': form})
def populate_fake_data(N=5): for i in range(N): title = fake.sentence(nb_words=6, variable_nb_words=True, ext_word_list=None) body = " ".join( fake.texts(nb_texts=3, max_nb_chars=200, ext_word_list=None)) created_on = fake.date_time_between(start_date='-2y', end_date='now', tzinfo=None) # updated_on = fake.date_time_between(start_date='-2y', end_date='now', tzinfo=None) post = Post(title=title, body=body, created_on=created_on) post.save() for cat in get_category(): post.categories.add(cat) create_comments(post)
def test_create_comment(self): Comment.post = Post(title='Post being commented on') Comment.author = User(username='******') comment = Comment(author='James', text='This is my first test comment') self.assertEqual(comment.author, 'James') self.assertEqual(comment.text, 'This is my first test comment')
def post(self, request): """ Procesa el formulario para la crear el anuncio :param request: objeto HttpRequest :return: HttpResponse con la respuesta """ post = Post() post.owner = request.user form = PostForm(request.POST, request.FILES, instance=post) if form.is_valid(): post = form.save() form = PostForm() messages.success(request, 'Anuncio creado correctamente') context = {'form': form} return render(request, 'blogs/form.html', context)
def add_blog(request) : if request.method=='POST': form=BLOGENTRY(request.POST) if form.is_valid() : form=form.cleaned_data A=Post(title=form['title'],body=form['blog'],date=timezone.now(),author=Author.objects.get(handle=request.user.username)) try : A.save() except IntegrityError as e: return render(request,'add_blog.html',{'form':BLOGENTRY(),'error':e.message}) return index(request) else : return render(request,'add_blog.html',{'form':BLOGENTRY(),'error':'something went wrong..'}) else : return render(request,'add_blog.html',{'form':BLOGENTRY()})
def test_doesnt_regenerate_slug_if_same_title(self): test_title = 'Test title' post = Post(title=test_title, author=self.new_user) post.generate_unique_slug() post.save() self.assertEqual(post.slug, 'test-title') post.save() self.assertEqual(post.slug, 'test-title')
def test_create_post(self): Post.author = User(username='******') post = Post(author='Max', title='My first test post', text='This is my first test post') self.assertEqual(post.author, 'Max') self.assertEqual(post.title, 'My first test post') self.assertEqual(post.text, 'This is my first test post')
def post(self, request, pk=None): post = Post(blog=request.user.blog) form = PostForm(request.POST, instance=post) if form.is_valid(): if pk is not None: post.response = Post.objects.filter(pk=pk).first() form.save() send_email = self.need_send_email(post) if send_email: self.send_email_notification(post) return redirect(home) else: message = _("blogs.views.error_create_post") context = {"post": post, "form": form, "message": message} return render(request, 'blogs/post_new.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 fake_posts(count=50): for i in range(count): post = Post( title = fake.sentence(), body = fake.text(2000), category_id = random.randint(1, Category.query.count()), timestamp=fake.date_time_this_year() ) db.session.add(post) db.session.commit()
def api_create_blog_view(request): account = Account.objects.get(pk=1) post = Post(author=account) if request.method == "POST": serializer = PostSerializer(post, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def setUp(self): self.posts = [ Post(uuid=uuid.uuid4(), author='*****@*****.**', heading='post 1', content='post 1 content'), Post(uuid=uuid.uuid4(), author='*****@*****.**', heading='post 2', content='post 2 content') ] Post.objects.bulk_create(self.posts) self.author_user = User.objects.create_user(username='******', password='******') self.author_user.author.is_author = True self.author_user.author.save() self.normal_user = User.objects.create_user(username='******', password='******') self.url = reverse('blogs:new')
def post(self, request): """ Crea un post en base a la información POST :param request: :return: """ success_message = "" post_with_owner = Post() post_with_owner.owner = request.user form = PostForm(request.POST, instance=post_with_owner) if form.is_valid(): # Guardamos el objeto post y lo devolvemos new_post = form.save() form = PostForm() success_message = "Post generado con éxito!" success_message += '<a href="{0}">'.format(reverse("post_detail", args=[new_post.owner, new_post.pk])) success_message += " Ver post" success_message += "</a>" context = {"form": form, "success_message": success_message} return render(request, "blogs/new_post.html", context)
def test_save(self): self.assertEqual(User.objects.count(), 0) new_user = User.objects.create_user(username='******', password='******') new_post = Post(author=new_user) form = PostModelForm({'title': 'Cats'}, instance=new_post) result = form.is_valid() form.save() self.assertTrue(result) self.assertEqual(User.objects.count(), 1)
def newpost(request): if request.user.is_authenticated(): if request.method == 'POST': titles= request.POST.get('title') data = request.POST.get('postdata') time=datetime.now() p = Post(title=titles,post=data,created=time) p.save() return HttpResponseRedirect("/") else: status = request.GET.get('status') t = get_template('addpost.html') if status: html = t.render(Context({'message' : "Username already exists"})) else: html = t.render(Context({'message' : ""})) return HttpResponse(html) else: return HttpResponseRedirect("/")
def get(self, request): ''' Post Form render. If data are correct the form save the content if not sends a feedback. User must logged ''' success_message = '' post = Post() post_form = PostForm() # Template context context = {'form': post_form, 'message': success_message} return render(request, 'blogs/post-create.html', context)
def delete_cascade(self, user): # delete comments user_comments = Comment.query(Comment.user == user.key) CommentDeleteMixin.delete_cascade_multi(self, user_comments) # delete posts user_posts = Post.query(Post.author == user.key) for post in user_posts: post.delete_cascade() # delete reactions user_reactions = Reaction.query(Reaction.user == user.key) ndb.delete_multi(user_reactions.fetch(keys_only=True)) # finally, the user itself user.key.delete()
def post(self, request): """ Publicar el post :param request: HttpRequest :return: HttpResponse """ # Crear el post con los datos del POST post = Post(owner=request.user) form = PostForm(request.POST, instance=post) if form.is_valid(): post.save() for genre in form.cleaned_data["genres"]: post.genres.add(genre) form = PostForm() message = 'Publicado' else: message = 'No se ha publicado' context = {"form": form, "message": message} return render(request, 'blogs/new_post.html', context)
def new_post(): form = PostForm() if form.validate_on_submit(): post = Post(title=form.title.data, content=form.content.data, author=current_user) db.session.add(post) db.session.commit() flash('Post Created Successfully', 'success') return redirect(url_for('home')) return render_template('create_post.html', title='New Post', legend='New Post', form=form)
def content_html(self): '''直接渲染模板''' from blogs.models import Post from comment.models import Comment result = '' if self.display_type == self.DISPLAY_HTML: result = self.content elif self.display_type == self.DISPLAY_LATEST: context = { 'posts': Post.latest_posts() } result = render_to_string('config/blocks/sidebar_posts.html', context) elif self.display_type == self.DISPLAY_HOT: context = { 'posts': Post.hot_posts() } result = render_to_string('config/blocks/sidebar_posts.html', context) elif self.display_type == self.DISPLAY_COMMENT: context = { 'comments': Comment.objects.filter(status=Comment.STATUS_NORMAL) } result = render_to_string('config/blocks/sidebar_comments.html', context) return result
def post(self): data = request.get_json() subject = data.get('subject') content = data.get('content') tags = data.get('tags', []) user = g.user if subject and content: new_post = Post(author=user.key, subject=subject, content=content) # store it in DB new_post.put() new_post.add_tags(tags) new_post_key = new_post.key return ( {'key': new_post_key.integer_id()}, 201, {'Location': api.url_for(UserBlogPostAPI, username=user.username, post_id=new_post_key.integer_id())}, ) else: return None, 400 # Bad Request
def post(self, request): success_message = '' # Creo un post vacío con el usuario para pasarselo al formulario # De este modo oculto el campo owner y lo cargo automaticamente. post_with_owner = Post() post_with_owner.owner = request.user form = PostForm(request.POST, instance=post_with_owner) if form.is_valid(): # Creo el post con los datos del formulario y lo almaceno en nueva new_post new_post = form.save() form = PostForm() success_message = 'Guardado con exito!' success_message += '<a href="{0}">'.format(reverse('post_detail', args=[new_post.owner, new_post.pk])) success_message += 'Ver post' success_message += '</a>' context = { 'form': form, 'success_message': success_message } return render(request, 'blogs/post_create.html', context)
def create(self, validated_data): user_id = self.context.get("user_id") category_ids = self.context.get("category") categories = [] if category_ids != ['']: categories = Category.objects.filter(id__in=category_ids) user = User.objects.get(id=user_id) post = Post(**validated_data) post.blog = self.get_user_blog(user) post.save() for cat in categories: post.category.add(cat) post.save() return post
def get_user_base_context(self, user): username = user.username return OrderedDict([ ("username", username), ("id", user.key.integer_id()), ("uri", urls.get_user_uri(username)), ("email", user.email), ("full_name", user.full_name), ("bio", user.bio), ("blogsposts_count", Post.query(Post.author == user.key).count()), ("blogposts_uri", urls.get_user_blogposts_uri(username=username)), ("reactions_uri", urls.get_user_reactions_uri(username=username)), ("comments_uri", urls.get_user_comments_uri(username=username)), ("is_active", user.is_active), ("is_admin", user.is_admin), ("joined", datetime.strftime(user.joined, TIME_FMT)), ("last_updated", datetime.strftime(user.last_updated, TIME_FMT)), ])
def post(self, request): """ Presenta el formulario para crear una foto y, en caso de que la petición sea POST la valida y la crea en caso de que sea válida :param request: objeto HttpRequest con los datos de la petición :return: objeto HttpResponse con los datos de la respuesta """ message = None post_with_user = Post(owner=request.user) post_form = PostForm(request.POST, instance=post_with_user) if post_form.is_valid(): new_post = post_form.save() post_form = PostForm() message = 'Foto creada satisfactoriamente. <a href="{0}">Ver foto</a>'.format( reverse('photos_detail', args=[new_post.pk]) ) context = {'form': post_form, 'message': message} return render(request, 'photos/photo_creation.html', context)
def get(self): posts = Post.query().order(-Post.created) return [self.get_post_context(p) for p in posts]
def get(self, username): user = get_user_by_username_or_404(username) posts = Post.query(Post.author == user.key).order(-Post.created) return [self.get_post_context(p) for p in posts]