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 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 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 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 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 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 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 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 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 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 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 add_post():
form = PostForm(request.form)
if form.validate():
post = Post(bleach.clean(form.content.data), current_user.id, datetime.datetime.utcnow())
words = form.content.data.split()
for tag in Tag.parse_tags(words):
db_session.add(tag)
post.tags.append(tag)
db_session.add(post)
db_session.commit()
flash("Successful!")
else:
flash("Something went wrong. Make sure that your tweet's length is less than 140 characters", 'error')
return redirect(url_for('main.hello'))
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 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(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 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 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 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_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 test_valid_form(self):
form = PostForm(data={'title': 'Title', 'body': 'Hello world!'})
assert form.is_valid(
) is True, 'Should be valid if body message is not too short'
def setUpClass(cls):
super().setUpClass()
cls.form = PostForm()
def get(self, request):
form = PostForm()
return render(request, 'post_form.html', {'form': form})
def post(self, request):
form = PostForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return redirect('posts:feed')
def home(request):
utc = pytz.UTC
# TODO: If the user is not authenticated then don't show the home page,
# but instead show soe other page reporting the error. (Maybe just the login page).
streamlist = []
instance = None
if request.method == "POST":
data = request.POST.copy()
data['user'] = request.user.id
data['publish'] = datetime.now()
form = PostForm(data, request.FILES or None)
if form.is_valid():
instance = form.save()
form = PostForm()
print(form.errors)
user = request.user
privacy = request.GET.get('privacy', None)
if privacy is not None:
streamlist = Post.objects.filter(privacy=privacy)
print("GET", streamlist)
else:
streamlist = Post.objects.filter_user_visible_posts(
user=request.user)
"""
Allows you to search for the titles of post
"""
query = request.GET.get("query")
if query:
streamlist = streamlist.filter(content__icontains=query)
print("Stream list len: ", len(streamlist))
print("Stream list: ", streamlist)
#Cast QuerySet into a list for Github
streamlist = list(streamlist)
#TODO: increase rate limit with OAuth?
#if so, do pagination of API call
#make call to Github API
build_request = 'https://api.github.com/users/' + request.user.github + '/events'
r = requests.get(build_request)
response = r.json()
if r.status_code == 200:
for event in response:
#parse through output of API call and formulate into readable message
event_type = ''
#Parse event type into multiple words
#eg: PushEvent -> Push event
#https://stackoverflow.com/questions/2277352/split-a-string-at-uppercase-letters
#Credit: Mark Byers (https://stackoverflow.com/users/61974/mark-byers)
for word in re.findall('[A-Z][^A-Z]*', event['type']):
event_type += word + ' '
#Parse date into more readbale format
#https://stackoverflow.com/questions/18795713/parse-and-format-the-date-from-the-github-api-in-python
#Credit: IQAndreas (https://stackoverflow.com/users/617937/iqandreas)
date = datetime.strptime(event['created_at'],
"%Y-%m-%dT%H:%M:%SZ")
event_datetime = date.strftime('%A %b %d, %Y at %H:%M GMT')
#Parse url
event_repo = 'https://github.com/' + event['repo']['name']
message = "You had a " + event_type + 'on ' + event_datetime + ' for repo ' + event_repo
#Flag for determining if a github event is older than all posts
is_oldest = True
#sort based on datetime
for item in streamlist:
if isinstance(item, Post):
#Note that the time returned by the github api is timezone naive
#We must give it local timezone information in order to compare with timestamp
#of a post
#https://stackoverflow.com/questions/15307623/cant-compare-naive-and-aware-datetime-now-challenge-datetime-end
#Credit: Viren Rajput (https://stackoverflow.com/users/997562/viren-rajput)
if item.timestamp < utc.localize(date):
is_oldest = False
streamlist.insert(streamlist.index(item), message)
break
if is_oldest:
streamlist.append(message)
# context = {
# "object_list": streamlist,
# "user": user,
# "form": form,
# }
return HttpResponseRedirect('/home/')
else:
form = PostForm()
user = request.user
privacy = request.GET.get('privacy', None)
if privacy is not None:
streamlist = Post.objects.filter(privacy=privacy)
print("GET", streamlist)
else:
print(request.user)
streamlist = Post.objects.filter_user_visible_posts(
user=request.user)
"""
Allows you to search for the titles of post
"""
query = request.GET.get("query")
if query:
streamlist = streamlist.filter(content__icontains=query)
#print("Stream list len: ", len(streamlist))
#print("Stream list: ", streamlist)
#Cast QuerySet to list for Github
streamlist = list(streamlist)
#TODO: increase rate limit with OAuth?
#if so, do pagination of API call
#Validate user github?
#make call to Github API
build_request = 'https://api.github.com/users/' + request.user.github + '/events'
r = requests.get(build_request)
response = r.json()
if r.status_code == 200:
for event in response:
#parse through output of API call and formulate into readable message
event_type = ''
#Parse event type into multiple words
#eg: PushEvent -> Push event
#https://stackoverflow.com/questions/2277352/split-a-string-at-uppercase-letters
#Credit: Mark Byers (https://stackoverflow.com/users/61974/mark-byers)
for word in re.findall('[A-Z][^A-Z]*', event['type']):
event_type += word + ' '
#Parse date into more readbale format
#https://stackoverflow.com/questions/18795713/parse-and-format-the-date-from-the-github-api-in-python
#Credit: IQAndreas (https://stackoverflow.com/users/617937/iqandreas)
date = datetime.strptime(event['created_at'],
"%Y-%m-%dT%H:%M:%SZ")
event_datetime = date.strftime('%A %b %d, %Y at %H:%M GMT')
#Parse url
event_repo = 'https://github.com/' + event['repo']['name']
message = "You had a " + event_type + 'on ' + event_datetime + ' for repo ' + event_repo
#Flag for determining if a github event is older than all posts
is_oldest = True
#sort based on datetime
for item in streamlist:
if isinstance(item, Post):
#Note that the time returned by the github api is timezone naive
#We must give it local timezone information in order to compare with timestamp
#of a post
#https://stackoverflow.com/questions/15307623/cant-compare-naive-and-aware-datetime-now-challenge-datetime-end
#Credit: Viren Rajput (https://stackoverflow.com/users/997562/viren-rajput)
if item.timestamp < utc.localize(date):
is_oldest = False
streamlist.insert(streamlist.index(item), message)
break
if is_oldest:
streamlist.append(message)
nodeList = getNodeList()
context = {
"object_list": streamlist,
"user": user,
"form": form,
"nodeList": json.dumps(nodeList),
}
if instance and instance.unlisted is True:
context["unlisted_instance"] = instance
return render(request, "home.html", context)
def get(self, request):
form= PostForm()
return render(request,'addPost.html', context={'form':form})
def render_thread(request, board_name, thread_id):
"""
Render thread page with all thread's posts.
:param request: user's request
:param board_name: name of threads board
:param thread_id: thread id
:return: thread page
"""
board = get_board(board_name)
boards = get_boards_navlist()
board.url = board.uri
post = Post.objects.filter(board=board).get(id=thread_id)
post.posts = Post.objects.filter(board=board).filter(thread=post.id)
if request.method == 'POST':
if 'delete' in request.POST:
for key in request.POST.keys():
if key.startswith('delete_'):
post_id = key[7:]
post_to_delete = Post.objects.get(board=board, id=post_id)
if post_to_delete.password == request.POST['password']:
post_to_delete.delete()
return HttpResponseRedirect(
reverse('thread', args=[
board_name,
thread_id
]))
if 'report' in request.POST:
for key in request.POST.keys():
if key.startswith('delete_'):
post_id = key[7:]
post_to_report = Post.objects.get(board=board, id=post_id)
print(post_to_report)
report = Report(
ip=get_ip(request),
reason=request.POST['reason'],
post=post_to_report
)
report.save(force_insert=True)
return HttpResponseRedirect(
reverse('thread', args=[
board_name,
thread_id
]))
json_response = 'json_response' in request.POST
agreed_with_rules = 'rules' in request.POST
post_form = PostForm(request.POST, request.FILES)
if agreed_with_rules:
if post_form.is_valid():
_ip = get_ip(request)
new_post_id = post_form.process(board_name, _ip, thread_id)
if new_post_id:
if json_response:
respond = json.dumps({
'id': new_post_id,
'noko': False,
'redirect': '/' + board_name
})
answer = HttpResponse(
respond,
content_type="application/json"
)
else:
answer = HttpResponseRedirect(
reverse('thread', args=[
board_name,
thread_id
]) + '#{0}'.format(new_post_id)
)
return answer
else:
post_form = PostForm()
context = {
'config': config,
'board': board,
'boards': boards,
'threads': [post],
'hr': True,
'form': post_form,
'id': 1
}
return render(request, 'posts/page.html', context)
def get(self, request):
form = PostForm(user=request.user)
return render(request, 'posts/new_post.html', {'form': form})
def get(self, request, *args, **kwargs):
posts = Post.objects.get(pk=kwargs['pk'])
form = PostForm(instance=posts)
return render(request, 'common/edit.html', {'form': form})
def get(self, request):
context = {'form': PostForm()}
return render(request, 'create.html', context)
def get_context_data(self, **kwargs):
""" Returns a specific post page by pk. """
context = super().get_context_data(**kwargs)
context['post_form'] = PostForm()
return context
def test_forms(self):
post_text = 'TestText'
form_data = {'text': post_text}
form = PostForm(data=form_data)
self.assertTrue(form.is_valid())
def setUp(self):
super().setUp()
self.form = PostForm()
def get(self, request):
form = PostForm()
context = {'form': form}
return render(request, 'posts/new.html', context)
def test_form_too_short(self):
form = PostForm(data={'title': 'Title', 'body': 'Hello'})
assert form.is_valid(
) is False, 'Should be invalid if body message is too short'
assert 'body' in form.errors
def create(request):
form = PostForm(request.POST or None)
form_is_valid(form)
return {
'form': form,
}
def get(self, request):
post_form = PostForm()
image_form = ImageFormSet(queryset=PostImages.objects.none())
context = {'post_form': post_form, 'image_form': image_form}
return render(request, 'post/create.html', context)
def show(request, id):
group = Group.objects.get(id=id)
query = request.GET.get('q', '')
post = PostForm(request.POST or None)
if post.is_valid():
form_content = post.cleaned_data['content']
post_obj = Post.objects.create(content=form_content,
owner=request.user,
group=group)
post_obj.save()
return redirect("/groups/show/" + str(group.id))
if (query):
first_name_query1 = User.objects.filter(
userprofile__first_name__icontains=str(query)).filter(
userprofile__groups__in=[group])
first_name_query2 = User.objects.filter(
userprofile__first_name__in=[query]).filter(
userprofile__groups__in=[group])
last_name_query1 = User.objects.filter(
userprofile__last_name__icontains=str(query)).filter(
userprofile__groups__in=[group])
last_name_query2 = User.objects.filter(
userprofile__last_name__in=[query]).filter(
userprofile__groups__in=[group])
username_query1 = User.objects.filter(username__in=[query]).filter(
userprofile__groups__in=[group])
username_query2 = User.objects.filter(
username__icontains=str(query)).filter(
userprofile__groups__in=[group])
users = first_name_query1.union(first_name_query1, first_name_query2,
last_name_query1, last_name_query2,
username_query1, username_query2)
return render(request, "groups/searchResult.html", {
"usersResult": users,
"query": query,
"group": group,
"form": post
})
posts = Post.objects.filter(group=group).order_by('-created_at')
groups = Group.objects.all()
users_in_group = UserProfile.objects.filter(Q(groups=id))
request_sent = True
try:
GroupRequestJoin.objects.get(requestFrom=request.user,
requestTo=group.owner,
group=group)
except:
request_sent = False
invited = GroupInvite.objects.filter(inviteTo=request.user).filter(
group=group)
members = []
for user in users_in_group:
members.append(user.user)
notifyCounter = len(
Notification.objects.filter(reciever=request.user).filter(read=False))
return render(
request, "groups/show.html", {
"posts": posts,
"form": post,
"groups": groups,
"group": group,
"users_in_group": members,
"invited": invited,
"request_sent": request_sent,
"notifyCounter": notifyCounter
})
def get_context_data(self, **kwargs):
context = super(FormMixin, self).get_context_data(**kwargs)
context["form_post"] = PostForm()
return context
def get(self, request):
message = None
post_form = PostForm()
context = {'form': post_form, 'message': message}
return render(request, 'posts/create_post.html', context)
def get(self, request, *args, **kwargs):
form = PostForm()
return render(request, 'create_posts.html', {'form': form})
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)
else:
form = PostForm(auto_id=False)
params.update(form=form)
return render(request, 'posts/create_post.html', params)
@login_required
def posts_list_view(request):
params = dict()
posts = Post.objects.filter(user=request.user, is_enabled=True)
params.update(posts=posts)
return render(request, 'posts/posts_list.html', params)
@login_required
def post_detail_view(request, post_slug):
params = dict()
def get(self, request):
post_form = PostForm(request.user)
return render(request, 'new_post.html', {'form': post_form})
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['mediaformset'] = PostMediaFormSet()
context['post_form'] = PostForm()
return context
def setUpClass(cls):
super().setUpClass()
settings.MEDIA_ROOT = tempfile.mkdtemp(dir=settings.BASE_DIR)
cls.form = PostForm()
def wall(request, user_id):
profile = get_object_or_404(Profile, user=user_id)
if request.user.profile.has_access(profile.user):
posts = Post.objects.filter(author=user_id)[:10]
taboo = False
if request.user.profile.is_closed:
black = True
else:
black = False
else:
taboo = True
post = False
black = False
subscrib = Subscrib.objects.filter(who=user_id)
subscrib_onme = Subscrib.objects.filter(to=user_id)
form_com = CommentForm(prefix='comment')
if user_id == request.user.id:
form = PostForm()
form_st = StatusForm(prefix='status')
if profile.has_unread_notif():
notif = True
else:
notif = False
context = {
'post': posts,
'form': form,
'profile': profile,
'subscrib': subscrib,
'form_st': form_st,
'notif': notif,
'form_com': form_com,
'subscrib_onme': subscrib_onme,
'taboo': taboo
}
else:
if profile.is_follower(request.user):
fol = True
else:
fol = False
form_mes = MessageForm()
form_im = ImageMessageForm()
curr_subscrib = Subscrib.objects.filter(who=request.user,
to=profile.user)
if curr_subscrib.exists():
context = {
'post': posts,
'profile': profile,
'subscrib': subscrib,
'you_subscribed': True,
'form_com': form_com,
'subscrib_onme': subscrib_onme,
'form_mes': form_mes,
'form_im': form_im,
'taboo': taboo,
'fol': fol,
'black': black
}
else:
context = {
'post': posts,
'profile': profile,
'subscrib': subscrib,
'you_subscribed': False,
'form_com': form_com,
'subscrib_onme': subscrib_onme,
'form_mes': form_mes,
'form_im': form_im,
'taboo': taboo,
'fol': fol,
'black': black
}
return render(request, 'root/wall.html', context)
def get_context_data(self, **kwargs):
form_class = PostForm(self.request.POST or None,
instance=Post.objects.get(id=self.object.pk))
context = super().get_context_data(**kwargs)
context['form'] = form_class
return context
def test_empty_form(self):
form = PostForm(data={})
assert form.is_valid(
) is False, 'Should be invalid if no data is given'
def update(request, pk=None):
instance = get_object_or_404(Post, pk=pk)
form = PostForm(request.POST or None, instance=instance)
form_is_valid(form)
return {'form': form, 'instance': instance, 'form': form}
def index(request):
form = PostForm()
return render(request, 'index.html', {
'form': form
})
