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)
