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 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 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 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 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(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 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 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 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(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 create_view (request):
if request.method == 'POST':
form = PostForm (request.POST)
if (form.is_valid()):
save_form_data (form, Post())
return HttpResponseRedirect ('/posts')
else:
form = PostForm ()
return render (request, 'posts/edit.html',
{ 'form': form })
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, 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 edit_view (request, post_id):
post = Post.objects.get(id=post_id)
if request.method == 'POST':
form = PostForm (request.POST)
if (form.is_valid()):
save_form_data (form, post)
return HttpResponseRedirect ('/posts/%s' % post_id)
else:
form = PostForm ({'title': post.title,
'author': post.author.id,
'content': post.content})
return render (request, 'posts/edit.html',
{ 'form': form })
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 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 school(request, internalName):
user = request.user
posts = Post.objects.filter(school = School.objects.get(internalName = internalName))
if request.method == 'POST':
postForm = PostForm(request.POST)
if postForm.is_valid():
post = Post(title = postForm.cleaned_data['title'], user = user, school = user.get_profile().school, seekingFemale = postForm.cleaned_data['seekingFemale'], seekingMale = postForm.cleaned_data['seekingMale'], seekingTransgendered = postForm.cleaned_data['seekingTransgendered'], type = postForm.cleaned_data['hookupType'], allowOtherSchools = postForm.cleaned_data['allowOtherSchools'], text = postForm.cleaned_data['text'])
post.save()
return HttpResponseRedirect('')
else:
return render_to_response('schools/school.html', {'posts': posts, 'postForm': postForm, 'user': user, 'loginform': AuthenticationForm, 'logoSize': 50}, context_instance = RequestContext(request))
else:
return render_to_response('schools/school.html', {'posts': posts, 'postForm': PostForm(), 'user': user, 'loginform': AuthenticationForm, 'logoSize': 50}, 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 create(request):
if request.POST:
form = PostForm(request.POST)
if form.is_valid():
print(form.cleaned_data)
new_user = form.new_user(request.user)
new_user.save()
for cat in form.cleaned_data.get("categories"):
new_user.categories.add(PostsCategories.objects.get(title=cat))
new_user.save()
return redirect("posts:all")
else:
form = PostForm()
return render(request, "posts/create.html", {"form": form, "button_name": "Створити"})
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_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 create_post_view(request):
params = dict(current_page='create_post')
if request.method == 'POST':
form = PostForm(request.POST, auto_id=False)
if form.is_valid():
slug = form.cleaned_data['slug']
text = form.cleaned_data['text']
post = Post(slug=slug, text=text)
try:
post.user = request.user
post.save()
return redirect('post_detail_view', post.slug)
except Exception, e:
messages.error(request, "create post errors: %s" % e)
else:
messages.error(request, "form errors: %s" % form.errors)
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 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(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 post_publish(request):
if(request.method == 'POST'):
form = PostForm(request.POST)
if(form.is_valid()):
ctx = BlogInfoContext(request, {
'form': form
})
post = Post()
post.content = form['content'].value()
post.title = form['title'].value()
post.published = datetime.datetime.now()
post.save()
return HttpResponseRedirect("/")
else:
form = PostForm()
return render_to_response('post_create.html',{
'form': form
})
def get_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
# process data in form.cleaned_data
name = form.cleaned_data['name']
link = form.cleaned_data['link']
p = Post(name=name, link=link, publisher_id=request.user.id)
p.save();
#redirect
return HttpResponseRedirect('/posts')
else:
form = PostForm()
return render(request, 'posts/post.html', {'form': form})
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_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(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 p_create(request):
if request.method == 'POST':
# POST 방식으로 호출 될 때
post_form = PostForm(request.POST)
if post_form.is_valid():
user_id = request.session.get('user')
user = User.objects.get(username=user_id)
new_post = Post(author=user,
title=post_form.cleaned_data['title'],
contents=post_form.cleaned_data['contents'])
new_post.save()
return redirect('posts:list')
else:
# GET 방식으로 호출 될 때
post_form = PostForm()
return render(request, 'create.html', {'post_form': post_form})
def post_edit(request, username, post_id):
edit_post = get_object_or_404(Post, pk=post_id)
if edit_post.author == request.user:
if request.method == "POST":
form = PostForm(request.POST,
files=request.FILES or None,
instance=edit_post)
if form.is_valid():
form.save()
return redirect("post", username, post_id)
form = PostForm(instance=edit_post)
return render(
request, "new_post.html", {
"form": form,
"username": username,
"post_id": post_id,
"edit_post": edit_post
})
return redirect("post", username, post_id)
def post(self, request):
# Nos definimos previamente un formulario con el valor del usuario que hemos excluido de la página.
new_post_in = Post(owner=request.user)
# Coge los datos del formulario y de los ficheros
form = PostForm(request.POST, request.FILES, instance=new_post_in)
if form.is_valid():
new_blog_in = form.save()
messages.success(request, 'El post: {0} ha sido creado con éxito.'.format(new_post_in.title))
# Se limpia el formulario para una nueva inserción
form = PostForm()
else:
storage = generate_new_html_errors(form.errors)
for msg in storage:
messages.error(request, storage.get(msg))
return render(request, 'posts/new_post.html', {'form': form})
def create_post(request):
""" Create new post view """
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/new.html',
context={
'form': form,
'user': request.user,
'profile': request.user.profile
})
def post_create(request):
form = PostForm(request.POST or None,request.FILES or None)
if form.is_valid():
instance=form.save(commit=False)
instance.save()
messages.success(request,"Successfully Posted")
return HttpResponseRedirect(instance.get_absolute_url())
context={
"form":form,
"title":"create view",
}
return render(request,"postform.html",context)
def ajax_publication_date(request, post_id):
if request.is_ajax():
post = get_object_or_404(Post, id=post_id)
form = PostForm(request.POST, instance=post)
if form.is_valid():
form.save()
data = {
'message' : 'The publication date has been saved.'
}
else:
publication_date_errors = form.errors.get('publication_date')
if publication_date_errors == None:
data = {
'message' : 'The publication date has not been saved.'
}
else:
data = {
'message' : form.errors['publication_date'][0]
}
return JsonResponse(data)
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()
messages.success(request,
"<a href='#'>Successfully</a> Saved",
extra_tags="html_safe")
return HttpResponseRedirect(instance.get_absolute_url())
context = {
"title": instance.title,
"instance": instance,
"form": form,
}
return render(request, "post_form.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()
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 post(self, request):
"""
Procesa el formulario para crear un usuario
:param request: objeto HttpRequest
:return: HttpResponse con la respuesta
"""
post = Post()
post.owner = request.user
form = PostForm(request.POST, instance=post)
if form.is_valid():
# creamos el post
post = form.save()
# limpiar el formulario
form = PostForm()
# Devolvemos un mensaje de OK
messages.success(request, 'Post creado correctamente')
context = {'form': form}
return render(request, 'posts/form.html', context)
def new_post(request):
profile = request.user.profile
if request.method == 'POST':
form = PostForm(profile, request.POST, request.FILES)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.content = request.POST.get('content')
if request.POST.get('action') == "save":
post.save()
post.tag_save()
return redirect('edit_post', pk=post.pk, slug=post.slug)
elif request.POST.get('action') == "submit":
post.published = True
post.save()
post.tag_save()
return redirect('detail', pk=post.pk, slug=post.slug)
else:
form = PostForm(profile)
return render(request, 'new_post.html', {'form': form, })
def create_post(request):
"""Create new post view."""
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 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.content = instance.content.replace(u"\u2018", "'").replace(
u"\u2019", "'").strip()
instance.user = request.user
if not instance.publish:
instance.publish = timezone.now().date()
instance.save()
messages.success(request, 'Post successfully created!')
return HttpResponseRedirect(instance.get_absolute_url())
context = {'title': 'Create Post', 'form': form}
return render(request, 'post_form.html', context)
def post_update(request, slug=None):
if not request.user.is_staff or not request.user.is_superuser:
raise Http404
post = get_object_or_404(Post, slug=slug)
form = PostForm(request.POST or None, request.FILES or None, instance=post)
if form.is_valid():
post = form.save(commit=False)
post.save()
# message success
messages.success(request,
'Post was successfully edited',
extra_tags="some-tags")
# link = '/post/'+post.id
return redirect('posts:detail', post.slug)
context = {
"title": post.title,
"post": post,
"form": form,
}
return render(request, 'posts/post_form.html', context)
def write_post(request, p_idx):
park_post = get_object_or_404(Park_number, p_idx=p_idx)
if request.method == 'POST':
if request.FILES:
post = Post(p_idx=park_post,
author=request.user,
images=request.FILES['images'])
else:
post = Post(p_idx=park_post, author=request.user, images=None)
post_form = PostForm(request.POST, instance=post)
if post_form.is_valid():
post_form.save()
path = '/posts/{}/detail'.format(p_idx)
return redirect(path)
# post_form = Post(p_idx=p_idx, author=request.user, starpoint=request.POST['starpoint'], contents=request.POST['contents'], images=request.FILES['images'])
# post_form.save()
# return redirect('posts:detail')
else:
post_form = PostForm()
return render(request, 'write.html', {'post_form': post_form})
def edit_post(request, post_id):
"""
Renders form to edit post with specified post_id.
Only author of the post can edit the form otherwise user will be redirected to post page
"""
post = get_object_or_404(Post, pk=post_id)
if request.user != post.author:
return redirect('index')
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', post_id=post.pk)
return render(request, 'new_post.html', {"form": form, "post": post})
def post_create(request):
form = PostForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
#print (form.cleaned_data.get("title"))
instance.save()
#message success
messages.success(request, "Successfully Created")
return HttpResponseRedirect(instance.get_absolute_url())
#else:
#messages.success(request," Not Successfully Created")
#if request.method=="POST":
# print request.POST.get("content")
# print request.POST.get("title")
# Post.objects.create(title=title)
context = {
"form": form,
}
return render(request, "post_form.html", context)
def post_edit(request, username, post_id):
author = get_object_or_404(User, username=username)
post = get_object_or_404(Post, author=author, id=post_id)
user = request.user
if user != author:
return redirect("post", username=post.author, 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", username=post.author, post_id=post.id)
return render(request, "new_post.html", {
"form": form,
"edit": True,
"post": post,
"author": author
})
def update(request, pk):
if request.method == "POST":
post = get_object_or_404(Post, pk=pk)
form = PostForm(request.POST)
if form.is_valid():
data = form.cleaned_data
post.title = data['title']
post.content = data['content']
post.language = data['language']
post.category = data['category']
post.save()
print(repr(post))
return redirect("posts:detail", pk=pk)
elif request.method == "GET":
post = get_object_or_404(Post, pk=pk)
context = {
"post" : post
}
return render(request, 'editpost.html', context=context)
def post(self, request):
current_page = 'home'
form = PostForm(request.POST, request.FILES or None, auto_id=False)
if form.is_valid():
post = form.save(commit=False)
post.user = request.user
post.save()
messages.success(request, "Post successfully created!")
text = form.cleaned_data['post']
else:
messages.error(request, "Post not created!")
form = PostForm()
return redirect('home:home')
args = {
'form': form,
'text': text,
'current_page': current_page,
}
return render(request, self.template_name, args)
def post_update(request, slug=None):
if not request.user.is_authenticated: #request.user.is_staff or not request.user.is_superuser:
raise Http404("please login first, to update your post")
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.category = form.cleaned_data.get("category")
instance.save()
# Without this next line the tags won't be saved.
form.save_m2m()
messages.success(request, "Post Updated", extra_tags='html_safe')
return HttpResponseRedirect(instance.get_absolute_url_jb_app())
context = {
"title": instance.title,
"instance": instance,
"form": form,
}
return render(request, "jb_app_posts/posts_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 account_detail(request, slug=None):
user = get_object_or_404(User, username=slug)
query_list_posts = Post.objects.filter(to_user=user).filter(wait=False)
paginator = Paginator(query_list_posts, 2)
page = request.GET.get('page')
try:
contacts = paginator.page(page)
except PageNotAnInteger or EmptyPage:
contacts = paginator.page(1)
form_post = PostForm(request.POST or None)
form_comment = CommentForm(request.POST or None)
if request.method == 'POST' and 'btnform2' in request.POST:
if form_comment.is_valid() and request.user.is_authenticated():
comment_parent_id = request.POST.get("comment_parent")
# comment_parent = get_object_or_404(Post, id=int(comment_parent_id))
comment = form_comment.save(commit=False)
comment.from_user = request.user
comment.to_user = user
comment.parent = int(comment_parent_id)
comment.save()
return redirect(reverse("accounts:detail", kwargs={"slug": slug}))
elif request.method == 'POST' and 'btnform1' in request.POST:
if form_post.is_valid() and request.user.is_authenticated():
post = form_post.save(commit=False)
post.from_user = request.user
post.to_user = user
post.save()
return redirect(reverse("accounts:detail", kwargs={"slug": slug}))
# comments = Comment.objects.filter(to_user=user)
context = {
"user": user,
"posts": query_list_posts,
'form_post': form_post,
'form_comment': form_comment,
"contacts": contacts,
}
return render(request, "account.html", context)
def post_create(request):
if not request.user.is_staff or not request.user.is_superuser:
raise Http404
# if not request.user.is_authenticated():
# 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())
else:
messages.error(request, "Not Created!")
context = {
"form": form,
}
return render(request, "post_form.html", context)
def post_update(request, slug=None):
if not request.user.is_authenticated():
messages.error(request, "You need to login first")
# return redirect(reverse('posts:login'))
return redirect(reverse('posts:homepage'))
post = get_object_or_404(Post, slug=slug)
if post.user.username == request.user.username:
form = PostForm(request.POST or None,
request.FILES or None,
instance=post)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
messages.success(request, "Updated: %s" % (str(instance.updated)))
messages.success(request, "Notice Successfully updated")
return HttpResponseRedirect(instance.get_absolute_url())
context = {"post": post, "form": form}
return render(request, "post_form.html", context)
else:
messages.error(request, "You cannot edit this post!")
return redirect(post.get_absolute_url())
def post(self, request, *args, **kwargs):
form = PostForm(request.POST)
if form.is_valid():
title = request.POST.get('title')
description = request.POST.get('description')
if 'photo' in request.FILES:
photo = request.FILES.get('photo')
id = request.POST.get('id')
user = User.objects.get(id=id)
if 'photo' in request.FILES:
blogpost = Post(title=title,
description=description,
photo=photo,
post_user=user)
else:
blogpost = Post(title=title,
description=description,
post_user=user)
blogpost.save()
messages.success(request,
'You have successfully made a new post...')
return redirect('dashboard')
def view_user_profile(request, username):
user = User.objects.get(username = username)
post_list = UserPost.objects.filter(user_id = user.id).order_by('-date')
if request.method == 'POST':
post_form = PostForm(request.POST,
request.FILES,
)
if post_form.is_valid():
instance = post_form.save(commit = False)
instance.user = request.user
instance.save()
messages.success(request, f'New post created!')
return redirect('user-profile', username = user)
else:
post_form = PostForm()
context = {'user':user, 'post_list': post_list, 'post_form':post_form}
return render(request, 'users/user_profile.html', context)
def post_edit(request, username, post_id):
post = Post.objects.get(pk=post_id)
if post.author != request.user:
return redirect('post', username, post_id)
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
post.author = request.user
form.save()
return redirect(
reverse('post',
kwargs={
'username': username,
'post_id': post_id
}))
else:
form = PostForm(instance=post)
form = PostForm(instance=post)
return render(request, 'newpost.html', {
'form': form,
'post': post,
'is_edit': True
})
def post(self, request):
# Define new instance
post = Post()
# Add user logged
post.owner = request.user
# Create form
form = PostForm(request.POST, request.FILES, instance=post)
# Validate form
if form.is_valid():
# Create add
post = form.save()
# Clear form
form = PostForm()
# Redirect
return redirect('blogs')
context = {'form': form}
return render(request, 'posts/new_post.html', context)
def post_update(request, id=None):
instance = get_object_or_404(Post, id=id)
form = PostForm(request.POST or None,
request.FILES or None,
instance=instance)
print(request.user, instance.user)
if not (request.user == instance.user):
return redirect("posts:list")
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, "Something went wronge")
context = {
"instance": instance,
"form": form,
}
return render(request, "post_form.html", context)
def user_account(request):
username = request.user
user = User.objects.get(username = username)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
if form.is_valid():
new_post = form.save(commit=False)
new_post.author = request.user
new_post.post_time = timezone.now()
new_post.save()
return HttpResponseRedirect(request.path)
else:
form = PostForm()
user_posts = Post.objects.filter(author = user).order_by("-post_time")
page = request.GET.get('page', 1)
paginator = Paginator(user_posts, 10)
try:
post_list = paginator.page(page)
except PageNotAnInteger:
post_list = paginator.page(1)
except EmptyPage:
post_list = paginator.page(paginator.num_pages)
context = {'user': user, 'form':form, 'user_posts': post_list}
return render(request, 'account/account.html', context)
