def new_post(request):
if request.method == 'POST':
post_form = PostForm(request.POST, request.FILES)
new_postt = post_form.save(commit=False)
new_postt.user = request.user
new_postt.save()
categories = request.POST.getlist("category")
for cat in categories:
new_postt.category.add(cat)
tagss = request.POST.getlist("tag")
for ta in tagss:
new_postt.category.add(ta)
my_tags = request.POST.get("my_tags")
my_tags = my_tags.strip()
my_tags = my_tags.split(",")
for ta_g in my_tags:
n_t = my_models.Tag.objects.create(name=ta_g)
n_t.save()
new_postt.tag.add(n_t)
return HttpResponseRedirect(('{}?post_id=' + str(new_postt.id)).format(
reverse('post', kwargs={})))
else:
post_form = PostForm()
return render(request, 'main/new_post.html', {
'parts': my_models.Part.objects.all(),
"post_form": post_form,
})
def new(request):
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=Post.default())
if form.is_valid():
post = form.save()
return redirect(view, post.id)
else:
form = PostForm()
context = RequestContext(request, {'form': form})
return render_to_response('new.html', context)
def add_post(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post_item = form.save(commit=False)
post_item.author = request.user
post_item.save()
return redirect('post_view', pk=post_item.pk)
else:
form = PostForm(instance=Post())
return render(request, 'post_edit.html', {'form': form, 'action': 'add'})
def post_new(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post.published_date = timezone.now()
post.save()
return redirect('post_detail', pk=post.pk)
else:
form = PostForm()
return render(request, 'main/post_edit.html', {'form': form})
def post_new(request):
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
post = form.save()
post.save()
messages.info(request, 'Your post is added successfully!')
return redirect('postlist')
else:
form = PostForm()
return render(request, 'main/create or edit post.html', {'form': form})
def post_update(request, pk):
post = get_object_or_404(Post, pk=pk)
if request.method == 'POST':
form = PostForm(request.POST, instance=post)
if form.is_valid():
post = form.save()
post.save()
messages.info(request, 'Your post is updated successfully!')
return redirect('postlist')
else:
form = PostForm(instance=post)
return render(request, 'main/create or edit post.html', {'form': form})
def post_create(request):
"""Route Create Post."""
errors = ''
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
form.save()
else:
errors = "Cannot save the post"
else:
form = PostForm()
context = {"form": form, "errors": errors}
return render(request, "main/post_create.html", context=context)
def postform(request):
if request.method == 'POST':
post = PostForm(request.POST, request.FILES)
if post.is_valid():
myPost = post.save(commit=False)
myPost.created_at = timezone.now()
myPost.save()
return redirect('/')
else: # blank form
post = PostForm()
context = {'form': post}
return render(request, 'postform.html', context)
def post_create(request):
"""Route Create Post."""
errors = ''
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect("posts_all")
else:
errors = "Не возможно сохранить пост."
else:
form = PostForm()
context = {"form": form, "errors": errors}
return render(request, "main/post_create.html", context=context)
def index(request):
latest_post_list = Post.objects.order_by('-created_at')
if request.method == 'POST':
form = PostForm(request.POST)
if form.is_valid():
form.save()
return redirect('/blog/')
else:
form = PostForm()
context = {
'latest_post_list': latest_post_list,
'form': form
}
return render(request, 'main/index.html', context)
def view(request, post_id):
post = get_object_or_404(Post, id=int(post_id), active=True, parent=None)
if request.method == 'POST':
form = PostForm(request.POST,
request.FILES,
instance=Post.default(parent=post))
if form.is_valid():
resp = form.save()
form = PostForm()
post.last_resp_at = resp.created_at
post.save()
else:
form = PostForm()
context = RequestContext(request, {'post': post, 'form': form})
return render_to_response('view.html', context)
def post_update(request, post_id):
"""Update Posts."""
err = ""
pst = get_object_or_404(Post, pk=post_id)
if request.method == "POST":
form = PostForm(instance=pst, data=request.POST)
if form.is_valid():
form.save()
return redirect("posts_all")
else:
err = "Не возможно обновить пост."
else:
form = PostForm(instance=pst)
context = {"form": form, "err": err}
return render(request, "main/post_update.html", context=context)
def index():
form = PostForm()
if form.validate_on_submit():
if form.picture.data == None:
flash("Select any image before submitting!", "danger")
return redirect("/")
imgname = save_picture(form.picture.data)
cols = request.form.get('cols')
scale = request.form.get('scale')
if scale == None:
scale = 0.43
else:
scale = float(scale)
if cols == None:
cols = 500
else:
cols = int(cols)
result = convert_img_to_ascii(imgname, cols, scale)
os.remove(imgname)
if result != None:
return render_template('index.html',form=form, result=result)
else:
return redirect("/")
return render_template('index.html',form=form)
def modify(request):
user_info = get_user_info(request)
form = PostForm()
post_id = request.GET.get('id')
modified = False
if request.POST.get('title'):
now = timezone.now()
title = request.POST.get('title')
post_id = request.POST.get('id')
category = request.POST.get('category')
context = request.POST.get('context')
user_id = request.user.id
Post.objects.filter(id=post_id).update(
title=title,
category=category,
context=context,
updated_at=now,
)
modified = True
post_info = Post.objects.filter(id=post_id).values().last()
side_popular_contents_list = get_side_popular_contents()
side_latest_contents_list = get_side_latest_contents()
return render(request, 'main/modify.html',
dict(form=form, side_popular_contents_list=side_popular_contents_list, side_latest_contents_list=side_latest_contents_list, user_info=user_info, post_info=post_info, modified=modified))
def write(request):
user_info = get_user_info(request)
form = PostForm()
created = False
if request.POST.get('title'):
now = timezone.now()
title = request.POST.get('title')
category = request.POST.get('category')
context = request.POST.get('context')
user_id = request.user.id
Post.objects.create(
title=title,
category=category,
context=context,
write_date=now,
user_id=user_id,
)
created = True
side_popular_contents_list = get_side_popular_contents()
side_latest_contents_list = get_side_latest_contents()
return render(request, 'main/write.html',
dict(form=form, side_popular_contents_list=side_popular_contents_list, side_latest_contents_list=side_latest_contents_list, user_info=user_info, created=created))
def index():
form = PostForm()
if current_user.can(Permission.WRITE_ARTICLES) and \
form.validate_on_submit():
post = Post(body=form.body.data,
author=current_user._get_current_object())
db.session.add(post)
return redirect(url_for('.index'))
page = request.args.get('page', 1, type=int)
show_followed = False
if current_user.is_authenticated:
show_followed = bool(request.cookies.get('show_followed', ''))
if show_followed:
query = current_user.followed_posts
else:
query = Post.query
pagination = query.order_by(Post.timestamp.desc()).paginate(
page,
per_page=current_app.config['FLASKY_POSTS_PER_PAGE'],
error_out=False)
posts = pagination.items
return render_template('index.html',
form=form,
posts=posts,
show_followed=show_followed,
pagination=pagination)
def search(request, pattern):
tags = TagsSet.from_string(pattern)
q, search = get_search(request)
regex = r'(\s|\A)\.{}(\W|\Z)'
for tag in tags:
q &= Q(content__iregex=regex.format(re.escape(tag)))
for tag in tags.iter_exclude():
q &= ~Q(content__iregex=regex.format(re.escape(tag)))
paginator = Paginator(
Post.objects.filter(q, active=True).order_by('-created_at'), 10)
page_id = request.GET.get('page')
try:
posts = paginator.page(page_id)
except PageNotAnInteger:
posts = paginator.page(1)
except EmptyPage:
posts = paginator.page(paginator.num_pages)
context = RequestContext(
request, {
'page': posts,
'form': PostForm(),
'title': '{} - {}'.format(_('tag'), pattern),
'search': search
})
return render_to_response('index.html', context)
def test_new_ad(client, user):
client.login(username=user.username, password="******")
resp_get = client.get("/ad/new")
assert resp_get.status_code == 200
data = {"title": "asdasd", "text": "sdefghhgj"}
assert PostForm(data=data).is_valid()
resp_post = client.post("/ad/new", data)
assert resp_post.status_code == 302
def add_post(request):
ImageFormSet = modelformset_factory(Image, form=ImageForm, max_num=1)
if request.method == 'POST':
post_form = PostForm(request.POST)
formset = ImageFormSet(request.POST,
request.FILES,
queryset=Image.objects.none())
if post_form.is_valid() and formset.is_valid():
post = post_form.save()
for form in formset.cleaned_data:
image = form['image']
Image.objects.create(image=image, post=post)
return redirect(post.get_absolute_url())
else:
post_form = PostForm()
formset = ImageFormSet(queryset=Image.objects.none())
return render(request, 'add-post.html', locals())
def edit(request, post_id):
post = get_object_or_404(Post, id=int(post_id), active=True)
if request.method == 'POST':
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
old = Post.objects.get(id=post.id)
old.id = None
old.active = False
old.save()
post = form.save(commit=False)
post.old_post = old
post.updated_at = timezone.now()
post.save()
return redirect(view, post.thread.id)
else:
form = PostForm(instance=post)
context = RequestContext(request, {'post': post, 'form': form})
return render_to_response('edit.html', context)
def add_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data, content=form.content.data)
post.slug_(str(form.title.data))
db.session.add(post)
db.session.commit()
return redirect(url_for('index'))
return render_template('add_post.html', form=form)
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title = form.title.data, content=form.content.data, author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
return redirect(url_for('home'))
return render_template('create_post.html', title='New post', form = form, legend= 'New Post')
def create_post(request, course_name_slug, forum_name_slug):
# find lecture object
try:
forum = Forum.objects.get(slug=forum_name_slug)
except Forum.DoesNoExist:
forum = None
try:
course = Course.objects.get(slug=course_name_slug)
except Course.DoesNotExist:
course = None
if course is None or forum is None:
return redirect('/main/forum/<slug:course_name_slug>/<slug:forum_name_slug/')
form = PostForm()
if request.method == 'POST':
print("after post")
form = PostForm(request.POST)
# If input is valid
if form.is_valid():
# Save the form
post = form.save(commit=False)
post.forum = forum
post.user = request.user
# save 1 creates id
post.save()
# save 2 uodates slug
post.save()
# return redirect('/main/course/<slug:course_name_slug>/<slug:lecture_name_slug>/')
return redirect(reverse('main:forum',
kwargs={'course_name_slug': course_name_slug,
'forum_name_slug': forum_name_slug}))
else:
print(form.errors)
# return render(request, 'main/course/<slug:course_name_slug>/<slug:lecture_name_slug>/', {'form': form})
return redirect(reverse('main:forum',
kwargs={'course_name_slug': course_name_slug,
'forum_name_slug': forum_name_slug}))
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data,
content=form.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
flash('Blog added to community', 'success')
return redirect(url_for('home'))
return render_template('new_post.html', form=form, titlt="NEW BLOG")
def new_post(request):
posted = False
if request.method == 'POST':
post_form = PostForm(request.POST)
if post_form.is_valid():
post = post_form.save(commit = False)
post.op = request.user
post.save()
posted=True
else:
print(post_form.errors)
else:
post_form = PostForm()
context_dict = {}
context_dict['post_form'] = post_form
context_dict['posted'] = posted
response = render(request, 'main/newpost.html', context_dict)
return response
def edit_post(request, pk):
post_item = get_object_or_404(Post, pk=pk)
if post_item.author != request.user:
raise ValidationError(
'You are not the owner of the post',
code='error.not.post.owner',
)
if request.method == 'POST':
post_form = PostForm(request.POST)
if post_form.is_valid():
new_post_item = post_form.save(commit=False)
post_item.title = new_post_item.title
post_item.text = new_post_item.text
post_item.save()
return redirect('post_view', pk=post_item.pk)
else:
post_form = PostForm(instance=post_item)
return render(request, 'post_edit.html', {
'form': post_form,
'action': 'edit'
})
def newpost():
form = PostForm()
if form.validate_on_submit():
post = Post(
title=form.title.data,
content=form.content.data,
author=current_user) #use author the backref to grab the user
db.session.add(post)
db.session.commit()
flash('Post submitted successfully', 'success')
return redirect(url_for('index'))
return render_template('newpost.html', title='New Post', form=form)
def delete_post(request, pk):
post_item = get_object_or_404(Post, pk=pk)
if post_item.author != request.user:
raise ValidationError(
'You are not the owner of the post',
code='error.not.post.owner',
)
if request.method == "POST":
post_item.delete()
return redirect('user_posts', pk=request.user.id)
return render(request, 'post_delete.html',
{'form': PostForm(instance=post_item)})
def add(request):
if request.method == "POST":
form = PostForm(request.POST)
if form.is_valid():
spk = form.save(commit=False)
now = datetime.datetime.now()
spk.time = now
spk.save()
form = PostForm()
return render(request, 'main/add.html', {
'form': form,
'ans': 'Добавлено!'
})
else:
return render(request, 'main/add.html', {
'form': form,
'ans': 'Форма не валидна'
})
else:
form = PostForm()
return render(request, 'main/add.html', {'form': form})
def page(request):
paginator = Paginator(
Post.objects.filter(active=True,
parent=None).order_by('-last_resp_at'), 10)
page_id = request.GET.get('page')
try:
posts = paginator.page(page_id)
except PageNotAnInteger:
posts = paginator.page(1)
except EmptyPage:
posts = paginator.page(paginator.num_pages)
context = RequestContext(request, {'page': posts, 'form': PostForm()})
return render_to_response('index.html', context)
