def new_post():
# Craeting an instance of PostForm
form=PostForm()
#Check for a GET or POST request
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()
#If successful display the message and redirect to the home page
flash('Your post has been created!','success')
return redirect(url_for('main'))
return render_template('create_post.html',form=form)
def seed():
content = """
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
"""
for i in range(25):
post = Post(title="Test Post #{}".format(i), content=content)
session.add(post)
session.commit()
def addpsot():
if request.method == "POST":
title = request.form.get('title')
body = request.form.get('content')
photo = save_images(request.files.get('photo'))
post = Post(title=title, body=body, image=photo, author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post has been submited', 'success')
return redirect('dashboard')
return render_template('admin/addpost.html')
def handle(self, *args, **kwargs):
try:
for ir in range(10):
i = ir + 1
post = Post(title=f'Post {i}', text=f'text for post {i}')
post.save()
for jr in range(ir):
j = jr + 1
comment = Comment(text=f'comment {j} for post {i}', post=post)
comment.save()
except:
raise CommandError('Initalization failed.')
def setUp(self):
self.now = datetime.datetime.utcnow().replace(tzinfo=utc)
self.timedelta = datetime.timedelta(15)
author = User.objects.get(pk=1)
for count in range(1, 11):
post = Post(title="Post %d Title" % count,
text="foo",
author=author)
if count < 6:
pubdate = self.now - self.timedelta * count
post.published_date = pubdate
post.save()
def api_post_create_view(request):
post = Post(
author=request.user
) # Take the user from the request as user is already authenticated using Token Authentication
if request.method == 'POST':
serializer = PostSerializer(post, data=request.data)
data = dict()
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def share(request, photo):
name = makeName(request)
photo.save("djangoTest/media/media_photo/" + name)
if not Post.objects.filter(key=request.session.session_key).exists():
pst = Post(key=request.session.session_key)
pst.save()
else:
pst = Post.objects.get(key=request.session.session_key)
mdl = Picture(post=pst, photo='/media_photo/' + name)
mdl.save()
def create_post():
form = BlogPostForm()
if form.validate_on_submit():
blog_post = Post(title=form.title.data,
text=form.text.data,
user_id=current_user.id)
db.session.add(blog_post)
db.session.commit()
flash('Blog Post Created')
return redirect(url_for('core.index'))
return render_template('create_post.html', form=form)
def setUp(self):
# Add parent category and post category
parent = Category(name='Writing', parent=None)
parent.save()
category = Category(name='Thoughts', parent=parent)
category.save()
# Create a draft
_post = Post(title='Random thoughts of the author',
body='Thoughts turned to words.',
category=category)
_post.save()
self.draft = _post
# Publish a post
post = Post(title='New thoughts from without',
body='A post fit to be published!',
category=category)
post.save()
post.publish()
self.post = post
self.client = test.Client()
def test_is_count_one(self):
category = Category(name="テストカテゴリー")
category.save()
tag = Tag(name="テストタグ")
tag.save()
post = Post(category=category,
title="test_title",
body="test_body",
published=1)
post.save()
saved_posts = Post.objects.all()
self.assertEqual(saved_posts.count(), 1)
def new_post():
form = PostForm()
if form.validate_on_submit():
title = form.title.data
body = form.body.data
category = Category.query.get(form.category.data)
post = Post(title=title, body=body, category=category)
db.session.add(post)
db.session.commit()
flash('Post created.', 'success')
return redirect(url_for('show_post', post_id=post.id))
return render_template('new_post.html', form=form)
def setUp(self):
post1 = Post(title='Post 1',
content='Postagem de teste 1.',
post_slug='post-1')
post2 = Post(title='Post 2',
content='Postagem de teste 1.',
post_slug='post-2')
post3 = Post(title='Post 3',
content='Postagem de teste 1.',
post_slug='post-3')
post4 = Post(title='Post 4',
content='Postagem de teste 1.',
post_slug='post-4')
post5 = Post(title='Post 5',
content='Postagem de teste 1.',
post_slug='post-5')
post6 = Post(title='Post 6',
content='Postagem de teste 1.',
post_slug='post-6')
post1.save()
post2.save()
post3.save()
post4.save()
post5.save()
post6.save()
def setUp(self):
self.user1 = get_user_model().objects.create(
username='******',
email='*****@*****.**',
first_name='Billy',
last_name='Dodson'
)
self.user1.set_password('test1pass')
self.user2 = get_user_model().objects.create(
username='******',
email='*****@*****.**',
first_name='Jilian',
last_name='Sommers'
)
self.user2.set_password('test2pass')
Post.objects.bulk_create(
[
Post(author=self.user1, title='Some title 1', text='some text 1'),
Post(author=self.user2, title='Some title 2', text='some text 2'),
Post(author=self.user2, title='Some title 3', text='some text 3'),
Post(author=self.user1, title='Some title 4', text='some text 4'),
Post(author=self.user1, title='Some title 5', text='some text 5'),
Post(author=self.user2, title='Some title 6', text='some text 6'),
]
)
self.client = Client()
def new_post():
form = PostForm()
form.trip.choices = [
(g.id, g.destination)
for g in Travel.query.order_by(Travel.date_posted.desc())
]
form.trip.choices.insert(0, (0, ''))
if form.validate_on_submit():
if form.trip.data == '':
post = Post(title=form.title.data,
content=form.content.data,
author=current_user)
elif form.trip.data == '' and form.picture.data:
picture_file = save_picture(form.picture.data)
post = Post(title=form.title.data,
content=form.content.data,
author=current_user,
image_file=picture_file)
elif form.picture.data:
trip = Travel.query.get(form.trip.data)
picture_file = save_picture(form.picture.data)
post = Post(title=form.title.data,
content=form.content.data,
author=current_user,
trip=trip,
image_file=picture_file)
else:
trip = Travel.query.get(form.trip.data)
post = Post(title=form.title.data,
content=form.content.data,
author=current_user,
trip=trip)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
return redirect(url_for('main.home'))
return render_template('create_post.html',
title='New Post',
form=form,
legend='New Post')
def create():
if request.method == 'POST':
title = request.form['title']
author = session.user.name
date = request.form['real-date']
section = request.form['section']
preview = request.form['create-preview']
body = request.form['create-body']
file = request.files['file']
error = None
if not title:
error = 'Please include a title.'
elif not date:
error = 'Please include the date.'
elif not preview:
error = 'Please include a preview.'
elif not body:
error = 'Please include a body.'
elif 'file' not in request.files:
error = 'No file part'
elif file.filename == '':
error = 'No selected file'
elif not allowed_file(file.filename):
flash('Filetype not accepted')
return redirect(request.url)
if error is None:
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
print(filename, file=sys.stderr)
if session.user.user_auth == "peasant":
post_auth = "pending"
flash("Submission awaiting approval")
elif session.user.user_auth == "dev":
post_auth = "approved"
flash("Submission Posted")
post = Post(author_id=session.user.id,
author=author,
real_date=date,
title=title,
preview=preview,
body=body,
section=section,
post_auth=post_auth,
preview_photo=filename)
db.session.add(post)
db.session.commit()
return redirect(url_for('page-dir.show', category=section))
return render_template('create.html')
def post():
form = PostForm()
tags_field = request.values.get('tags_field', '')
if form.validate_on_submit():
image_id = None
if form.image.data:
f = form.image.data
image_id = str(uuid.uuid4())
file_name = image_id + '.png'
file_path = os.path.join(BLOG_POST_IMAGES_PATH, file_name)
Image.open(f).save(file_path)
_image_resize(BLOG_POST_IMAGES_PATH, image_id, 600, 'lg')
_image_resize(BLOG_POST_IMAGES_PATH, image_id, 300, 'sm')
if form.new_category.data:
new_category = Category(form.new_category.data)
db.session.add(new_category)
db.session.flush()
category = new_category
else:
category = form.category.data
author = Author.query.get(session['id'])
title = form.title.data.strip()
body = form.body.data.strip()
post = Post(
author=author,
title=title,
body=body,
image=image_id,
category=category,
)
_save_tags(post, tags_field)
db.session.add(post)
db.session.commit()
slug = slugify(str(post.id) + '-' + post.title)
post.slug = slug
db.session.commit()
flash('Article posted')
return redirect(url_for('.article', slug=slug))
return render_template('blog/post.html',
form=form,
action="new",
tags_field=tags_field)
def code_create(request):
if request.method == 'POST':
code = Code()
post = Post()
try:
path = "upload/"
file = request.FILES['file']
if not os.path.exists(path):
os.makedirs(path)
list = GetFileList(path,file.name)
version ='1'
if len(list)>0:
version = str(len(list)+1)
file_name = path +request.session['username']+'-'+request.POST['category']+'-'+version+'-'+file.name
else:
file_name = path +request.session['username']+'-'+request.POST['category']+'-1-'+file.name
destination = open(file_name, 'wb+')
for chunk in file.chunks():
destination.write(chunk)
destination.close()
with open(file_name, 'r') as filer:
code.wenku = filer.read()
code.title = request.POST['title']
code.version = version
code.intro = request.POST['body']
code.status = '0'
code.path = path+file.name
code.size = str(file.size/1000).split('.')[0]+'K'
tlist = file.name.split('.')
code.type = tlist[len(tlist)-1]
code.author = User.objects.get_by_natural_key(request.session['username'])
code.category_id = request.POST['category']
code.save()
with open(file_name, 'r') as filer:
post.body = filer.read()
post.title = request.POST['title']
post.author = User.objects.get_by_natural_key(request.session['username'])
post.category_id = request.POST['category']
post.save()
request.session['codeid'] = code.id
return HttpResponseRedirect(reverse('codemg:code_post_list'))
except Exception as e:
print(e)
return HttpResponse(json.dumps({
"status": "fail",
}), content_type="application/json")
return render(request, "codemg/create.html", {
'username':request.session['username']
})
def new_post():
"""
Create a new post.
If :GET: present the form to submit a new post.
If :POST:, if valid, submit the post and redirect to home.
"""
form = PostBlogForm()
if form.validate_on_submit():
log.info("User %s submitted post %s", current_user, form.title.data)
log.debug("CodeType: %s", form.code_type.data)
if form.code_type.data is None:
code = False
else:
code = True
post = Post(
title=form.title.data,
slug=form.slug.data,
content=form.text.data,
user=current_user,
code=code,
code_type=form.code_type.data,
)
db.session.add(post)
try:
db.session.commit()
except IntegrityError as exc:
if exc.message.endswith("not unique"):
log.error("Post '%s' was not unique in field '%s'",
form.title.data,
exc.message.split(" ", 2)[-1].rsplit(" ", 3)[0])
else:
log.critical("Unknown Integrity Error with post '%s'",
form.title.data,
exc_info=True)
db.session.rollback()
flash("Integrity Error!", 'danger')
return render_template("post/make_post.html",
title="Post Blog",
form=form)
except:
log.critical("Exception on %s [%s]",
'page',
'method',
exc_info=True)
db.session.rollback()
abort(500)
flash(
"{} submitted {}.".format(current_user.username, form.title.data),
'success')
return redirect(url_for('index'))
return render_template("post/make_post.html", title="Post Blog", form=form)
def prepare_adme_posts_2(self):
client = MongoClient()
db = client.adme
posts = db.posts.find()
ribbon = Ribbon.objects.get(pk=11)
for post in posts:
Post(title=post['title'],
content=post['content2'],
status='d',
ribbon=ribbon,
meta_data={
'source_url': post['source_url'],
}).save()
def test_saving_and_retrieving_post(self):
first_item = Post()
first_item.title = "Post 1"
first_item.subtitle = "Subtitle 1"
first_item.text = "Text 1"
first_item.author = self.user
first_item.save()
second_item = Post()
second_item.title = "Post 2"
second_item.subtitle = "Subtitle 2"
second_item.text = "Text 2"
second_item.author = self.user
second_item.save()
saved_items = Post.objects.all()
self.assertEqual(saved_items.count(), 2)
first_saved_item = saved_items[0]
second_saved_item = saved_items[1]
self.assertEqual(first_saved_item.title, 'Post 1')
self.assertEqual(second_saved_item.title, 'Post 2')
def create_activity():
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('Successfully submitted to Activity Office', 'success')
return redirect(url_for('home'))
return render_template("create_activity.html",
title="New Activity",
form=form)
def NewPost(request):
if request.user.has_perm('blog.add_post'):
if request.method == 'POST':
author = Post(author = request.user)
form = PostForm(request.POST, request.FILES, instance = author)
if form.is_valid():
form.save()
return HttpResponseRedirect('/')
else:
form = PostForm()
return render(request,'blog/Edit_Post.html',locals())
else:
return HttpResponseRedirect('/dashboard/new_post/')
def uploadfile():
if not current_user.is_authenticated:
return redirect(url_for('index'))
form = UploadFileForm()
if form.validate_on_submit():
f = request.files['file']
post = Post(path='blog/pages/' + secure_filename(f.filename),
title=form.title.data)
db.session.add(post)
db.session.commit()
f.save('blog/pages/' + secure_filename(f.filename))
posts = Post.query.limit(5).all()
return render_template("upload.html", form=form, posts=posts)
def setUp(self):
self.app = create_app(config['testDB'])
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
self.user = User(username='******', email='*****@*****.**',
password='******', image_file='Night view.png')
db.session.add(self.user)
db.session.commit()
self.post = Post(title='Random post', date_posted=parser.parse("2020 05 17 12:00AM"),
content='Some words', user_id=self.user.id)
db.session.add(self.post)
db.session.commit()
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()
return redirect(url_for('home'))
return render_template("create_post.html",
title="New Post",
form=form,
legend='New Post')
def new_post(request):
if not request.method == 'POST':
response = HttpResponse()
response.status_code = 405
return response
title = request.POST['title']
content = request.POST['content']
post = Post(title=title, content=content)
post.save()
return HttpResponseRedirect(reverse('blog:blog'))
def setUp(self):
user = User.objects.create_user('user', '*****@*****.**', 'user')
user.save()
post = Post()
post.pub_date = datetime.datetime(int(self.date['year']),
int(self.date['month']),
int(self.date['day']))
post.headline = 'h'
post.summary = 's'
post.body = 'b'
post.author_id = user.id
post.save()
def test_add_blog(self):
author = User(username="******")
newblog = Post()
newblog.title = "TestBlog"
newblog.STATUS = 1
newblog.description = "Test Description"
newblog.image = tempfile.NamedTemporaryFile(suffix='.jpg').name
newblog.category = "TestCat"
newblog.slug = "test-slug"
newblog.author = author
newblog.content = "Cosas"
newblog.updated_on
newblog.created_on
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!', category='success')
return redirect(url_for('home'))
return render_template('create_post.html',
title='Create a new post',
form=form)
def new_topic():
form = NewTopicForm()
if form.validate_on_submit():
user_id = current_user.id
topic = Topic(name=form.name.data, user_id=user_id)
db.session.add(topic)
db.session.commit()
post = Post(body=form.msg.data, user_id=user_id, topic_id=topic.id)
db.session.add(post)
db.session.commit()
flash('Congratulations, your topic had been added!')
return redirect(url_for('topics'))
return render_template('new_topic.html', title='Add topic', form=form)
