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'])