def post(self, request):
form = PostForm(request.POST, request.FILES, user=request.user)
self.translate(form)
message = ""
if form.is_valid():
form.instance.blog_id = form.data.get("blog_id")
if not form.instance.date_pub:
form.instance.date_pub = datetime.datetime.now()
there_Is_A_File = False
if form.instance.attachment:
there_Is_A_File = True
form.instance.attachment_type = form.instance.get_attachment_type(
)
if form.instance.attachment_type == Post.NONE:
form.instance.attachment = None
form.save()
if there_Is_A_File:
form.instance.resizeImage.delay(form.instance.id)
if there_Is_A_File and form.instance.attachment_type == Post.NONE:
message = _(
"Se ha creado correctamente el post sin media file. Ver tipos de fichero admitidos."
)
else:
message = _("Se ha creado correctamente el post")
form = PostForm(user=request.user)
context = {"form": form, "message": message}
return render(request, 'blogs/new_post.html', context)
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 editPost(request, postid):
post = Post.objects.get(pk=postid)
form = PostForm(instance=post)
if request.method == "POST":
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('showPost', postid)
context = {'form': form, 'form_title': 'Edit Post', 'btn': 'Edit Post'}
return render(request, 'blogs/new.html', context)
def createPost(request):
form = PostForm()
if request.method == 'POST':
form = PostForm(request.POST,request.FILES)
if form.is_valid():
form.save()
return redirect('home-url')
data = {
'form': form
}
return render(request, template_name='blogs/createPost.html', context=data)
def edit_blog(request, title_id):
blog = MyBlog.objects.get(id=title_id)
title = blog.title
if blog.owner != request.user:
raise Http404
if request.method != 'POST':
form = PostForm(instance=blog)
else:
form = MyBlogForm(instance=blog, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse("blogs:title", args=[blog.id]))
context = {'blog': blog, 'form': form, 'title': title}
return render(request, 'blog/edit_blog.html', context)
def post_edit(request, pk):
blog = get_object_or_404(Blog, user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"{blog.useful_domain()}/dashboard")
post = get_object_or_404(Post, blog=blog, pk=pk)
published_date_old = post.published_date
if request.method == "POST":
form = PostForm(request.user, request.POST, instance=post)
if form.is_valid():
post_new = form.save(commit=False)
post_new.blog = blog
# This prevents the resetting of time to 00:00 if same day edit
if (published_date_old and
post_new.published_date and
published_date_old.date() == post_new.published_date.date()):
post_new.published_date = published_date_old
if not post_new.published_date:
post_new.published_date = timezone.now()
post_new.save()
form.save_m2m()
else:
form = PostForm(request.user, instance=post)
return render(request, 'dashboard/post_edit.html', {
'form': form,
'blog': blog,
'post': post,
'root': blog.useful_domain(),
})
def write(request, blogID):
if request.method == 'POST':
form = PostForm(request.POST)
# check whether it's valid:
if form.is_valid():
blog = Blog.objects.get(num=blogID)
user = blog.writer
token = request.META.__getitem__('HTTP_X_TOKEN')
if default_token_generator.check_token(user, token):
x = form.save(commit=False)
x.writer = user
x.blog = blog
post_id = (Post.objects.filter(blog__num=blogID).count() + 1)
x.num = post_id
x.save()
return JsonResponse({'status': 0, 'post_id': post_id})
else:
return JsonResponse({'status': -1, 'message': 'you are not logged in'})
else:
return JsonResponse({'status': -1, 'message': list(form.errors.keys())[0] + ": " + form.errors[list(form.errors.keys())[0]][0]})
else:
if request.method == 'GET':
blog = Blog.objects.get(num=blogID)
post = Post.objects.get(blog=blog, num=request.GET.__getitem__(id))
if post is not None:
return JsonResponse({'status': 0, 'post':{'title': post.title, 'summary': post.summary, 'text': post.text}})
else:
return JsonResponse({'status': -1, 'message': 'the post doesnt exist!'})
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 post(self, request):
"""
Crea un post a partir de la información POST
"""
success_message = ''
post_with_owner = Post()
post_with_owner.owner = request.user # aquí asignamos al usuario como propietario del post
form = PostForm(request.POST, instance=post_with_owner)
if form.is_valid():
new_post = form.save()
form = PostForm() # reiniciamos el form
success_message = 'Post almacenado con éxito! '
success_message += '<a href="{0}">'.format(
reverse('post_detail', args=[request.user.username, 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 post_edit(request, pk):
blog = get_object_or_404(Blog, user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"http://{get_root(blog.subdomain)}/dashboard")
post = get_object_or_404(Post, blog=blog, pk=pk)
if request.method == "POST":
form = PostForm(request.user, request.POST, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.blog = blog
if not post.published_date:
post.published_date = timezone.now()
post.save()
form.save_m2m()
else:
form = PostForm(request.user, instance=post)
return render(
request, 'dashboard/post_edit.html', {
'form': form,
'blog': blog,
'post': post,
'root': get_root(blog.subdomain),
})
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 edit_post(request, post_id):
"""show the detail of post"""
post = BlogPost.objects.get(id=post_id)
check_object_owner(request, post)
if request.method != 'POST':
form = PostForm(instance=post)
else:
form = PostForm(instance=post, data=request.POST)
if form.is_valid():
form.save()
return redirect('blogs:post', post.id)
context = {
'form': form,
'post': post,
}
return render(request, 'blogs/edit_post.html', context)
def post_blog(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.save()
return redirect("index")
else:
form = PostForm()
return render(request, "post_new.html", {"form": form})
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 edit_post(request, post_id):
"""Edit an existing post."""
post = get_object_or_404(Post, id=post_id)
# Make sure the post belongs to the current user.
if post.owner != request.user:
return HttpResponseForbidden('<h1>403 Forbidden</h1>')
if request.method != 'POST':
# Initial request; pre-fill form with the current post.
form = PostForm(instance=post)
else:
# POST data submitted; process data.
form = PostForm(instance=post, data=request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('post', args=[post.id]))
context = {'post': post, 'form': form}
return render(request, 'blogs/edit_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 new(request, blog_id):
blog = get_object_or_404(Blog, id=blog_id)
post_form = PostForm(request.POST or None)
if post_form.is_valid():
post = post_form.save(commit=False)
post.author = request.user
post.save()
blog.posts.add(post)
return redirect_to_view("post", id=post.id)
return {"blog": blog, "post_form": post_form}
def newPost(request):
form = PostForm()
tag_form = TagForm()
if request.method == "POST":
form = PostForm(request.POST)
tag_form = TagForm(request.POST)
if form.is_valid() and tag_form.is_valid():
post = form.save(commit=False)
post.user = request.user
form.save()
tags = tag_form.cleaned_data['tag']
for i in tags.split(','):
tag = Tag.objects.get_or_create(tag=i)[0]
post.tags.add(tag)
return redirect('showPost', post.id)
context = {
'form': form,
'tag_form': tag_form,
'form_title': 'Create New Post',
'btn': 'Create Post'
}
return render(request, 'blogs/new.html', context)
def post(self, request):
post_form = PostForm(request.POST)
if post_form.is_valid():
post = post_form.save(commit=False)
post.created_by = request.user
post.save()
blog = Blog.objects.filter(user_owner=request.user).first()
path = request.build_absolute_uri('/').strip("/")
path += '/blogs/post/detail/{}/'.format(post.id)
# Uncomment the next line for sending mail after creation posts
# send_letter_to_user(blog, path)
return HttpResponse('OK! Created post with id:{}'.format(post.id))
else:
return HttpResponse('Error data is not valid!')
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST, request.FILES or None)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.published = timezone.now()
post.save()
return redirect('blogs:blog', blog_id=post.id)
else:
form = PostForm()
return render(request, 'add_blog.html', {
'user': request.user,
'form': form
})
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_post(request):
"""show the detail of post"""
if request.method != 'POST':
form = PostForm()
else:
form = PostForm(data=request.POST)
if form.is_valid():
new_post = form.save(commit=False)
new_post.owner = request.user
new_post.save()
return redirect('blogs:posts')
context = {
'form': form,
}
return render(request, 'blogs/add_post.html', context)
def post(self, request):
form = PostForm(request.user, request.POST)
if form.is_valid():
post = form.save()
message = "Post creado con éxito!"
form = PostForm(request.user)
else:
message = "Se ha producido un error"
context = {"form": form, "message": message}
return render(request, 'blogs/new_post.html', context)
def new_post(request):
"""Add a new post."""
if request.method != 'POST':
# No data submitted; create a blank form.
form = PostForm()
else:
# POST data submitted; process data.
form = PostForm(request.POST)
if form.is_valid():
new_post = form.save(commit=False)
new_post.owner = request.user
new_post.save()
return HttpResponseRedirect(reverse('post', args=[new_post.id]))
context = {'form': form}
return render(request, 'blogs/new_post.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):
form = PostForm(request.user,request.POST)
if form.is_valid():
post = form.save()
message = "Post creado con éxito!"
form = PostForm(request.user)
else:
message = "Se ha producido un error"
context = {
"form": form,
"message": message
}
return render(request, 'blogs/new_post.html', 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):
"""
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 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)
def post_new(request):
blog = get_object_or_404(Blog, user=request.user)
if not resolve_subdomain(request.META['HTTP_HOST'], blog):
return redirect(f"{blog.useful_domain()}/dashboard")
if request.method == "POST":
form = PostForm(request.user, request.POST)
if form.is_valid():
post = form.save(commit=False)
post.blog = blog
if not post.published_date:
post.published_date = timezone.now()
post.save()
form.save_m2m()
return redirect(f"/dashboard/posts/{post.id}/")
else:
form = PostForm(request.user)
return render(request, 'dashboard/post_edit.html', {
'form': form,
'blog': blog
})
def post(self, request):
"""
Recibe los datos del nuevo post los valida y los guarda
:param request: HttpRequest
:return: HttpResponse """
# crear el formulario con los datos del post
form = PostForm(request.POST)
if form.is_valid():
#crea el post
post = form.save()
#generar mensaje de exito
msg = "Post creado con éxito"
form = PostForm()
else:
msg = "Ha ocurrido un error al guardar el post" \
# renderiza la plantilla con el formulario
context = {"form": form, "msg": msg}
# renderiza y devuelve la plantilla
return render(request, 'blogs/new-post.html', context)
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)
