def save(self, *args, **kwargs):
# first must save the object before we can use the many_to_many field
super(Post, self).save(*args, **kwargs)
link_hashtags_to_model(self.text, self, self.user)
notify_on_mention(self.text, self, self.user)
# generate thumbnail picture version
if self.pictures is not None:
for p in self.pictures.all():
p.create_thumbnail()
def parse_fields_looking_for_hashtags(sender,
instance,
hashtagged_field_list=None,
**kwargs):
"""
A function handler to work with ``hashtagged_model_was_saved`` signal. This
handler parse a list of model fields looking for hashtags to be
linked/related with the instance in question.
Usage example::
# You need connect ``parse_fields_looking_for_hashtags`` on
# ``hashtagged_model_was_saved`` only one time.
from hashtags.signals import (hashtagged_model_was_saved,
parse_fields_looking_for_hashtags)
hashtagged_model_was_saved.connect(parse_fields_looking_for_hashtags)
Connecting your models that you want track hashtags (FlatPage example)::
from django.contrib.flatpages.models import FlatPage
from django.db.models.signals import post_save
# connect hashtagged_model_was_saved signal to post_save
def post_save_handler(sender, instance, **kwargs):
hashtagged_model_was_saved.send(sender=sender, instance=instance,
# put the hashtagged fields of your app here
hashtagged_field_list=['title', 'content']
)
post_save.connect(post_save_handler, sender=FlatPage)
Alternatively you can set ``hashtagged_field_list`` in your model as a
class attribute, then your ``post_save_handler`` can be:
def post_save_handler(sender, instance, **kwargs):
hashtagged_model_was_saved.send(sender=sender, instance=instance)
"""
if not hashtagged_field_list:
try:
hashtagged_field_list = sender._meta.hashtagged_field_list
except AttributeError:
return
text = ''
for field in hashtagged_field_list:
text += instance.__getattribute__(field) + '\n'
link_hashtags_to_model(text, instance)
print 'Parsing hashtags\n'
def parse_fields_looking_for_hashtags(sender, instance, hashtagged_field_list=None,
**kwargs):
"""
A function handler to work with ``hashtagged_model_was_saved`` signal. This
handler parse a list of model fields looking for hashtags to be
linked/related with the instance in question.
Usage example::
# You need connect ``parse_fields_looking_for_hashtags`` on
# ``hashtagged_model_was_saved`` only one time.
from hashtags.signals import (hashtagged_model_was_saved,
parse_fields_looking_for_hashtags)
hashtagged_model_was_saved.connect(parse_fields_looking_for_hashtags)
Connecting your models that you want track hashtags (FlatPage example)::
from django.contrib.flatpages.models import FlatPage
from django.db.models.signals import post_save
# connect hashtagged_model_was_saved signal to post_save
def post_save_handler(sender, instance, **kwargs):
hashtagged_model_was_saved.send(sender=sender, instance=instance,
# put the hashtagged fields of your app here
hashtagged_field_list=['title', 'content']
)
post_save.connect(post_save_handler, sender=FlatPage)
Alternatively you can set ``hashtagged_field_list`` in your model as a
class attribute, then your ``post_save_handler`` can be:
def post_save_handler(sender, instance, **kwargs):
hashtagged_model_was_saved.send(sender=sender, instance=instance)
"""
if not hashtagged_field_list:
try:
hashtagged_field_list = sender._meta.hashtagged_field_list
except AttributeError:
return
text = ''
for field in hashtagged_field_list:
text += instance.__getattribute__(field) + '\n'
link_hashtags_to_model(text, instance)
print 'Parsing hashtags\n'
def profile(request,
username='',
template='account/profile.html',
extra_context=None):
user = None
if username == "":
user = User.objects.get(username=request.user.username)
else:
user = User.objects.get(username=username)
if request.method == 'POST':
form = PostForm(
data=request.POST,
files=request.FILES,
)
if form.is_valid():
post = form.save(commit=False)
# Check for image
picture = request.POST.get('picture')
if picture != '':
picture = UploadedFile.objects.get(pk=int(picture, 0))
post.picture = picture
post.pub_date = timezone.now()
post.user = request.user
post.save()
try:
UploadedFile.objects.get(pk=int(picture, 0)).delete()
except:
pass
link_hashtags_to_model(post.text, post, user)
notify_on_mention(post.text, post, user)
return redirect('./')
context = {
'posts':
Post.objects.filter(user=user).order_by('-pub_date').distinct()[:500],
'form':
PostForm(),
'user_sub':
user,
}
if extra_context is not None:
context.update(extra_context)
return render(request, template, context)
def urlize_and_track_hashtags(value, object_to_track):
"""
Works like ``urlize_hashtags`` but you can pass a object parameter to
link/relate hashtags on text with the object in question.
Usage example::
{{ value|urlize_and_track_hashtags:object_to_track }}
Real world example::
{{ flatpage.content|urlize_and_track_hashtags:flatpage }}
**Important**: ``urlize_and_track_hashtags`` doesn't works properly if your
object has two fields with hashtags to be tracked. Use the signals below if
you want this feature or if you want hashtags updated on ``post_save``
signal instead on template rendering.
"""
link_hashtags_to_model(value, object_to_track)
return mark_safe(urlize_hashtags(value))
def urlize_and_track_hashtags(value, object_to_track):
"""
Works like ``urlize_hashtags`` but you can pass a object parameter to
link/relate hashtags on text with the object in question.
Usage example::
{{ value|urlize_and_track_hashtags:object_to_track }}
Real world example::
{{ flatpage.content|urlize_and_track_hashtags:flatpage }}
**Important**: ``urlize_and_track_hashtags`` doesn't works property if your
object has two fields with hashtags to be tracked. Use the signals below if
you want this feature or if you want hashtags updated on ``post_save``
signal instead on template rendering.
"""
link_hashtags_to_model(value, object_to_track)
return mark_safe(urlize_hashtags(value))
def create(self, request):
"""
Creates a new comment
POST data:
- object_pk
- picture (UploadedFile id)
- content_type
- content_type_id
- target_object
- security_hash
- timestamp
- comment
"""
user = User.objects.get(username=request.user.username)
post = Post.objects.get(id=request.data.get('object_pk'))
comment = None
if request.method == 'POST':
serializer = CommentSerializer(data=request.data)
if serializer.is_valid():
comment = serializer.save(site_id=1, content_object=post, user=request.user)
# Check for image
picture = request.data.get('picture', '')
if picture != '':
picture = UploadedFile.objects.get(pk=picture)
comment.picture = picture
comment.timestamp = timezone.now()
comment.save()
link_hashtags_to_model(comment.comment, comment, user)
notify_on_mention(comment.comment, comment, user)
return Response(
CommentSerializer(comment, context={'request': request}).data,
status.HTTP_201_CREATED
)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
"""
Creates a new post
POST data:
- text
- pictures
"""
user = request.user
post = None
# return Response(json.dumps(request.FILES))
my_data = {
'text': request.data.get('text', '')
}
# my_data.append(request.data['filename'])
# my_data.append(request.data['object_content_type'])
if request.method == 'POST':
serializer = PostSerializer(
data=my_data
)
if serializer.is_valid():
post = serializer.save(user=request.user, pub_date=timezone.now())
UploadedFile.objects.upload(request.user, request.data, post)
link_hashtags_to_model(post.text, post, user)
notify_on_mention(post.text, post, user)
return Response(
PostSerializer(post, context={'request': request}).data,
status.HTTP_201_CREATED
)
return Response(
serializer.errors,
status=status.HTTP_400_BAD_REQUEST
)
