def save(self, owner):
if owner.is_authenticated():
return List.create_new(
first_item_text=self.cleaned_data['text'],
owner=owner)
else:
return List.create_new(first_item_text=self.cleaned_data['text'])
def recommended_lists(user):
# nullity of user checked by caller
weekAgo = datetime.datetime.today() - datetime.timedelta(days=7)
history = BrowseHistory.objects.filter(Q(timestamp__gte=weekAgo), user=user).values('list')
histTopics = TopicTag.objects.filter(Q(list__in=history)).values('topic')
mytopics = InterestTopic.objects.filter(user=user).values('topic')
# first get the 5 most recent lists in the categories, then sort by likes
# sorting all potential lists by count is possible, but could be really slow
relevantlists = TopicTag.objects.filter(Q(topic__in=mytopics) | Q(topic__in=histTopics)).values('list')
ordered_lists = List.objects.filter(Q(id__in=relevantlists)).order_by('-pub_date')
no_own_lists = List.filter_own_lists(ordered_lists, user)
ordered_viewable_lists = List.filter_unviewable_lists(no_own_lists, user)
top = ordered_viewable_lists[:5]
pairs = []
for lst in top:
count = Like.objects.filter(list=lst).count()
pairs.append((lst,count))
pairs = sorted(pairs,key=lambda x: x[1], reverse=True)
mostLiked = [pair[0] for pair in pairs] # remove the counts
return mostLiked
def feed_view(request):
filter_data = request.POST.get('filter', 'following:following')
feed_filter = filter_data.split(':')[0]
feed_filter_data = filter_data.split(':')[1]
lists = {}
circles = Circle.objects.filter(user=request.user)
ineterest_topics = InterestTopic.TOPIC_CHOICES
recommendations = recommended_lists(request.user)
reblog_listids_ownerids = []
if feed_filter == 'interests':
topics = InterestTopic.objects.filter(user=request.user).values('topic')
lists_in_topics = TopicTag.objects.filter(topic__in=topics).values('list')
lists = List.objects.filter(id__in=lists_in_topics).order_by('-pub_date')
elif feed_filter == 'topic':
lists_in_topics = TopicTag.objects.filter(topic=feed_filter_data).values('list')
lists = List.objects.filter(id__in=lists_in_topics).order_by('-pub_date')
elif feed_filter == 'following':
following = Follow.objects.following(request.user)
reblog_listids_ownerids = Reblog.objects.filter(owner__in=following).values_list('list', 'owner')
following_reblogs = [reblog[0] for reblog in reblog_listids_ownerids]
lists = List.objects.filter(Q(owner__in=following)|Q(id__in=following_reblogs)).order_by('-pub_date')
elif feed_filter == 'circle':
circle = Circle.objects.get(user=request.user, circleName=feed_filter_data)
circle_relation = CircleRelation.objects.filter(circle=circle).values('followee')
in_circle = User.objects.filter(id__in=circle_relation)
reblog_listids_ownerids = Reblog.objects.filter(owner__in=in_circle).values_list('list', 'owner')
circle_reblogs = [reblog[0] for reblog in reblog_listids_ownerids]
lists = List.objects.filter(Q(owner__in=in_circle)|Q(id__in=circle_reblogs)).order_by('-pub_date')
else:
topics = InterestTopic.objects.filter(user=request.user).values('topic')
lists_in_topics = TopicTag.objects.filter(topic__in=topics).values('list')
following = Follow.objects.following(request.user)
lists = List.objects.filter(Q(id__in=lists_in_topics)|Q(owner__in=following))
reblog_listids_to_ownerids = dict(reblog_listids_ownerids)
lists = List.filter_unviewable_lists(lists, request.user)
lists = List.filter_own_lists(lists, request.user)
feed = []
for l in lists:
is_reblog = False
reblogged_by = ''
if l.id in reblog_listids_to_ownerids:
is_reblog = True
reblogged_by = User.objects.get(id=reblog_listids_to_ownerids[l.id])
feed.append({
'is_reblog': is_reblog,
'reblogged_by': reblogged_by,
'list': l
})
return render(request, 'feed.html', {'feed': feed,
'circles': circles,
'interest_topics': ineterest_topics,
'default_filter_select': filter_data,
'recommendations':recommendations})
def test_checks_user_added_to_share_list(self):
user = User.objects.create(email='*****@*****.**')
list_ = List.create_new("First item", owner=user)
response = self.client.post(
'/lists/%d/share' % (list_.id,),
data={'email': '*****@*****.**'}
)
self.assertIn(user, list_.shared_with.all())
def list(request):
"""Returns the lists of the user."""
#TODO: anonymous user
# Get the lists to retrieve
l = request.GET.get('l', None)
if l:
lists = [li.to_obj() for li in List.get_lists_for_user(request.user) and li.id in l]
else:
# Get the board to retrieve
b = request.GET.get('b', None)
lists = [l.to_obj() for l in List.get_lists_for_user(request.user, b)]
return HttpResponse(content_type='application/json', content=simplejson.dumps(lists))
def test_create_new_optionally_saves_owner(self):
'''тест: create_new необязательно сохраняет владельца'''
user = User.objects.create()
List.create_new(first_item_text='new item text', owner=user)
new_list = List.objects.first()
self.assertEqual(new_list.owner, user)
def test_list_owner_is_optional(self):
List().full_clean() # should not raise
def test_create_new_optionally_saves_owner(self):
user = User.objects.create()
List.create_new(first_item_text='new item text', owner=user)
new_list = List.objects.first()
self.assertEqual(new_list.owner, user)
def test_list_owner_is_optional(self):
List().full_clean()
def save(self, owner):
if owner.is_authenticated:
return List.create_new(first_item_text=self.cleaned_data['text'], owner=owner)
else:
return List.create_new(first_item_text=self.cleaned_data['text'])
def test_list_has_shared_with_method(self):
list_ = List.create_new('new item')
self.assertTrue(hasattr(list_, 'shared_with'))
def test_create_returns_new_list_object(self):
returned = List.create_new(first_item_text="new item text")
new_list = List.objects.first()
self.assertEqual(new_list.get_absolute_url(), returned)
def test_checks_user_added_to_share_list(self):
user = User.objects.create(email='*****@*****.**')
list_ = List.create_new("First item", owner=user)
response = self.client.post('/lists/%d/share' % (list_.id, ),
data={'email': '*****@*****.**'})
self.assertIn(user, list_.shared_with.all())
def test_create_new_returns_new_list_object(self):
list_ = List.create_new(first_item_text="new item text")
assert list_ == List.objects.first()
def save(self, owner, commit=True):
if owner.is_authenticated:
return List.create_new(first_item_text=self.instance.text,
owner=owner)
else:
return List.create_new(first_item_text=self.instance.text)
def test_create_new_creates_list_and_first_item(self):
List.create_new(first_item_text='new item text')
new_item = Item.objects.first()
assert new_item.text == 'new item text'
new_list = List.objects.first()
assert new_item.list == new_list
def test_list_owner_is_optional():
List(owner=User()) # should not throw
def test_lists_can_have_owners():
List(owner=User()) # should not throw
def test_shared_with_will_contain_user_if_email_in_queryset(self):
user = User.objects.create(email='*****@*****.**')
list_ = List.create_new('new item')
list_.shared_with.add(user)
sharee = list_.shared_with.all().get(email=user.email)
self.assertEqual(sharee, user)
def test_create_returns_new_list_object(self):
returned = List.create_new(first_item_text='new')
new_list = List.objects.first()
assert returned == new_list
def test_create_returns_new_list_object(self):
created_list = List.create_new(first_item_text='new item')
self.assertEqual(List.objects.first(), created_list)
def test_create_new_optionally_saves_owner(self) :
user = User.objects.create()
List.create_new(first_item_text = 'new item text', owner = user)
new_list = List.objects.first()
self.assertEqual(new_list.owner, user)
def test_lists_dont_need_owner(self):
List().full_clean()
def test_create_returns_new_list_object(self):
list_ = List.create_new(first_item_text='item text')
self.assertEqual(list_, List.objects.first())
def save(self, owner): # pylint: disable=arguments-differ
if owner.is_authenticated:
return List.create_new(first_item_text=self.cleaned_data['text'],
owner=owner)
else:
return List.create_new(first_item_text=self.cleaned_data['text'])
def get(self, request, username='', sortmethod=''):
try:
userid = User.objects.get(username=username)
except User.DoesNotExist:
# TODO: 404 Page
return HttpResponse('User Not Found')
request_profile = Profile.objects.get(user_id=userid)
not_friends = doesnt_follow = not_self = active_request = False
order_by = '-pub_date'
if sortmethod=='ascending':
order_by = 'pub_date'
elif sortmethod=='descending':
order_by = '-pub_date'
elif sortmethod=='alphabetical':
order_by = 'title'
elif sortmethod=='ralphabetical':
order_by = '-title'
userLists = List.objects.filter(owner=userid).order_by(order_by)
userLists = List.filter_unviewable_lists(userLists, request.user)
favorite_list_ids = Favorite.objects.filter(owner=userid).values_list('list', flat=True)
userFavorites = List.objects.filter(id__in=favorite_list_ids).order_by(order_by)
userFavorites = List.filter_unviewable_lists(userFavorites, request.user)
# the following is a kludge to associate a reblog date
# with the its corresponding list object it's pointing
# to in 'order_by' order
reblog_list = Reblog.objects.filter(owner=userid).values_list('list', 'reblog_date')
reblog_list_to_reblog_date = dict(reblog_list)
reblog_list_ids = [reblog[0] for reblog in reblog_list]
userReblogListObjects = List.objects.filter(id__in=reblog_list_ids).order_by(order_by)
userReblogListObjects = List.filter_unviewable_lists(userReblogListObjects, request.user)
userReblogs = []
for l in userReblogListObjects:
userReblogs.append({
'list': l,
'reblog_date': reblog_list_to_reblog_date[l.id],
})
topicList = InterestTopic.objects.filter(user=userid)
followers = Follow.objects.followers(request_profile.user)
if request.user.is_authenticated():
myfriends = Friend.objects.friends(request.user)
following = Follow.objects.following(request.user)
not_friends = not Friend.objects.are_friends(request.user, request_profile.user)
doesnt_follow = not Follow.objects.follows(request.user,request_profile.user)
not_self = request.user.username != username
# Generate message history between logged in user and the user
# whos profile is being viewed
conversation = Message.objects.filter(to_user=request_profile.user, from_user=request.user, type='GN').order_by('send_date') \
| Message.objects.filter(to_user=request.user, from_user=request_profile.user, type='GN').order_by('send_date')
# if you've already friended the person who's profile you're viewing, don't show the button
frnd_rqsts = Friend.objects.unread_requests(request_profile.user)
active_request = request.user in list(map(lambda req: req.from_user, frnd_rqsts))
circles = Circle.objects.filter(user=request.user).values('circleName')
return render(request, 'profiles/pubprofile.html', {'profile':request_profile,
'not_friends': not_friends,
'doesnt_follow':doesnt_follow,
'not_self': not_self,
'topicList': topicList,
'myfriends': myfriends,
'followers': followers,
'following': following,
'userLists': userLists,
'userFavorites': userFavorites,
'userReblogs': userReblogs,
'active_request':active_request,
'conversation': conversation})
def test_is_an_ItemForm(self):
self.assertIsInstance(ExistingListItemForm(for_list=List()), ItemForm)
def test_list_dont_have_to_have_owner(self):
List().full_clean()
def test_lists_can_have_owners(self):
"""тест: списки могут иметь владельца"""
List(owner=User()) # не должно поднять исключение
def test_list_owner_is_optional(self):
"""тест: владелец списка необязательный"""
List().full_clean() # не должно поднять исключение
def test_create_returns_new_list_object(self):
"""тест: create возвращает новый объект списка"""
returned = List.create_new(first_item_text='new item text')
new_list = List.objects.first()
self.assertEqual(returned, new_list)
def test_lists_can_have_owners(self):
List(owner=User())
def test_lists_can_have_owners(self):
List(owner=User()) # não deve gerar erro
def test_create_returns_new_list_object(self):
returned = List.create_new(first_item_text='new item text')
new_list = List.objects.first()
self.assertEqual(returned, new_list)
def test_list_owner_is_optional(self):
List().full_clean() # não deve gerar erro # não deve gerar erro
def test_lists_can_have_owners(self):
List(owner=User()) # should not raise
def test_shared_with_add(self):
user1 = User.objects.create(email='*****@*****.**')
user2 = User.objects.create(email='*****@*****.**')
list_ = List.create_new(first_item_text='new item text', owner=user1)
list_.shared_with.add('*****@*****.**')
self.assertIn(user2, list_.shared_with.all())
def test_create_new_creates_list_and_first_item(self):
List.create_new(first_item_text='new item text')
new_item = Item.objects.first()
self.assertEqual(new_item.text, 'new item text')
new_list = List.objects.first()
self.assertEqual(new_item.list, new_list)
def test_lists_can_have_owners(self):
self.assertTrue(List(owner=User())) # should not raise exception
def test_list_name_is_first_item_text(self):
list_ = List.create_new(first_item_text='new item text')
self.assertEqual(list_.name, 'new item text')
def test_list_owner_is_optional(self):
self.assertIsNone(List().full_clean()) # should not raise exception
def test_create_new_optionally_saves_owner(self):
user = User.objects.create(email="*****@*****.**")
List.create_new(first_item_text="new item text", owner=user)
self.assertEqual(List.objects.first().owner, user)
def test_shared_with_add_shares_list_with_another_user(self):
user = User.objects.create(email='*****@*****.**')
list_ = List.create_new(first_item_text='new item text', owner=user)
another_user = User.objects.create(email='*****@*****.**')
list_.shared_with.add(another_user.email)
self.assertIn(another_user, list_.shared_with.all())
def test_create_new_creates_list_and_first_item(self) :
List.create_new(first_item_text = 'new item text')
new_item = Item.objects.first()
self.assertEqual(new_item.text, 'new item text')
new_list = List.objects.first()
self.assertEqual(new_item.list, new_list)
def test_set_list_owner_when_user_is_authenticated(self):
user = User.objects.create(email="*****@*****.**")
List.create_new(first_item_text='item 1 text', owner=user)
new_list = List.objects.first()
self.assertEqual(new_list.owner, user)
def test_create_returns_new_list_object(self) :
returned = List.create_new(first_item_text = 'new item text')
new_list = List.objects.first()
self.assertEqual(returned, new_list)
def save(self, owner):
if hasattr(owner, 'email'):
return List.create_new(first_item_text=self.cleaned_data['text'], owner=owner)
else:
return List.create_new(first_item_text=self.cleaned_data['text'])
