def create_post(request):
# for key, value in request.POST.items():
# if(key == 'user'):
# if(str(value) not in ['4','2','1']):
# raise PermissionDenied()
"""Create new post view."""
# if(request.POST['user'] != 0):
# raise Exception('general exceptions not caught by specific handling')
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,
'profiles': request.user.profiles
})
def post_create(request):
"""
Allow logged-in Author to create post.
"""
try:
author = request.user.author
form = PostForm(request.POST or None)
if request.method == 'POST':
form.instance.author = author
if form.is_valid():
form.save()
messages.success(request, f'{form.instance.title} Created')
return redirect(
reverse('post_details', kwargs={'id': form.instance.id})
)
context = {
'title': 'Create Post.',
'form': form,
}
return TemplateResponse(request, 'post-create.html', context)
# If logged-in User is not an Author.
except ObjectDoesNotExist:
messages.warning(request, 'Not authorized.')
return redirect('post_list')
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_edit(request, username, post_id):
if request.user.username != username:
return redirect('post', username=username, post_id=post_id)
the_post = get_object_or_404(Post, id=post_id, author__username=username)
# проверим, подписан ли пользователь на автора поста
count = Follow.objects.filter(user=request.user,
author__username=username).count()
follows = True if count > 0 else False
edit_form_post = PostForm(request.POST or None,
files=request.FILES or None,
instance=the_post)
if edit_form_post.is_valid():
edit_form_post.save()
return redirect('post', username=username, post_id=post_id)
return render(
request, 'new_post.html', {
'form': edit_form_post,
'post': the_post,
'following': follows,
'title': 'Редактировать заись',
'button': 'Внести изменения'
})
def posts_list(request):
if request.method == "POST":
form = PostForm(data=request.POST)
if form.is_valid():
form.save()
messages.add_message(
request,
messages.SUCCESS,
"Utworzono nowy post!!"
)
else:
messages.add_message(
request,
messages.ERROR,
form.errors['__all__']
)
elif request.method == "GET":
posts = Post.objects.all()
form = PostForm()
return render(
request=request,
template_name="posts/posts_list.html",
context={"posts": posts,
"form": form
}
)
def new_post(request):
form = PostForm(request.POST or None, request.FILES or None)
if form.is_valid():
form.instance.author = request.user
form.save()
return redirect('index')
return render(request, 'posts/new_post.html', {'form': form})
def create_post(request):
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 list_posts(request):
# contact = []
# for post in posts:
# contact.append("""
# <p>{name}</p>
# <p>{user} - {timestamp}</p>
# <figure><img src="{picture}"/></figure>
# """.format(**post))
# return HttpResponse('<br>'.join(contact))
def create_post(request):
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, 'posts/new.html', {
'form': form,
'user': request.user,
'profile': request.user.profile
})
#def list_posts(request):
# content = []
# for post in posts:
# content.append("""
# <p>{user}</p>
# <img src={picture}>
# <p>{name} {timestamp}</p>
# """.format(**post))
# return HttpResponse('<br>'.join(content))
def post_edit(request, username, post_id):
author = get_object_or_404(User, username=username)
post = get_object_or_404(Post, pk=post_id, author=author)
if request.user != author:
return redirect("post_view",
username=request.user.username,
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_view",
username=request.user.username,
post_id=post_id)
return render(
request,
"new_post.html",
{
"form": form,
"post": post
},
)
def new_post(request):
form = PostForm(request.POST or None)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
form.save()
return redirect('index')
return render(request, 'newpost.html', {'form': form})
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 index_view(request):
posts = Post.objects.all()
form = PostForm(request.POST or None)
if form.is_valid():
form.save()
form = PostForm()
messages.success(request, 'saving successfully.')
context = {'form': form, 'posts': posts}
return render(request, 'index.html', context)
def post(self, request, *args, **kwargs):
post = Post.objects.get(pk=kwargs['pk'])
path_img = post.img_post.path
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
os.remove(path_img)
form.save()
messages.success(request, 'Successfully Edited The Post')
return redirect('posts')
def update_post(request, slug):
if request.POST:
post = get_object_or_404(Post, slug=slug)
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('/posts/')
else:
return HttpResponse("Error occurred")
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_creation(request):
if request.method == 'POST':
form = PostForm(request.POST or None, request.FILES or None)
if form.is_valid():
form.save()
return render(request, "success.html")
else:
form = PostForm()
context = {"form": form}
return render(request, "posts/post_creation.html", context)
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 p_create(request):
if request.method == 'POST':
post_form = PostForm(request.POST)
if post_form.is_valid():
post_form.save()
return redirect('posts:list')
else:
post_form = PostForm()
return render(request, 'create.html', {'post_form' : post_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 p_update(request, post_id):
post = get_object_or_404(Post, pk=post_id)
if request.method == 'POST':
post_form = PostForm(request.POST, instance=post)
if post_form.is_valid():
post_form.save()
return redirect('posts:list')
else:
post_form = PostForm(instance=post)
return render(request, 'create.html', {'post_form' : post_form})
def post(self, request):
post = Post()
post.owner = request.user
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
return redirect('home_page')
print(form.errors)
return render(request, 'new_post.html', {'form': form})
def edit(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
else:
form = PostForm(instance=post)
return render(request, 'posts/edit.html', {'form': form})
def post_create(request):
title = 'Create'
form = PostForm(request.POST or None, request.FILES or None)
author = get_author(request.user)
if request.method == "POST":
if form.is_valid():
form.instance.author = author
form.save()
return redirect(
reverse('posts:post-detail', kwargs={'id': form.instance.id}))
context = {'title': title, 'form': form}
return render(request, "posts/post_create.html", context)
def post(self, request, id):
post = Post.objects.get(id=id)
post_form = PostForm(request.POST, instance=post)
if post_form.is_valid():
post_form.save(action="update")
context = {
'post': post
}
return render(request, 'list.html', context)
def edit(request, id):
postData = Post.objects.get(pk=id)
if request.user != postData.owner:
return render(request, 'unauthorized.html')
post = PostForm(request.POST or None, instance=postData)
if post.is_valid():
post.save()
return redirect("/groups/show/" + str(postData.group.id))
return render(request, "group-posts/edit.html", {
'form': post,
"data": postData
})
def create_post(request):
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,'posts/new.html',{
'form':form,
'user':request.user,
'profile':request.user.profile
})
def new_post(request):
"""
Renders form to create new post
"""
form = PostForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
form.save()
return redirect('post', post_id=post.pk)
return render(request, 'new_post.html', {"form": form})
def post(self, request):
context_dict = {}
post_form = PostForm(request.POST)
if post_form.is_valid():
post_form.save(action="create")
posts = Post.objects.all().order_by('created_at')
context_dict['posts'] = posts
post_form = PostForm()
context_dict['post_form'] = post_form
return render(request, 'posts.html', context_dict)
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 p_create(request):
# POST 방식으로 호출될때 =>form action method="post"인 방식
if request.method == 'POST':
post_form = PostForm(request.POST) # POST방식으로 전송된것을 싹다 사용해서 객체로 만들어라!
PostForm.Meta.fields.append('author' == User.id)
if post_form.is_valid(): # 제대로 된 값을 입력하였다면
post_form.save()
return redirect("posts:list") #다시 돌아간다!
# GET 방식으로 호출될때 => form action을 사용하지않는 거의 모든 방식
else:
post_form = PostForm() #PostForm의 인자가 ()처럼 비어있기 때문에 비어있는 형태로 출력된다.
return render(request, 'create.html', {'post_form': post_form})
def post_edit(request, username, post_id):
"""Страница редактирования поста."""
author = get_object_or_404(User, username=username)
post = get_object_or_404(author.author_posts, id=post_id)
if request.user == author:
form = PostForm(request.POST or None,
files=request.FILES or None,
instance=post)
if form.is_valid():
form.save()
return redirect('post_view', username=username, post_id=post_id)
return render(request, 'new_post.html', {'form': form, 'post': post})
else:
return redirect('post_view', username=username, post_id=post_id)
def create_post(request):
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/create.html',
context={
'form': form,
'user': request.user,
'profile': request.user.profile
})
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_edit(request, username, post_id):
edit_post = get_object_or_404(Post, author__username=username, id=post_id)
if request.user != edit_post.author:
return redirect('post_view', edit_post.author, post_id)
form = PostForm(request.POST or None,
files=request.FILES or None,
instance=edit_post)
if form.is_valid():
form.save()
return redirect('post_view', edit_post.author, post_id)
context = {
'form': form,
'post': edit_post,
'is_edit': True,
}
return render(request, '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 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 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 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 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 index(request):
if request.user.is_authenticated:
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
# save post to db
instance = form.save(commit=False)
instance.author = request.user
instance.save()
posts = Posts.objects.all().filter(
author=request.user).order_by('-date')
posts = formatLaTeX(posts)
return redirect('index')
"""
return render(request, 'index.html', {'form':form,
'posts':posts})"""
# SELECT * FROM Posts WHERE author=user
posts = Posts.objects.all().filter(
author=request.user).order_by('-date')
form = PostForm()
posts = formatLaTeX(posts)
return render(request, 'index.html', {'form': form, 'posts': posts})
else:
return render(request, 'index.html')
def create_post(request):
user_id = request.user.id
username1 = User.objects.get(id=user_id)
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
form.save()
return redirect('group_detail', pk=post.groupname.pk)
else:
print("form is not valid")
else:
form = PostForm(initial={'user': username1})
return render(request, 'posts/post_form.html', {'form': form})
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 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, id):
"""
Edit details of post
"""
post = get_object_or_404(Post, id=id)
# If request.user is not the owner of the post
# redirect to access denied page
if not post.author == request.user:
return redirect('access_denied')
form = PostForm(request.POST or None, instance = post)
if form.is_valid():
form.save()
messages.success(request, u'Post edited successfully')
return redirect('posts:my_posts')
return render(request, 'posts/edit.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 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 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 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 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 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_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_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(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_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()
# message success
messages.success(request, "Successfully Edited", extra_tags='some-extra-tag')
return HttpResponseRedirect(instance.get_absolute_url())
context = {
"title": instance.title,
"instance": instance,
"form": form,
}
return render(request, "post_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 editaRuta(request, ruta_id=None):
if ruta_id is not None:
ruta=get_object_or_404(Post, pk=ruta_id)
#seguretat
if ruta.administrador != request.user.perfil:
messages.add_message(request, messages.ERROR , "No pots modificar aquesta ruta!")
url_next= reverse('index', kwargs={})
return HttpResponseRedirect(url_next)
else:
ruta=Post()
if request.method == 'POST':
form=PostForm(request.POST, instance=ruta)
if form.is_valid():
# solucion correcta:
r = form.save(commit=False)
#agafa coordenades
frase = r.coordenades
distancia = calcularDistanciaMapa(frase);
# calcular tiempo
modo = r.categoria
tiempo = calcularDuradaMapa(modo, distancia)
#save
r.km= distancia
r.administrador=request.user.perfil
#r.apuntats= r.administrador
r.durada = tiempo
r.save()
messages.add_message(request, messages.SUCCESS, "Ruta creada correctament")
#messages.info(request, 'Ruta guardada. ')
url_next= reverse('index', kwargs={})
return HttpResponseRedirect(url_next)
else:
#messages.ad
messages.error(request, 'petada general')
else:
form=PostForm(instance=ruta)
return render(request, 'posts/novaRuta.html', {
'form':form,
})
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 create(request):
success_message = ''
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()
form = PostForm()
success_message = 'Guardado con Correctamente! '
success_message += '<a href="{0}">'.format(reverse('post_detail', args=[new_post.owner.username, new_post.pk]))
success_message += 'Ver Post creado'
success_message += '</a>'
context = {
'form': form,
'success_message': success_message
}
return render(request, 'posts/new_post.html', context)
def post_update(request, slug=None): #update data
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)
print form.cleaned_data.get("title")
instance.save()
messages.success(request, "<a href='#'>Post</a> Saved Successfully!", extra_tags = 'html_safe')
#message success pops out
return HttpResponseRedirect(instance.get_absolute_url())
context = {
"title":instance.title,
"instance":instance,
"form":form,
}
return render (request, "post_form.html", context)
