Example #1
0
 def test_activity_create(self):
     self.authenticate()
     poster = open(os.path.join(settings.BASE_DIR, 'media', 'tests', 'test.png'))
     response = self.client.post(reverse('activity:create'), data=dict(
         name='test activity',
         description='description',
         max_attend=10,
         start_at=time_to_string(timezone.now() + datetime.timedelta(days=10)),
         end_at=time_to_string(timezone.now() + datetime.timedelta(days=12)),
         location=json.dumps(dict(lat=30, lon=120, description='test location')),
         poster=poster
     ))
     response_data = json.loads(response.content)
     self.assertTrue(response_data['success'])
Example #2
0
 def dict_description(self):
     return dict(
         car=self.car.dict_description(),
         signature=self.signature,
         identified=self.identified,
         identified_date=time_to_string(self.created_at)
     )
Example #3
0
 def test_status_list_access_with_avatar_club(self):
     """ 在setUp创建的数据集里面,没有引入签名俱乐部,这个测试给默认用户加入签名俱乐部
     """
     # 首先创建一个俱乐部
     club = Club.objects.create(name='test club', host=self.default_user,
                                logo=os.path.join(settings.MEDIA_ROOT, 'tests', 'test.png'),
                                description='test club')
     # 将这个俱乐部设置为default_user的avatar_club
     self.default_user.profile.avatar_club = club
     self.default_user.profile.save()
     # 然后进行访问
     self.authenticate()
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertEqual(len(response_data["data"]), 1)
     status = self.default_status
     status_dict = status.dict_description()
     status_dict["comment_num"] = 0
     status_dict["like_num"] = 0
     status_dict["liked"] = False
     self.assertEqual(response_data["data"][0], status_dict)
Example #4
0
 def dict_description(self, show_liked=False, user=None):
     """ 获取字典形式的数据描述,字典形式的注释参见view.py中的status_list的注释
      但是这里没有生成comment_num和like_num这两个字段
     """
     result = dict(
         statusID=self.id,
         images=self.images,
         content=self.content,
         user=self.user.dict_description(detail=True),
         created_at=time_to_string(self.created_at),
     )
     if self.car is not None:
         try:
             own = SportCarOwnership.objects.get(user=self.user, car=self.car)
             result["car"] = own.dict_description()
         except ObjectDoesNotExist:
             result["car"] = self.car.dict_description()
     if self.recent_like_user:
         result["recent_like_user"] = self.recent_like_user.nick_name
     if self.location is not None:
         result["location"] = self.location.dict_description()
     if hasattr(self, "comment_num"):
         result["comment_num"] = self.comment_num
     if hasattr(self, "like_num"):
         result["like_num"] = self.like_num
     if show_liked:
         result["liked"] = StatusLikeThrough.objects.filter(status=self, user=user).exists()
     return result
Example #5
0
 def dict_description(self):
     return dict(
         inviter=self.inviter.dict_description(),
         target=self.target.dict_description(),
         activity=self.target.dict_description(),
         created_at=time_to_string(self.created_at),
         responsed=self.responsed,
         agree=self.agree
     )
Example #6
0
 def test_activity_create_with_club_limit(self):
     self.authenticate()
     club = Club.objects.create(name='test_club', host=self.user, logo='meida/tests/test.png', description='test')
     poster = open(os.path.join(settings.BASE_DIR, 'media', 'tests', 'test.png'))
     response = self.client.post(reverse('activity:create'), data=dict(
         name='test activity',
         description='description',
         max_attend=10,
         start_at=time_to_string(timezone.now() + datetime.timedelta(days=10)),
         end_at=time_to_string(timezone.now() + datetime.timedelta(days=12)),
         location=json.dumps(dict(lat=30, lon=120, description='test location')),
         club_limit=club.id,
         poster=poster
     ))
     response_data = json.loads(response.content)
     self.assertTrue(response_data['success'])
     act = Activity.objects.order_by('-created_at').first()
     self.assertEqual(act.allowed_club.id, club.id)
Example #7
0
 def dict_description(self):
     result = dict(
         id=self.id,
         cover=self.cover.url,
         created_at=time_to_string(self.created_at),
         content=self.content,
         title=self.title,
         is_video=self.is_video,
     )
     return result
Example #8
0
 def dict_description_without_user(self):
     result = dict(
         actID=self.id,
         name=self.name,
         description=self.description,
         max_attend=self.max_attend,
         start_at=time_to_string(self.start_at),
         end_at=time_to_string(self.end_at) if not self.closed \
             else time_to_string(self.closed_at),
         poster=self.poster.url,
         location=self.location.dict_description(),
         created_at=time_to_string(self.created_at),
         authed_user_only=self.authed_user_only
     )
     if self.recent_like_user:
         result["recent_like_user"] = self.recent_like_user.nick_name
     if self.allowed_club is not None:
         result.update(allowed_club=self.allowed_club.dict_description())
     return result
Example #9
0
 def test_news_list_latest(self):
     self.authenticate()
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:news_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertTrue(response_data["success"])
     self.assertEqual(len(response_data["news"]), 1)
Example #10
0
 def dict_description(self):
     result = dict(
         user=self.user.dict_description(),
         created_at=time_to_string(self.created_at),
         image=self.image.url if self.image else None,
         content=self.content,
         commentID=self.id,
     )
     if self.response_to is not None:
         result.update(response_to=self.response_to.dict_description())
     return result
Example #11
0
 def test_news_without_login(self):
     self.create_comments(20)
     comment = self.create_comments(num=1)[0]
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:comments_list', args=(self.news1.id, )), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(response_data, dict(success=False, message='You need to login first', code='1402'))
Example #12
0
 def test_news_get_comments_with_limit(self):
     self.authenticate()
     self.create_comments(20)
     comment = self.create_comments(num=1)[0]
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:comments_list', args=(self.news1.id, )), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(len(response_data['comments']), 10)
Example #13
0
 def test_status_comments_list_with_limit(self):
     self.authenticate()
     another_user = get_user_model().objects.create(username='******')
     self.create_comments(num=20, user=another_user)
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_comments', args=(self.default_status.id, )), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(len(response_data['comments']), 10)
Example #14
0
 def test_news_list_with_invalid_operation_type(self):
     self.authenticate()
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:news_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='invalid',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(response_data, dict(
         success=False, code='3400', message='invalid op_type'
     ))
Example #15
0
 def test_activity_create_with_inform_of(self):
     self.authenticate()
     users = []
     user_num = random.randint(1, 20)
     for i in range(user_num):
         users.append(get_user_model().objects.create(username='******' % i))
     poster = open(os.path.join(settings.BASE_DIR, 'media', 'tests', 'test.png'))
     response = self.client.post(reverse('activity:create'), data=dict(
         name='test activity',
         description='description',
         max_attend=10,
         start_at=time_to_string(timezone.now() + datetime.timedelta(days=10)),
         end_at=time_to_string(timezone.now() + datetime.timedelta(days=12)),
         location=json.dumps(dict(lat=30, lon=120, description='test location')),
         inform_of=json.dumps(map(lambda x: x.id, users)),
         poster=poster
     ))
     response_data = json.loads(response.content)
     self.assertTrue(response_data['success'])
     act = Activity.objects.order_by('-created_at').first()
     self.assertEqual(len(act.inform_of.all()), user_num)
Example #16
0
 def test_news_get_comments_more(self):
     self.authenticate()
     comment = self.create_comments(num=1)[0]
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:comments_list', args=(self.news1.id, )), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertTrue(response_data["success"])
Example #17
0
 def dict_description_simple(self):
     """ 相比之下,这个函数返回的字典不包含activity的信息
     """
     result = dict(
         user=self.user.dict_description(),
         created_at=time_to_string(self.created_at),
         image=self.image.url if self.image else None,
         content=self.content,
         commentID=self.id
     )
     if self.response_to is not None:
         result.update(response_to=self.response_to.dict_description_simple())
     return result
Example #18
0
 def test_news_list_limit(self):
     new_news = self.news1
     for _ in range(20):
         new_news.id = None
         new_news.save()
     self.authenticate()
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('news:news_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(len(response_data['news']), 10)
Example #19
0
 def dict_description(self):
     result = dict(
         ssid=self.id,
         unread_num=self.unread_num,
         recent_chat=self.recent_chat,
         always_on_top=self.always_on_top,
         no_disturbing=self.no_disturbing,
         created_at=time_to_string(self.created_at),
         updated_at=time_to_string(self.updated_at),
     )
     if self.user is not None:
         user_json = self.user.dict_description()
         user_json.update(note_name=ChatRemarkNameStorage.get_nick_name(self.host, self.user))
         result.update(
             user=user_json,
             entity_type="user"
         )
     if self.club is not None:
         result.update(
             club=self.club.dict_description(show_members_num=True),
             entity_type='club'
         )
     return result
Example #20
0
 def test_stauts_list_access_latest(self):
     """ 测试状态列表首页获取是否正常
     """
     self.authenticate()
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertTrue(response_data["success"])
     self.assertEqual(len(response_data["data"]), 1)
Example #21
0
 def test_activity_check_detail_with_appliers(self):
     another_user = get_user_model().objects.create(username='******')
     join = ActivityJoin.objects.create(user=another_user, activity=self.activity)
     self.authenticate()
     response = self.client.get(reverse('activity:detail', args=(self.activity.id, )))
     response_data = json.loads(response.content)
     setattr(self.activity, "like_num", 0)
     setattr(self.activity, "comment_num", 0)
     act_dict = self.activity.dict_description_with_aggregation(with_user_info=True)
     act_dict.update(dict(apply_list=[dict(
         approved=join.approved,
         like_at=time_to_string(join.created_at),
         user=join.user.profile.complete_dict_description()
     )], liked=False))
     self.maxDiff = None
     self.assertEqual(response_data['data'], act_dict)
Example #22
0
 def test_status_comment_list_latest(self):
     self.authenticate()
     another_user = get_user_model().objects.create(username='******')
     comment = self.create_comments(num=1, user=another_user)
     request_time = timezone.now() - datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_comments', args=(self.default_status.id, )), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='latest',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertEqual(
         response_data,
         dict(
             success=True,
             comments=[comment.dict_description()]
         )
     )
Example #23
0
def activity_detail(request, act_id):
    """ 活动详情, 注意这里只显示活动相关的内容, 评论列表从单独的接口获取
     返回的信息和创建时提交的信息基本一致,但是不用显示inform_of, 回复的club_limit要显示这个俱乐部的标识和id,
     另外要返回报名参加者的列表
    """
    try:
        act = Activity.objects.get(id=act_id)
    except ObjectDoesNotExist:
        return JsonResponse(dict(success=False, code='7000', message='Activity not found.'))

    data = act.dict_description_with_aggregation(with_user_info=True)
    apply_list = ActivityJoin.objects.select_related('user__avatar_club').filter(activity=act, approved=True)
    data['apply_list'] = map(lambda x: dict(approved=x.approved,
                                            like_at=time_to_string(x.created_at),
                                            user=x.user.dict_description()),
                             apply_list)
    data["liked"] = act.liked_by.filter(id=request.user.id).exists()
    data["applied"] = ActivityJoin.objects.filter(user=request.user, activity=act, approved=True).exists()
    return JsonResponse(dict(success=True, data=data))
Example #24
0
 def test_status_list_access_more(self):
     """ 测试状态列表首页获取是否正常
     """
     self.authenticate()
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertTrue(response_data["success"])
     self.assertEqual(len(response_data["data"]), 1)
     status = self.default_status
     status_dict = status.dict_description()
     status_dict["comment_num"] = 0
     status_dict["like_num"] = 0
     status_dict["liked"] = False
     self.assertEqual(response_data["data"][0], status_dict)
Example #25
0
 def dict_description(self, host):
     """
     :param host:
     :return:
     """
     if isinstance(host, ChatEntity):
         host = host.user
     data = self.sender.dict_description()
     data.update(note_name=ChatRemarkNameStorage.get_nick_name(host, self.sender))
     result = dict(
         chatID=self.id,
         sender=data,
         chat_type=self.chat_type,
         message_type=self.message_type,
         created_at=time_to_string(self.created_at)
     )
     if self.image is not None and self.image:
         result.update(
             image=self.image.url,
             image_width=self.image.width,
             image_height=self.image.height
         )
     if self.text is not None:
         result.update(text=self.text)
     if self.audio is not None and self.audio:
         result.update(
             audio=self.audio.url,
             audio_wave_data=self.audio_wave_data,
             audio_length=self.audio_length
         )
     if self.target_user is not None:
         data = self.target_user.dict_description()
         data.update(note_name=ChatRemarkNameStorage.get_nick_name(host, self.target_user))
         result.update(
             target_user=data
         )
     if self.target_club is not None:
         result.update(
             target_club=self.target_club.dict_description()
         )
     return result
Example #26
0
    def dict_description(self):
        """ 获取字典表示形式
        """
        result = dict(
            notification_id=self.id,
            target=self.target.dict_description(),
            message_type=self.message_type,
            read=self.read,
            created_at=time_to_string(self.created_at),
            flag=self.flag,
            checked=self.checked
        )

        def set_related(attribute_name):
            attribute = getattr(self, attribute_name)
            if attribute is not None:
                if isinstance(attribute, Club):
                    result[attribute_name] = attribute.dict_description(
                        show_attended=True, target_user=self.target
                    )
                else:
                    result[attribute_name] = attribute.dict_description()
            # if attribute is not None:
            #     if attribute_name == "related_user":
            #         result[attribute_name] = attribute.profile.simple_dict_description()
            #     else:

        set_related("related_user")
        set_related("related_act")
        set_related("related_act_invite")
        set_related("related_act_join")
        set_related("related_act_comment")
        set_related("related_club")
        set_related("related_status")
        set_related("related_status_comment")
        set_related("related_news")
        set_related("related_news_comment")
        set_related("related_own")

        return result
Example #27
0
 def test_status_list_like_num(self):
     """ 测试点赞人数是否正确
     """
     random_like_num = random.randint(0, 20)
     for i in range(random_like_num):
         user = get_user_model().objects.create(username=str(i))
         StatusLikeThrough.objects.create(user=user, status=self.default_status)
     self.authenticate()
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.maxDiff = None
     self.assertEqual(len(response_data["data"]), 1)
     status = self.default_status
     status_dict = status.dict_description()
     status_dict["comment_num"] = 0
     status_dict["like_num"] = random_like_num
     status_dict["liked"] = False
     self.assertEqual(response_data["data"][0], status_dict)
Example #28
0
 def test_status_list_comment_num(self):
     """ 测试返回的评论数量是否正确
     """
     random_comment_num = random.randint(1, 20)
     for _ in range(random_comment_num):
         StatusComment.objects.create(status=self.default_status,
                                      user=self.guest_user,
                                      image='/media/tests/test.png',
                                      content='content')
     self.authenticate()
     request_time = timezone.now() + datetime.timedelta(seconds=60)
     response = self.client.get(reverse('status:status_list'), data=dict(
         date_threshold=time_to_string(request_time),
         op_type='more',
         limit='10'
     ))
     response_data = json.loads(response.content)
     self.assertEqual(len(response_data["data"]), 1)
     status = self.default_status
     status_dict = status.dict_description()
     status_dict["comment_num"] = random_comment_num
     status_dict["like_num"] = 0
     status_dict["liked"] = False
     self.assertEqual(response_data["data"][0], status_dict)
Example #29
0
 def result_format(like):
     result = like.user.dict_description()
     result["like_at"] = time_to_string(like.like_at)
     return result