def test_post_detail_context_info(self):
topic = Topic.objects.create()
Post.objects.bulk_create([Post(text=i, topic_id=1) for i in range(20)])
Post.objects.bulk_create([Post(text=i, topic_id=2) for i in range(20)])
with self.assertNumQueries(6):
response = self.client.get("/api/topics/2/posts/28/")
self.assertEqual(response.status_code, 200)
self.assertEqual(response.data["context"]["index"], 7)
self.assertEqual(response.data["context"]["page"], 2)
def rss_parser():
try:
content = urllib2.urlopen("https://lenta.ru/rss").read()
except urllib2.HTTPError:
return False
tree = etree.fromstring(content)
items = tree.xpath("//item")
for item in items:
try:
category = item.xpath('category/text()')[0]
guid = item.xpath('guid/text()')[0]
title = item.xpath('title/text()')[0]
link = item.xpath('link/text()')[0]
description = item.xpath('description/text()')[0]
pub_date = parser.parse(item.xpath('pubDate/text()')[0])
except IndexError:
continue
category, created = Category.objects.get_or_create(name=category)
try:
post = Post.objects.get(guid=guid)
except Post.DoesNotExist:
post = Post(guid=guid)
post.category = category
post.title = title
post.link = link
post.description = description
post.pub_date = pub_date
post.save()
return True
def test_no_np1q_on_post_list(self):
Post.objects.bulk_create(
[Post(text=str(i), topic_id=1) for i in range(5)])
with self.assertNumQueries(12):
response = self.client.get("/api/topics/1/posts/")
self.assertEqual(response.data["count"], 6)
def new_post():
token = request.json.get('token')
if not token:
return jsonify(error="Missing token")
user = auth_user(token)
if not user:
return jsonify(error="Invalid token")
title = request.json.get('title')
melody_data = request.json.get('melody_data')
if title == None or melody_data == None:
return jsonify(error="Missing title/melody_data")
post = Post(title=title, melody_data=melody_data, author=user)
db.session.add(post)
db.session.commit()
return jsonify(post={
"id":post.id,
"title":post.title,
"melody_data":post.melody_data,
"author":post.author.name,
"date":post.date_posted.strftime('%m-%d-%Y'),
})
def create(request: HttpRequest, course_id: int) -> HttpResponse:
"""Create a new post."""
course = Course.objects.get(id=course_id)
payload = loads(request.body)
# create post with required fields
new_post = Post(
title=payload["title"],
content=payload["content"],
author=request.user,
course=course,
)
new_post.save()
# handle optional fields
if payload.get("parent", False):
parent_post = Post.objects.get(id=payload["parent"])
new_post.parent = parent_post
if payload.get("tags", False):
tags = Tag.objects.filter(id__in=payload["tags"])
new_post.tags.add(*tags)
if payload.get("type", False):
new_post.type = payload["type"]
if payload.get("visibility", False):
new_post.visibility = payload["visibility"]
new_post.anonymous = payload.get("anonymous", False)
# automatically add author as a follower
new_post.followers.add(request.user)
new_post.save()
return HttpResponse(dumps(PostService.post_to_dict(new_post)))
def getting_all_comments_succeeds(self, client, init_db):
post_id = Post(**self.post_data).save().id
comment_data = {'body': 'test_comment', 'post_id': post_id}
# save three comments
for i in range(3):
Comment(**comment_data).save()
res = client.get('/api/comments')
assert res.status_code == 200
payload = json.loads(res.data)
assert len(payload['data']) == 3
def api_create_post_view(request):
account = Account.objects.get(pk=1)
post = Post(author=account)
if request.method == 'Post':
serializers = PostSerializer(post, data=request.data)
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 creating_comment_succeeds(self, client, init_db):
post_id = Post(**self.post_data).save().id
comment_data = {
'body': 'this is a test comment',
'post_id': post_id
}
res = client.post('/api/comments', data=json.dumps(comment_data))
assert res.status_code == 201
payload = json.loads(res.data)
assert payload['data']['body'] == comment_data['body']
assert payload['data']['post']['id'] == post_id
def create_post(id):
data = request.get_json() or {}
if 'image' not in data:
return make_response(400, 'must include image field')
data['user_id'] = id
post = Post()
post.from_dict(data)
db.session.add(post)
db.session.commit()
response = jsonify(post.to_dict())
response.status_code = 201
return response
def create_post():
title = request.json.get('title', None)
text = request.json.get('text', None)
media = request.json.get('media', None)
new_post = Post(title=title, text=text, media=media)
if new_post:
new_post.create()
return jsonify(new_post.to_dict()), 201
else:
return {'error': 'Something went wrong'}, 409
def post(self):
data = parser.parse_args()
current_user = get_jwt_identity()
new_post = Post(author=str(current_user['user_id']),
likes=0,
body=data['body'],
author_username=current_user['username'],
title=data['title'])
try:
new_post.save_to_db()
return {'message': 'Post created'}
except Exception as e:
return {'message': 'Something went wrong' + str(e)}, 500
def write_post_db(data):
post = Post(source_name=data['source_name'],
author=data['author'],
title=data['title'],
url=data['url'],
img_url=data['img_url'],
published_at=data['published_at'],
description=data['description'])
# check if we have already this post
if (not Post.objects.filter(title__icontains=data['title'])) or \
(not Post.objects.filter(url__icontains=data['url'])):
post.save()
else:
print('It\'s OK! We have already this info!')
def post(request):
#body_unicode = request.body.decode('utf-8')
#body = json.loads(body_unicode)
posted = Post()
form = PostForm(request.POST, instance=posted)
#form.user = body["user"]
#form.content = body["content"]
#form.title = body["title"]
if form.is_valid():
form.save()
return JsonResponse({"is_succeed": True})
else:
return HttpResponse(status=500)
def create_cultivo():
body = request.get_json() # get the request body content
if body is None:
return jsonify({'msg':"El body está vacio", 'status':'failed'}), 400
if 'nombre' not in body:
return jsonify({'msg':'Necesita especificar un nombre', 'status':'failed'}),400
if 'epoca_siembra' not in body:
return jsonify({'msg':'Necesita especificar epoca_siembra ', 'status':'failed'}), 400
if 'clima' not in body:
return jsonify({'msg':'Necesita especificar clima', 'status':'failed'}), 400
if 'cosecha' not in body:
return jsonify({'msg':'Necesita especificar cosecha', 'status':'failed'}), 400
if 'tipo_de_suelo' not in body:
return jsonify({'msg':'Necesita especificar tipo_de_suelo', 'status':'failed'}), 400
if 'preparacion_del_suelo' not in body:
return jsonify({'msg':'Necesita especificar preparacion_del_suelo', 'status':'failed'}), 400
if 'plagas' not in body:
return jsonify({'msg':'Necesita especificar plagas', 'status':'failed'}), 400
if 'descripcion' not in body:
return jsonify({'msg':'Necesita especificar descripción', 'status':'failed'}), 400
body_nombre = body['nombre']
cultivo = Post.query.filter_by(name= body_nombre).first()
if cultivo:
return jsonify({'msg':'El cultivo ya existe', 'status':'failed'}), 200
post = Post()
post.nombre = body['nombre']
post.epoca_siembra = body['epoca_siembra']
post.cosecha = body['cosecha']
post.clima = body['clima']
post.tipo_de_suelo = body['tipo_de_suelo']
post.preparacion_del_suelo = body['preparacion_del_suelo']
post.plagas = body['plagas']
# agrega user a la base de datos
db.session.add(post)
# guarda los cambios
db.session.commit()
response_body = {
"msg": "Cultivo creado",
"status":"succesful"
}
return jsonify(response_body), 200
def add_measurement(request):
temp = request.POST.get('temperature', None)
hum = request.POST.get('humidity', None)
mac = request.POST.get('mac', None)
if mac is None:
return Response()
sensors = Sensor.objects.filter(mac_addr=mac)
if sensors.count() == 0:
sensor = Sensor(mac_addr=mac, name=mac)
sensor.save()
else:
sensor = sensors[0]
post = Post(temperature=temp, humidity=hum, sensor=sensor)
post.save()
return Response(sensor.interval)
def addNewPost():
# Obtener el ID del usuario registrado get_jwt_identity
current_user_id = get_jwt_identity()
user = User.query.get(current_user_id)
# Se reporta un error si no esta registrado
if user is None:
raise APIException('No se ha iniciado sesión', status_code=400)
#Obtener el request body
request_body = request.get_json()
# Validate the data
if (request_body["title"] is None or request_body["comment"] is None or request_body["url"] is None or request_body["provincia"] is None \
or request_body["dificultad"] is None or request_body["duracion"] is None):
raise APIException('Request Body inválido. Uno o más parámetros están vacíos', status_code=400)
#Crear Nuevo Post
createdDate = datetime.datetime.now()
createdDate = createdDate.strftime("%d/%m/%Y %H:%M:%S")
updatedDate = datetime.datetime.now()
updatedDate = updatedDate.strftime("%d/%m/%Y %H:%M:%S")
total_comment = 35
total_like = 35
newPost = Post(created = createdDate, updated = updatedDate, title = request_body["title"], comment = request_body["comment"],\
url = request_body["url"], provincia = request_body["provincia"], dificultad = request_body["dificultad"], duracion = request_body["duracion"],\
total_comment = total_comment, total_like = total_like, iduser = user.id)
db.session.add(newPost)
db.session.commit()
tmpObj = newPost.serialize()
#Obtener Post Guardado
# Guardar puntuacion inicial
createdDate = datetime.datetime.now()
createdDate = createdDate.strftime("%d/%m/%Y %H:%M:%S")
updatedDate = datetime.datetime.now()
updatedDate = updatedDate.strftime("%d/%m/%Y %H:%M:%S")
newPostLike = Post_like(created = createdDate, updated = updatedDate, puntuacion = 35, idpost = tmpObj["id"],\
iduser = user.id)
db.session.add(newPostLike)
db.session.commit()
return jsonify('Nuevo Post publicado'), 200
def create_post(current_user):
# Get data from request
data = request.get_json()
# Check the length if the caption (caption is limited to 100 chars)
if len(data['caption']) <= 100:
post_image = save_image(url=data['image_file'])
# Create post object
post = Post(caption=data['caption'],
image_file=post_image,
user_id=current_user.id)
# Add to database
db.session.add(post)
db.session.commit()
# Return feedbacks
return jsonify({'message': 'Post created!'})
else:
return jsonify({'message': 'Caption is limited to 100 chars'})
def test_record_cycle(self):
Post.objects.bulk_create(
[Post(text=str(i), topic_id=1) for i in range(5)])
record = Record.objects.create(topic_id=1, user_id=2)
self.assertEqual(record.count, 0)
self.client.get("/api/topics/1/posts/?page=1")
record.refresh_from_db()
self.assertEqual(record.count, 5)
self.client.get("/api/topics/1/posts/?page=2")
record.refresh_from_db()
self.assertEqual(record.count, 6)
self.client.get("/api/topics/1/posts/?page=1")
record.refresh_from_db()
self.assertEqual(record.count, 6)
def addPost():
content = request.json.get("content")
user_id = request.json.get("user_id")
user = User.query.get(user_id)
if not content:
return jsonify({"msg": "Content required"}), 400
post = Post()
post.content = content
post.user_id = user_id
db.session.add(post)
db.session.commit()
data = {"user": user.username, "success": "Added", "post_id": post.id}
return jsonify(data), 200
def post(self, request, format=None):
# Check if user is authed or not
username_data = get_username_from_jwt(request)
if username_data['username'] != False:
# Parse and create post
data = JSONParser().parse(request)
data['created_at'] = created_at = timezone.now()
serializer = PostSerializer(data=data)
if serializer.is_valid():
user = User.objects.get(username=username_data['username'])
post = Post(title=serializer.data['title'],
description=serializer.data['description'],
user=user,
created_at=serializer.data['created_at'])
post.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
return JsonResponse({'msg': username_data['error_msg']}, status=400)
def create_post_resolver(obj, info, title, description):
try:
today = date.today()
post = Post(title=title,
description=description,
created_at=today.strftime("%b-%d-%Y"))
db.session.add(post)
db.session.commit()
payload = {"success": True, "post": post.to_dict()}
except ValueError: # date format errors
payload = {
"success":
False,
"errors": [
f"Incorrect date format provided. Date should be in "
f"the format dd-mm-yyyy"
]
}
return payload
def create_post(request):
form = PostForm({'author': request.user.id})
if request.method == 'POST':
form = PostForm(request.POST, request.FILES)
title = request.POST['title']
details = request.POST['details']
viewers = request.POST['viewers']
if form.is_valid():
post = Post(author=request.user,
type='Blog',
title=title,
details=details,
viewers=viewers)
try:
post.save()
''' upload the files '''
files = request.FILES.getlist('files')
if files is not None:
for file in files:
attachment = Attachment(file=file,
post=post,
content_type=file.content_type)
attachment.save()
return HttpResponseRedirect(reverse('thanks'))
except ():
pass
return render(request, 'posts/create.html',
{'model': {
'form': form,
'action': 'create-post'
}})
db.create_all()
db.session.commit()
# erase and clean the database
users = User.query.all()
for u in users:
db.session.delete(u)
posts = Post.query.all()
for p in posts:
db.session.delete(p)
comments = Comment.query.all()
for c in comments:
db.session.delete(c)
db.session.commit()
# fill database with test data
user1 = User(username='******')
user1.set_password('test')
db.session.add(user1)
db.session.commit()
users = User.query.all()
print(users)
post1 = Post()
db.session.add(post1)
db.session.commit()
postedDateTimes.insert(0, postedDatetime)
for i in range(postCount):
companyIndex = random.randrange(0, len(companies))
companyId = companyIndex + 1
company = companies[companyIndex]
companyName = company.__dict__["name"]
buyOrSell = random.choice(["buy", "sell"])
profit_or_loss_price = randint(-30000, 60000) * 100
content = getContent(companyName, buyOrSell, profit_or_loss_price)
created_at = postedDateTimes[i]
post = Post(
content=content,
user=random.choice(users),
company=company,
price=randint(500, 15000),
quantity=randint(1, 20) * 100,
buy_or_sell=buyOrSell,
created_at=created_at,
)
if buyOrSell == "sell":
post.profit_or_loss_price = profit_or_loss_price
post.save()
for user in getLikeUsers(users):
post.likeUsers.add(user)
def test_getting_a_single_post_succeeds(self, client, init_db):
post_id = Post(**POST_DATA).save().id
res = client.get(f'/api/posts/{post_id}')
assert res.status_code == 200
assert json.loads(res.data)['data']['id'] == post_id
def create_post(current_user):
data = request.get_json()
new_post = Post(content=data["content"], user_id=current_user.id)
db.session.add(new_post)
db.session.commit()
return jsonify({"Message": "A new post has been created."})
def validate(self, attrs): instance = Post(**attrs) instance.clean() return attrs
from api.models import User, Post u = User(username='******', email='*****@*****.**') db.session.add(u) db.session.commit() #Query User Table users = User.query.all() users for u in users: print(u.id, u.username) Now let's add a blog post:(adding a shop review) >>> u = User.query.get(1) >>> p = Post(body='my first post!', author=u) >>> db.session.add(p) >>> db.session.commit() Query Post Table >>> posts = Post.query.all() >>> posts To get Post Object >>> p = posts[0] >>> p >>> p.id >>> p.author To get list of user's posts>>> for p in u.posts: ... p
def setup():
"""
Function that creates and saves elements to the database for demo purposes.
Function assumes that the database starts out empty.
For LOCAL DEV ONLY.
"""
passwords = []
# create example users
passwords.append(UserService.generate_password())
user1 = User.objects.create_user(
"*****@*****.**",
password=passwords[0],
email="*****@*****.**",
first_name="Josiah",
last_name="Carberry",
)
user1.save()
passwords.append(UserService.generate_password())
user2 = User.objects.create_user(
"*****@*****.**",
password=passwords[1],
email="*****@*****.**",
first_name="Blueno",
)
user2.save()
passwords.append(UserService.generate_password())
user3 = User.objects.create_user(
"*****@*****.**",
password=passwords[2],
email="*****@*****.**",
first_name="Random",
last_name="Person",
)
user3.save()
# create course
course1 = Course(name="Course 1")
course1.save()
course1.instructors.add(user1)
course1.students.add(user2)
course1.students.add(user3)
course1.save()
# create posts
post1 = Post(
author=user1,
course=course1,
title="I have a question",
content="idk what im doing",
anonymous=True,
type=Post.Type.QUESTION,
visibility=Post.Visibility.PUBLIC,
)
post1.save()
post2 = Post(
author=user1,
course=course1,
title="I also have a question",
content="i really dont know what im doing",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PRIVATE,
)
post2.save()
post3 = Post(
author=user3,
course=course1,
title="My code is broken",
content="Hi you can see my name, Student answers welcomed!!",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PUBLIC,
)
post3.save()
post4 = Post(
author=user2,
course=course1,
title="Could a TA help",
content="Only TAs should be able to see this",
anonymous=False,
type=Post.Type.NOTE,
visibility=Post.Visibility.PRIVATE,
)
post4.save()
post5 = Post(
author=user1,
course=course1,
title="TA Note about posting",
content="Hours Changed from 11 to 2",
anonymous=True,
type=Post.Type.NOTE,
visibility=Post.Visibility.PUBLIC,
)
post5.save()
post6 = Post(
author=user1,
course=course1,
title="Question to Students",
content="TA asking for student replies ",
anonymous=True,
type=Post.Type.QUESTION,
visibility=Post.Visibility.PUBLIC,
)
post6.save()
# create tags
tag1 = Tag(name="Tag 1", course=course1)
tag1.save()
tag2 = Tag(name="Tag 2", course=course1)
tag2.save()
post1.tags.add(tag1, tag2)
post2.tags.add(tag2)
post4.tags.add(tag1)
post6.tags.add(tag1, tag2)
print("setup successful!")
print("user passwords in order: " + str(passwords))
def test_getting_single_comment_succeeds(self, client, init_db):
post_id = Post(**self.post_data).save().id
comment_data = {'body': 'test_comment', 'post_id': post_id}
comment_id = Comment(**comment_data).save().id
res = client.get(f'/api/comments/{comment_id}')
assert res.status_code == 200