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 test_can_generate_unique_slug(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 = Post(title=test_title, author=self.new_user) post.generate_unique_slug() post.save() self.assertEqual(post.slug, '0test-title') post = Post(title=test_title, author=self.new_user) post.generate_unique_slug() post.save() self.assertEqual(post.slug, '1test-title')
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 handle(self, *args, **options): password = encrypt_string('Password123') u1 = User(firstname='Caleb', lastname='Smith', username='******', email='*****@*****.**', password=password, biography='Sample Bio') u1.save() u2 = User(firstname='John', lastname='Doe', username='******', email='*****@*****.**', password=password, biography='Hello') u2.save() u3 = User(firstname='Private', lastname='Test', username='******', email='*****@*****.**', password=password, biography='Hidden') u3.private = True u3.save() Post(creator=u1, content='First Post Ever').save() Post(creator=u1, content='Second Post').save() p3 = Post(creator=u2, content="John's Post") p3.save() t = Topic(name="Example Topic") t.save() u1.interests.add(t) u1.save() Report(reporter=u1, post=p3).save()
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 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 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 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 post(self, request): # crear el formulario con los datos del POST task_with_user = Post(owner=request.user) form = PostForm(request.POST, request.FILES, instance=task_with_user) # validar el formulario if form.is_valid(): # crear el post post = form.save() return HttpResponseRedirect( reverse('blog_detail', args=[task_with_user.owner.username])) else: # mostrar mensaje de error message = "Se ha producido un error" # renderizar la plantilla context = {"form": form, "message": message} return render(request, 'blogs/new_post.html', context)
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 post(self, request): """ Creates a new post :param request: HttpRequest object :return: HttpResponse object """ new_post = Post(author=request.user) form = PostForm(request.POST, instance=new_post) context = dict() if form.is_valid(): post = form.save() # Redirect to post detail return redirect('post_detail', username=post.author, pk=post.pk) else: context['error'] = "Error submitting new post" context['blog'] = request.user.username context['form'] = form return render(request, 'blogs/new_post.html', context)
def post(self, request): ''' Post Form render. If data are correct the form save the content if not sends a feedback. User must logged :param: request ''' # blog_with_user = Blog(owner=request.user) blog_with_user = Blog.objects.filter(owner=request.user) if len(blog_with_user) == 0: return HttpResponse('You have to create a blog first') else: post_with_blog = Post(blog=blog_with_user[0]) success_message = '' post_form = PostForm(request.POST, instance=post_with_blog) if post_form.is_valid(): new_post = post_form.save() post_form = PostForm() success_message = 'Post succesfully created' context = {'form': post_form, 'message': success_message} return render(request, 'blogs/post-create.html', context)