def doPost(request, current_posts):
if request.method == 'POST':
form = PostsForm(request.POST)
if form.is_valid():
formData = form.cleaned_data
c = Post(
subject=formData['subject'],
author=request.user,
content=formData['message'],
time=datetime.datetime.now(),
)
if(len(formData['topic']) != 0):
n = formData['topic']
topics = Topic.objects.filter(name=n)
if(len(topics) == 0):
t = Topic(name=n)
t.save()
else:
t = topics[0]
c.topic = t
c.save()
return HttpResponseRedirect('/p')
else:
form = PostsForm(
initial={'subject': 'Your subject', 'message': 'Put your comments here. Max 60000 words!'}
)
return render_to_response('posts/posts.html', {'form': form, 'current_posts' : current_posts }, context_instance=RequestContext(request))
def handle(self, *args, **options):
PATH = os.path.join(BASE_DIR, '../assets/posts')
SEPARATOR = '==='
# For every blog post markdown file
for post_file in os.listdir(PATH):
post_f = open(os.path.join(PATH, post_file), 'r')
post_string = post_f.read()
# Get the heading and content data
file_content = post_string.strip(SEPARATOR).split(SEPARATOR)
heading = file_content[0].strip('\n').split(
'\n') # An array of the title, author and slug
title = heading[0].replace('Title: ', '')
author = heading[1].replace('Author: ', '')
slug = heading[2].replace('Slug: ', '')
content = file_content[1] # The blog post content as a string
tags = get_tags(content)
# Create blog post object and save to the db
post = Post(
slug=slug.strip(),
title=title.strip(),
author=author.strip(),
content=content.strip(),
tags=tags,
)
post.save()
self.stdout.write('Blog post "{}" saved.'.format(title))
def post_repost(request, pk=None):
"""
Repost a post.
This always reposts the original post.
Redirects to the post's page if the repost was successful or if the user
is not authenticated.
Otherwise, redirects to the referer if present, or the landingpage if not.
@param pk: the primary key which identifies the post
@return redirect depending on the success
"""
user = request.user
repost_original = Post.objects.get(pk=pk).original_or_self()
check = repost_original.check_repost(user)
if check == 'not_auth':
return redirect('posts:post', pk=repost_original.pk)
if check != 'ok':
return redirect(request.META['HTTP_REFERER'] or 'landingpage')
repost = Post(content=repost_original.content,
author=user,
repost_original=repost_original)
repost.save()
context = {
'content': "There is a new repost to a post of you made by %s" % user.username,
'link_to_subject': reverse("posts:post", kwargs={'pk': repost.pk})
}
send_notifications(repost_original.author, "There is a new repost to your post",
'users/notification_for_post_email.html', context, repost)
return redirect('posts:post', pk=repost.pk)
def get_delete(value):
post = Post()
user = User()
user.id = value['author']['id']
post.id = value['id']
post.user = user
return post.get_delete_absolute_url()
def new_post_for_testing(self):
"""
creates a new post with required fields filled out for use in testing
"""
post = Post(url="test", creator="*****@*****.**", title="test", text_content="test", type="blog")
post.save()
return post
def add_post_data_from_webpage(self):
for account in self.accounts:
url = 'https://www.youtube.com/feeds/videos.xml?channel_id={}'.format(
account.account_id)
soup = BeautifulSoup(requests.get(url).content, "xml")
for entry in soup.find_all('entry'):
account.updated = datetime.utcnow()
account.save()
source_id = entry.find('id').text.replace('yt:video:', '')
exists = Post.objects.filter(source_id=source_id).count()
if exists:
continue
if self.reject_condition_exists(
entry.find('title').text, account):
continue
post = Post(account=account,
title=entry.find('title').text,
description=entry.find('media:group').find(
'media:description').text,
created=entry.find('published').text,
source_id=source_id,
url=entry.find('media:group').find(
'media:content').get('url'),
thumbnail=entry.find('media:group').find(
'media:thumbnail').get('url'))
print('Adding {}\'s - {}'.format(account.name, post.title))
post.save()
def profile(request, user_slug):
user = get_object_or_404(User, slug=user_slug)
if user.id == request.me.id:
goto = request.GET.get("goto")
if goto:
return redirect(goto)
tags = Tag.objects.filter(is_visible=True).all()
intro = Post.get_user_intro(user)
projects = Post.objects.filter(author=user, type=Post.TYPE_PROJECT).all()
active_tags = {t.tag_id for t in UserTag.objects.filter(user=user).all()}
achievements = UserBadge.objects.filter(user=user)[:8]
expertises = UserExpertise.objects.filter(user=user).all()
posts = Post.objects_for_user(request.me)\
.filter(author=user, is_visible=True)\
.exclude(type__in=[Post.TYPE_INTRO, Post.TYPE_PROJECT])
return render(
request, "users/profile.html", {
"user": user,
"intro": intro,
"projects": projects,
"tags": tags,
"active_tags": active_tags,
"achievements": achievements,
"expertise_form": ExpertiseForm(),
"expertises": expertises,
"posts": paginate(request, posts),
})
def upload(request, customer_id):
customer = get_object_or_404(Customer, pk=customer_id)
if request.method == 'POST' and request.POST['content']:
myfile = request.FILES['myfile']
post = Post()
post.content = request.POST['content']
post.createtime = timezone.now()
post.updatetime = timezone.now()
post.customer = Customer.objects.get(id=customer_id)
fs = FileSystemStorage()
filename = fs.save(myfile.name, myfile)
uploaded_file_url = fs.url(filename)
# image = Image()
post.save()
for file in request.FILES.getlist('myfile'):
image = Image()
post.save()
image.imageurl = file
image.post = Post.objects.get(id=post.id)
image.save()
# image.imageurl = filename
# image.post = Post.objects.get(id=post.id)
# post.save()
# image.save()
return redirect('/customers/' + 'detail/' + str(customer_id))
return render(request, 'customers/detail.html', {'customer': customer})
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 test_list_posts(self):
response = self.client.get(self.post_list_url)
self.assertEqual(response.status_code, 200)
post_data = [{
'title': 'test1',
'body': 'test1',
'user': self.user
}, {
'title': 'test2',
'body': 'test2',
'user': self.user
}]
for data in post_data:
post = Post(**data)
post.save()
# not logged in
response = self.client.get(self.post_list_url)
payload = response.json()
self.assertEqual(len(payload), 2)
# now logged in
self.login()
response = self.client.get(self.post_list_url)
payload = response.json()
self.assertEqual(len(payload), 2)
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):
form = RegistrarUsuarioForm(request.POST)
if (form.is_valid()):
dados = form.cleaned_data
if request.POST['senha_1'] != request.POST['senha']:
message = 'Atençao! As senhas não conferem.'
form = RegistrarUsuarioForm(request.POST)
return render(request, 'usuarios/registrar.html', {
'form': form,
'message': message
})
usuario = User.objects.create_user(dados['nome'], dados['email'],
dados['senha'])
perfil = Perfil(nome=usuario.username,
nome_empresa=dados['nome_empresa'],
telefone=dados['telefone'],
usuario=usuario)
perfil.save()
post = Post(user=perfil,
postagem='Opa, nenhuma postagem!',
init=True)
post.save()
message = Feedback(perfil=perfil,
message='Perfil criado com sucesso.')
message.save()
return redirect('login')
return render(request, 'usuarios/registrar.html', {'form': form})
def doPost(request, current_posts):
if request.method == 'POST':
form = PostsForm(request.POST)
if form.is_valid():
formData = form.cleaned_data
c = Post(
subject=formData['subject'],
author=request.user,
content=formData['message'],
time=datetime.datetime.now(),
)
if (len(formData['topic']) != 0):
n = formData['topic']
topics = Topic.objects.filter(name=n)
if (len(topics) == 0):
t = Topic(name=n)
t.save()
else:
t = topics[0]
c.topic = t
c.save()
return HttpResponseRedirect('/p')
else:
form = PostsForm(
initial={
'subject': 'Your subject',
'message': 'Put your comments here. Max 60000 words!'
})
return render_to_response('posts/posts.html', {
'form': form,
'current_posts': current_posts
},
context_instance=RequestContext(request))
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 debug_dev_login(request):
if not settings.DEBUG:
raise AccessDenied(title="Эта фича доступна только при DEBUG=true")
user, is_created = User.objects.get_or_create(
slug="dev",
defaults=dict(
patreon_id="123456",
membership_platform_type=User.MEMBERSHIP_PLATFORM_PATREON,
email="*****@*****.**",
full_name="Senior 23 y.o. Developer",
company="FAANG",
position="Team Lead конечно",
balance=10000,
membership_started_at=datetime.utcnow(),
membership_expires_at=datetime.utcnow() +
timedelta(days=365 * 100),
created_at=datetime.utcnow(),
updated_at=datetime.utcnow(),
is_email_verified=True,
moderation_status=User.MODERATION_STATUS_APPROVED,
roles=["god"],
),
)
if is_created:
Post.upsert_user_intro(user, "Очень плохое интро", is_visible=True)
session = Session.create_for_user(user)
return set_session_cookie(redirect("profile", user.slug), user, session)
def intro(request):
if request.me.moderation_status == User.MODERATION_STATUS_APPROVED:
return redirect("profile", request.me.slug)
if request.method == "POST":
form = UserIntroForm(request.POST, request.FILES, instance=request.me)
if form.is_valid():
user = form.save(commit=False)
# send to moderation
user.moderation_status = User.MODERATION_STATUS_ON_REVIEW
user.save()
# create intro post
intro_post = Post.upsert_user_intro(user,
form.cleaned_data["intro"],
is_visible=False)
Geo.update_for_user(user)
# notify moderators to review profile
async_task(notify_profile_needs_review, user, intro_post)
return redirect("on_review")
else:
existing_intro = Post.get_user_intro(request.me)
form = UserIntroForm(
instance=request.me,
initial={"intro": existing_intro.text if existing_intro else ""},
)
return render(request, "users/intro.html", {"form": form})
def create(self, validated_data):
content = validated_data['content']
thread_id = validated_data['thread_id']
# Get thread object
try:
thread = Thread.objects.get(id=thread_id)
except Thread.DoesNotExist:
raise serializers.ValidationError('Thread does not exist, please enter correct thread id')
# Get the requesting user
user = None
request = self.context.get("request")
if request and hasattr(request, "user"):
user = request.user
else:
raise serializers.ValidationError('Must be authenticated to create post')
# Create the post
post = Post(
content=content,
thread=thread,
creator=user
)
# Update the thread last_activity to post creation time
post.save()
thread.last_activity = post.created_at
thread.save()
return post
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 post(self, req):
"""
Muestra un form para crear un post y lo crea si la peticion es POST
:param req: HttpRequest
:return: HttpResponse
"""
error_messages = []
success_message = ''
# Creamos owner y se lo pasamos al form con un objeto pre-establecido
post_with_owner = Post()
post_with_owner.owner = req.user
post_with_owner.blog = Blog.objects.filter(owner=req.user)[0]
form = PostCreateForm(req.POST, instance=post_with_owner)
if form.is_valid():
new_post = form.save()
form = PostCreateForm()
success_message = u'Post guardado con éxito! '
success_message += u'<a href="{0}">'.format(reverse('post_detail', args=[req.user.username, new_post.pk]))
success_message += u'(ver post)</a>'
else:
error_messages.append(u'Formulario incompleto.')
context = {
'form': form,
'success_message': success_message
}
return render(req, 'posts/new_post.html', context)
def image_form_upload(request):
if request.method == 'POST':
form = ImageForm(request.POST, request.FILES)
if form.is_valid():
url = "https://api.imgur.com/3/upload"
access_token = "931ddfab9e19c9a7512147c83459ce1d457e09cf"
headers = {'Authorization': 'Bearer ' + access_token}
data = {
'image': request.FILES.get('imagefile').read(),
'title': request.POST['description'],
'type': 'file'
}
response = requests.request("POST",
url,
headers=headers,
data=data)
response_data = response.json()
upload_success = response_data['success']
external_link = response_data['data']['link']
print(upload_success)
# save reference to database as a post
new_post = Post(content=external_link, author=request.user)
new_post.save()
return redirect('image')
else:
form = ImageForm()
return render(request, 'iv/image.html', {'form': form})
def mutate(root, info, input=None):
ok = True
post_instance = Post(title=input.title,
descr=input.descr,
owner_id=input.owner)
post_instance.save()
return CreatePost(ok=ok, post=post_instance)
def intro(request):
if request.me.is_profile_complete \
and request.me.is_profile_reviewed \
and not request.me.is_profile_rejected:
return redirect("profile", request.me.slug)
if request.method == "POST":
form = UserIntroForm(request.POST, request.FILES, instance=request.me)
if form.is_valid():
user = form.save(commit=False)
# send to moderation
user.is_profile_complete = True
user.is_profile_reviewed = False
user.is_profile_rejected = False
user.save()
# create intro post
intro_post = Post.upsert_user_intro(user,
form.cleaned_data["intro"],
is_visible=False)
# notify moderators to review profile
async_task(notify_profile_needs_review, user, intro_post)
return redirect("on_review")
else:
existing_intro = Post.get_user_intro(request.me)
form = UserIntroForm(
instance=request.me,
initial={"intro": existing_intro.text if existing_intro else ""},
)
return render(request, "users/intro.html", {"form": form})
def debug_random_login(request):
if not settings.DEBUG:
raise AccessDenied(title="Эта фича доступна только при DEBUG=true")
slug = "random_" + random_string()
user, is_created = User.objects.get_or_create(
slug=slug,
defaults=dict(
patreon_id=random_string(),
membership_platform_type=User.MEMBERSHIP_PLATFORM_PATREON,
email=slug + "@random.dev",
full_name="%s %d y.o. Developer" % (random.choice(["Максим", "Олег"]), random.randint(18, 101)),
company="Acme Corp.",
position=random.choice(["Подниматель пингвинов", "Опускатель серверов", "Коллектор пивных бутылок"]),
balance=10000,
membership_started_at=datetime.utcnow(),
membership_expires_at=datetime.utcnow() + timedelta(days=365 * 100),
created_at=datetime.utcnow(),
updated_at=datetime.utcnow(),
is_email_verified=True,
moderation_status=User.MODERATION_STATUS_APPROVED,
),
)
if is_created:
Post.upsert_user_intro(user, "Интро как интро, аппрув прошло :Р", is_visible=True)
session = Session.create_for_user(user)
return set_session_cookie(redirect("profile", user.slug), user, session)
def post(self, request):
"""
Procesa el formulario de creación de un post
:param request: objeto HttpRequest
:return: HttpResponse con respuesta
"""
post = Post()
userid = User.objects.get(username=request.user).id
try:
post.blog = Blog.objects.get(owner=userid)
except Blog.DoesNotExist:
return HttpResponse(
'Este usuario no tiene creado ningún blog. <a href="/new-blog" %}>Cree un blog</a> primero',
status=404)
form = PostForm(request.POST, request.FILES, instance=post)
if form.is_valid():
new_post = form.save()
form = PostForm()
messages.success(request, 'Post creado correctamente')
context = {'form': form}
return render(request, 'posts/form.html', context)
def create(request):
post = Post(post_text=request.POST['post_text'],
title=request.POST['title'],
content=request.POST['content'],
pub_date=datetime.datetime.now())
post.save()
return HttpResponseRedirect(reverse('posts:detail', args=(post.id, )))
def create_posts_from_xml(url):
"""
Read XML file data and add each row as a post to database
:param(str) url: Web URL of XML Data
:return(int): No of Posts added to database
"""
data = get_xml_data_from_file(url)
count = 0
from posts.models import Post
for row in data:
new_post = Post()
for key, value in row.items():
object_attr_type = KEY_ATTR_MAP.get(key)
if not object_attr_type:
continue # XML key not of our interest
attribute = object_attr_type[0]
data_type = object_attr_type[1]
try :
# Type cast and assign value to mapped attribute of `post` object
setattr(new_post, attribute, data_type(value))
except (TypeError, ValueError) as e:
continue
new_post.save()
count += 1
print("{} Posts added".format(count))
return count
def post_reply(request, pk=None):
"""
Reply to a post.
Redirects to the post page.
@param request:
@param pk:
@return:
"""
user = request.user
reply_original = Post.objects.get(pk=pk)
author = reply_original.author
check = reply_original.check_reply(user)
if check != 'ok':
return redirect('posts:post', pk=reply_original.pk)
reply = Post(content=request.POST['content_reply'],
author=user,
reply_original=reply_original)
reply.save()
context = {
'content':
"There is a new reply to a post of you made by %s" % user.username,
'link_to_subject': reverse("posts:post", kwargs={'pk': reply.pk})
}
send_notifications(author, "There is a new reply to your post",
'users/notification_for_post_email.html', context,
reply)
reply_original.reply.add(reply)
return redirect('posts:post', pk=reply_original.pk)
def post_reply(request, pk=None):
"""
Reply to a post.
Redirects to the post page.
@param request:
@param pk:
@return:
"""
user = request.user
reply_original = Post.objects.get(pk=pk)
author = reply_original.author
check = reply_original.check_reply(user)
if check != 'ok':
return redirect('posts:post', pk=reply_original.pk)
reply = Post(content=request.POST['content_reply'],
author=user,
reply_original=reply_original)
reply.save()
context = {
'content': "There is a new reply to a post of you made by %s" % user.username,
'link_to_subject': reverse("posts:post", kwargs={'pk': reply.pk})
}
send_notifications(author, "There is a new reply to your post",
'users/notification_for_post_email.html', context, reply)
reply_original.reply.add(reply)
return redirect('posts:post', pk=reply_original.pk)
def setUp(self):
self.factory = RequestFactory()
self.client = Client()
self.user = DjangoUser.objects.create_superuser(
'adminz', '*****@*****.**', 'adminpass')
self.post = Post(user=self.user, **POST_DATA)
self.post.save()
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 posts(request):
"""
add a new post
"""
if check_key(request):
if request.method == 'POST':
Post.save_by_pattern(request)
return HttpResponseRedirect('/yours')
def test_create_or_update(self):
url = 'foo'
Post.create_or_update(url)
self.assertEqual(1, Post.objects.count())
Post.create_or_update(url)
self.assertEqual(1, Post.objects.count())
def test_user_feed_contains_post_by_user(self):
"""A user's post show up on their own feed."""
test_user = self.users[0]
self.client.force_login(test_user)
post = Post(author=test_user, title="TestPost", content="testcontent")
post.save()
response = self.client.get('/')
self.assertContains(response, 'TestPost')
def test_publish_study_post(self):
new_post = Post(category='OOP',
body='unit test post',
author=self.user)
new_post.save()
pk = new_post.id
response = self.client.post(reverse('posts:post-detail', args=(pk, )))
self.assertEqual(response.status_code, 200)
def form_valid(self, form):
"""
Check if the user is allowed to edit the post this way.
The user must be logged in and the post content must be
at most 256 python characters long.
@param form: the form containing the new post
@return `form_valid` if accepted, `form_invalid` if not
"""
if not self.request.user.is_authenticated:
return self.form_invalid(form)
has_img = 'image' in self.request.FILES
if has_img and not Post.image_is_valid(self.request.FILES['image']):
messages.error(self.request, 'Invalid image format')
if not Post.content_is_valid(self.request.POST['content']):
return self.form_invalid(form)
old_post = self.object
parsed_content_old = Post.parse_content(old_post.content)
post = form.save()
parsed_content_new = Post.parse_content(post.content)
mentioned_users = User.objects.filter(username__in=parsed_content_new['mentions'])
for mentionedUser in mentioned_users:
if post.circles_id == -1:
members = mentioned_users
else:
members = post.circles.members.all()
for member in members:
if mentionedUser.username in parsed_content_old['mentions']:
context = {
'content': "%s changed his post you were metioned in" % self.request.user.username,
'link_to_subject': reverse("posts:post", kwargs={'pk': post.pk})
}
else:
context = {
'content': "%s mentioned you in his post" % self.request.user.username,
'link_to_subject': reverse("posts:post", kwargs={'pk': post.pk})
}
send_notifications(mentionedUser, "You were mentioned!",
'users/notification_for_post_email.html', context, post)
circle_pk = int(self.request.POST['circle'])
if circle_pk not in (ME_CIRCLE, PUBLIC_CIRCLE):
circle_owner_id = Circle.objects.get(pk=circle_pk).owner_id
# Is the selected circle not one of the user's circles?
if circle_owner_id != self.request.user.pk:
return self.form_invalid(form)
post = form.save()
if has_img:
post.image = self.request.FILES['image']
circle_pk = int(self.request.POST['circle'])
post.circles = Circle(circle_pk)
return super(PostEditView, self).form_valid(form)
def add(request):
if request.method == 'POST':
user = Follower.objects.get(follower=request.user)
post = request.POST['message']
p = Post(post=post,user=user)
p.save()
return profile(request)
else:
return render_to_response('addpost.html', {'user': request.user}, context_instance=RequestContext(request))
def create(request):
if request.method == "POST":
title = request.POST.get('title')
content = request.POST.get('content')
post = Post(title=title, content=content)
post.save()
return redirect('list')
return render(request, 'posts/create.html')
class PostForUser(TestCase):
databases = ['default', 'messenger_users_db']
def setUp(self):
self.POST_DATA = POST_DATA
self.user = DjangoUser.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.post = Post(user=self.user, **self.POST_DATA)
self.post.save()
self.muser = MUser(last_channel_id=1,
channel_id=1,
backup_key="backz1",
username="******")
self.muser.save()
def test_get_post_for_user(self):
user_data = {'username': "******", 'value': 15, 'premium': False}
response = self.client.get('/posts/getPostForUser', user_data)
def test_get_post_for_user_chan(self):
user_data = {'channel_id': 1, 'value': 15, 'premium': False}
response = self.client.get('/posts/getPostForUser', user_data)
def test_fail_to_get_post_for_user__recoo(self):
user_data = {'channel_id': 1, 'value': 15, 'premium': False}
response = self.client.get('/posts/getRecommendedPostForUser',
user_data)
# self.assertEqual(response.)
def test_fail_post_for_user(self):
user_data = {"asdf": "fasd"}
response = self.client.get('/posts/getPostForUser', user_data)
#TODO: json error
def test_fetch_post(self):
p_id = self.post.id
self.client.post(
f"/messenger_users/actions/user/{self.muser.id}/set/set active_session"
)
response = self.client.get(f'/posts/{p_id}/', {
"username": self.muser.username,
'bot_id': 1
})
eq_(response.status_code, 200)
def test_set_interaction(self):
data = {
"username": self.muser.username,
"bot_id": "1",
"post_id": self.post.id,
"interaction_type": "opened"
}
response = self.client.post('/posts/set_interaction/', data)
def test_comment_post(self):
pass
def mutate(self, info, title, content):
post = Post(title=title, content=content)
post.save()
return CreatePost(
id=post.id,
title=post.title,
content=post.content,
)
def test_post_edit_wrong_user(self):
"""Test post edit wrong user returns 404."""
this_user = self.users[0]
self.client.force_login(this_user)
this_post = Post()
this_post.author = self.users[1]
this_post.save()
response = self.client.post('/posts/' + str(this_post.id) + '/edit')
self.assertTrue(response.status_code == 404)
def test_save_delete(self):
self.testpost2 = Post(user=self.testuser,
url="www.example.com/testimage2.jpeg",
likes=0)
self.assertNotIn(self.testpost2, Post.objects.all())
self.testpost2.save_pic()
self.assertIn(self.testpost2, Post.objects.all())
self.testpost2.delete()
self.assertNotIn(self.testpost2, Post.objects.all())
def test_add_answer_to_question(self):
post = Post(content='Testing',
type='answer',
parent=Question.objects.get(pk=1).post,
created_by=A2AUser.objects.get(pk=1))
post.save()
self.check_num_answers()
self.check_num_questions()
def create(user_id: int, post):
newPost = Post(user_id=user_id,
post=post,
created_at=datetime.now(),
updated_at=datetime.now())
newPost.save()
return True
def test_add_answer_to_question(self):
post = Post(
content='Testing',
type='answer',
parent=Question.objects.get(pk=1).post,
created_by=A2AUser.objects.get(pk=1)
)
post.save()
self.check_num_answers()
self.check_num_questions()
def post(self, request):
form = AddPostForm(request.POST)
if form.is_valid():
data = form.cleaned_data
post = Post()
post.text = data['text']
post.author = request.user
post.save()
return redirect("posts:list")
return render_to_response(self.template_name, {'form': form}, context_instance=RequestContext(request))
def create_post(self, created, raw):
if not created or raw:
return
if self.bucket.public:
post = Post(
composition=self.composition,
creator=self.bucket.owner,
post_type = Post.BUCKET,
content_object=self.bucket)
post.save()
def postid_post(request, post_id):
# get post with id in url
if request.method == "GET":
try:
post = [Post.objects.get(uuid=post_id)]
data = get_posts(post)
except:
return HttpResponse(status=404)
return JsonResponse(data, safe=False)
# update post with id in url
if request.method == "PUT":
received_data = json.loads(request.body)
try:
current_user = User.objects.get(username=request.user.username)
current_profile = Profile.objeects.get(user=current_user)
post = Post.objects.get(uuid=post_id)
title = received_data['title']
description = received_data['description']
content_type = received_data['content-type']
content = received_data['content']
post.title = received_data['title']
post.description = received_data['description']
post.content_type = received_data['content-type']
post.post_text = received_data['content']
post.save()
except:
return HttpResponse(status=404)
return HttpResponse(status=200)
# create post with id in url
if request.method == "POST":
received_data = json.loads(request.body)
try:
current_user = User.objects.get(username=request.user.username)
current_profile = Profile.objects.get(user=current_user)
title = received_data['title']
description = received_data['description']
content_type = received_data['content-type']
content = received_data['content']
date = timezone.now()
new_post = Post(uuid=post_id, author=current_profile, title=title, description=description,
content_type=content_type, post_text=content, date=date)
new_post.save()
except:
return HttpResponse(status=404)
return HttpResponse(status=200)
return HttpResponse(status=405)
def post(request):
msg = request.GET['message']
email = request.user.email
p = Post(message=msg, email=email, pub_date=datetime.datetime.now())
p.save()
'''
sa = request.user.social_auth.get()
token = sa.extra_data['access_token']
graph = facebook.GraphAPI(token)
graph.put_object('me','feed',message=msg)
'''
return HttpResponseRedirect(reverse('posts.views.index'))
def markdown_post():
post = Post(
title='My Post',
content_markdown=inspect.cleandoc("""
Heading
=======
Body text
""")
)
post.save()
yield post
post.delete()
def add_post(request, post_id):
print "in add_post"+str(post_id)
session_id = request.session.get('_auth_user_id', -1)
if(session_id == -1):
return HttpResponse("Must login to view this page")
username = User.objects.get(pk=session_id)
#csrf: Cross Site Request Forgery protection
csrf_request = {}
csrf_request.update(csrf(request))
p = Post(title=request.POST['new_post_title'],
text=request.POST['new_post_text'],
pub_date = timezone.now(),
author = username,
love = 0, hate = 0)
p.save()
#upload choices if poll
localchoice_text = []
localchoice = []
####old approach, works for a fixed amount of choices
print request.POST
print "id = "+post_id
i = 1
choice_i_exists = True
while(choice_i_exists == True):
localchoice_text.append(request.POST.get('choice_%d' % (i), -1))
if(localchoice_text[i-1] == -1):
choice_i_exists = False
elif(localchoice_text[i-1] != ''):
#the following failed when we deleted posts
#localchoice.append(Choice(parent_post = get_object_or_404(Post, pk=post_id),
localchoice.append(Choice(parent_post = p,
text = localchoice_text[i-1],
votes = 0))
localchoice[i-1].save()
i+=1
#upload photo
post_photo = request.POST.get('post_photo', -1)
if(post_photo != ''):
photo_file = File(request.FILES['post_photo'])
#the following failed when we deleted posts
#post_photo = PostPhoto(parent_post =get_object_or_404(Post, pk=post_id),
# image = photo_file)
post_photo = PostPhoto(parent_post = p,
image = photo_file)
post_photo.save()
photo_file.close()
#photo_object = PostPhoto
return HttpResponseRedirect(reverse('posts.views.main'))
def userPost(request):
if not request.user.is_authenticated():
return redirect('Login')
if 'form-post' in request.POST:
text = request.POST['form-post']
if(len(text) > 140):
context = { 'post_error': 'The post needs to be 140 characters or less!' }
return render(request, 'post_form.html', context)
post = Post(post_text=text, post_author=request.user)
post.save()
return redirect('Homepage')
return render(request, 'postForm.html')
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 create_post(request, author_name = None ):
context = RequestContext(request)
u = request.user
a = Author.objects.get(user = u)
form = CreatePostForm()
context_dict = {'author': a, 'success': False, 'form':form }
if request.method == "POST":
access = request.POST['access']
c = request.POST['content']
post_title = request.POST['title']
t = request.POST['content_type']
if t == "text/x-markdown":
import markdown2
c = markdown2.markdown(c)
elif t == "text/plain":
c = c
else:
pass
p = Post(author=a, visibility=access, content=c, title=post_title)
p.content_type = t
p.save()
p.source = "http://%s/posts/%s" % ( request.META['HTTP_HOST'], p.id )
p.origin = p.source
p.save()
return HttpResponseRedirect("/posts/")
return render_to_response('social/createPost.html', context_dict, context)
def create_thread(request):
tuple = get_tags(request.POST['title'])
# Create and save new thread
t = Thread(author=request.POST['author'], title=tuple[0], professor_viewable=(request.POST.has_key('professor_viewable')))
t.save()
for ttag in tuple[1]:
tag = Tag(tag = ttag)
tag.save()
t.tags.add(tag)
t.save()
# Create and save new post
p = Post(author=request.POST['author'], content=request.POST['content'], thread=t)
p.save()
return HttpResponseRedirect(reverse('posts.views.index'))
def test_creating_new_post_and_saving_to_database(self):
#start creating a new post
post = Post()
post.title = "My first post"
post.pub_date = timezone.now()
post.save()
all_posts_in_database = Post.objects.all()
self.assertEquals(len(all_posts_in_database),1)
only_post_in_database = all_posts_in_database[0]
self.assertEquals(only_post_in_database, post)
self.assertEquals(only_post_in_database.title, "My first post")
self.assertEquals(only_post_in_database.pub_date, post.pub_date)
def handle(self, *args, **options):
for url in args:
try:
post = requests.get(url)
if post.status_code == requests.codes.ok:
# Assume that the name of the post is the filename. Works for GitHub.
filename = '.'.join(url.split('/')[-1].split('.')[:-1])
p = Post(body = post.text, title = filename)
p.save()
self.stdout.write("Successfully added new post with url: '%s'" % filename)
else:
raise CommandError('URL not valid.')
except (requests.RequestException, requests.Timeout, requests.ConnectionError) as e:
raise CommandError("A connection error was encountered.")
def test_votepost_create_success(self):
"""
Tests that a new vote can successfully be created
"""
self.client.login(username=self.username,
password=self.password)
# create a new post
post = Post(created_by=self.test_user, text='asdfasdf', title='tests')
post.save()
response = self.client.post(reverse('posts:vote',
args=[post.pk, 'up']),
follow=True)
self.assertTrue('Thank you for voting' in response.content)
vote = PostVote.objects.get(post=post)
self.assertEqual(vote.score, 1)
def postplan_update_view(request,*args,**kwargs):
year=kwargs.get('year')
month=kwargs.get('month')
day=kwargs.get('day')
slug=kwargs.get('slug')
post=Post.objects(slug=slug).first()
if request.method=="POST":
form=PlanForm(request.POST)
if form.is_valid():
ending=form.cleaned_data['ending']
starting=form.cleaned_data['starting']
title=form.cleaned_data['title']
transport=form.cleaned_data['transport']
cost=form.cleaned_data['cost']
content=form.cleaned_data['content']
plan=PostPlan(title=title,transport=transport,cost=cost,content=content)
plan.save()
plan.starting=datetime.combine(date(year=year,month=month,day=day),starting)
plan.ending=datetime.combine(date(year=year,month=month,day=day),ending)
plan.save()
post.postplans.append(plan.number)
post.save()
return HttpResponseRedirect(reverse('plan-create',kwargs={'slug':slug,'year':year,'month':month,'day':day}))
else:
plan=PostPlan.objects(number=kwargs.get('pk')).first()
form=PlanForm()
return render(request,'plans/plan_update.html',{'plan':plan,'form':form})
def user_profile_by_username(request, username):
"""
Renders the view of a profile that was searched by username
@param request: HttpRequestObj - current request.
@param username: string - searched username
@return rendered template with the given context
"""
try:
user = User.objects.get(username=username)
except:
raise Http404("Username does not exist", username)
if request.user.is_authenticated():
posts = Post.visible_posts_for(request.user) \
.filter(author=user.pk) \
.select_related('author', 'repost_original', 'reply_original')
else:
posts = Post.objects.filter(circles=PUBLIC_CIRCLE) \
.filter(author=user.pk) \
.select_related('author', 'repost_original', 'reply_original')
for post in posts:
post.set_post_extra(request)
for reply in post.extra['replies']:
reply.set_post_extra(request)
context = {'posts': posts, 'user': user}
return render(request, 'users/user_profile.html', context)
