def get_notes(request, entity_id, template='entity/entity_note_list.html'): if request.method == 'GET': _user_context = User(request.user.id).read() _note_id_list = Note.find(entity_id=entity_id, sort_by='poke') _note_list = [] for _note_id in _note_id_list: _note = Note(_note_id) _note_context = _note.read() _creator_id = _note_context['creator_id'] _creator_context = User(_creator_id).read() if not _note_context['is_selected']: _note_list.append( { 'note_context' : _note_context, 'creator_context' : _creator_context, 'user_context' : _user_context } ) # TODO 需要改进 返回json 参照 main.selection return render_to_response( template, { 'note_list' : _note_list }, context_instance = RequestContext(request) )
def wechat_entity_detail(request, entity_id, template='wap/detail.html'): _start_at = datetime.datetime.now() if request.user.is_authenticated(): _request_user_id = request.user.id else: _request_user_id = None _entity_id = int(entity_id) _entity_context = Entity(_entity_id).read() _is_soldout = True _taobao_id = None for _item_id in Item.find(entity_id=_entity_id): _item_context = Item(_item_id).read() _taobao_id = _item_context['taobao_id'] if not _item_context['soldout']: _is_soldout = False break _note_list = [] for _note_id in Note.find(entity_id=_entity_id, reverse=True): _note = Note(_note_id) _note_context = _note.read() if _note_context['weight'] >= 0: _creator_context = User(_note_context['creator_id']).read() _note_list.append({ 'note_context' : _note_context, 'creator_context' : _creator_context, }) _liker_list = [] for _liker in Entity(_entity_id).liker_list(offset=0, count=20): _liker_list.append(User(_liker[0]).read()) # _duration = datetime.datetime.now() - _start_at # WebLogTask.delay( # duration=_duration.seconds * 1000000 + _duration.microseconds, # entry='wechat', # page='ENTITY', # request=request.REQUEST, # ip=get_client_ip(request), # log_time=datetime.datetime.now(), # request_user_id=_request_user_id, # appendix={ # 'entity_id' : int(_entity_id), # }, # ) return render_to_response( template, { 'entity_context' : _entity_context, 'note_list' : _note_list, 'liker_list' : _liker_list, 'buy_link' : _item_context['buy_link'], }, context_instance=RequestContext(request) )
def qiandao_test(): user = User('用户名', '密码', ) user.login() tiebalist = ['lol', 'dnf', 'cf', 'python', 'unity3d', 'ue4', '天涯明月刀OL', '李毅', '魔兽世界', '美女', '魔兽玩家', 'java', 'c++', '动漫', '冒险岛2', '暗黑3', '激战2'] for tiebaname in tiebalist: tieba = Tieba(tiebaname) tieba.qiandao(user)
def test_base_user_profile(self): user = User.login('*****@*****.**', '123456') user.set_profile('johnny', location='北京', city='朝阳', gender='M', bio='我是你大爷', website='www.baidu.com'); UserTest.print_user(user) us = User.create('*****@*****.**', '123456', 'johnny1') UserTest.assert_exception((lambda:us.set_profile('johnny')), User.NicknameExistAlready) us.set_profile('johnny2'); UserTest.print_user(us)
def reset_password(request, template='account/reset_password.html'): if request.method == "GET": _token = request.GET.get("token", None) if _token: _result = User.check_one_time_token(_token, "reset_password") if _result['status'] == 'available': return render_to_response( template, { 'status': _result['status'], 'token': _token, 'user_context': User(_result['user_id']).read() }, context_instance=RequestContext(request)) else: return render_to_response( template, {'status': _result['status']}, context_instance=RequestContext(request)) elif request.method == "POST": _token = request.POST.get("token", None) _password = request.POST.get("password", None) _result = User.check_one_time_token(_token, "reset_password") if _result['status'] == 'available': _user = User(_result['user_id']) _user.reset_account(password=_password) User.confirm_one_time_token(_token) return HttpResponseRedirect(reverse('web_selection')) else: return render_to_response(template, {'status': _result['status']}, context_instance=RequestContext(request))
def seller_only_decorator(request, *args, **kwargs): user_inst = User(request.user.id) user_context = user_inst.read() shop_nick = user_context.get("shop_nick", None) if shop_nick: shop_inst = TaobaoShop(shop_nick) kwargs['user_context'] = user_context kwargs['shop_inst'] = shop_inst return func(request, *args, **kwargs) else: return HttpResponseRedirect(reverse("seller_bind_taobao_shop"))
def update_profile(request): form = SettingAccountForm(request.POST) _user = User(request.user.id) if form.is_valid(): _user.set_profile( nickname=form.cleaned_data['nickname'], location=form.cleaned_data['location'], city=form.cleaned_data['city'], gender=form.cleaned_data['gender'], bio=form.cleaned_data['bio'], website=form.cleaned_data['website'], ) return HttpResponseRedirect(reverse("web_setting"))
def add_comment(request, note_id, template='note/note_comment.html'): if request.method == 'POST': _user_context = User(request.user.id).read() _creator_id = request.user.id _comment_text = request.POST.get('comment_text', None) _reply_to_user_id = request.POST.get('reply_to_user_id', None) _reply_to_comment_id = request.POST.get('reply_to_comment_id', None) _ret = { 'status' : '0', 'msg' : '' } if _comment_text is not None and len(_comment_text) > 0: if _reply_to_comment_id is not None: if len(_reply_to_user_id) > 0: _reply_to_comment_id = int(_reply_to_comment_id) else: _reply_to_comment_id = None if _reply_to_user_id is not None: if len(_reply_to_user_id) > 0: _reply_to_user_id = int(_reply_to_user_id) else: _reply_to_user_id = None _note = Note(int(note_id)) _new_comment_id = _note.add_comment(_comment_text, _creator_id, reply_to_comment_id=_reply_to_comment_id, reply_to_user_id=_reply_to_user_id) _comment_context = _note.read_comment(_new_comment_id) if _reply_to_user_id is not None: _nickname = User(_reply_to_user_id).read()['nickname'] _comment_context['reply_to_user_nickname'] = _nickname _creator_context = User(_creator_id).read() _t = loader.get_template(template) _c = RequestContext(request, { 'comment_context': _comment_context, 'creator_context': _creator_context, 'user_context': _user_context }) _data = _t.render(_c) _ret = { 'status': '1', 'data': _data } return JSONResponse(_ret)
def bind_taobao_shop(request): user_id = request.user.id user_inst = User(user_id) request_user_context = user_inst.read() if request.method == "GET": taobao_nick = request_user_context.get("taobao_nick", None) taobao_shop = None if taobao_nick and TaobaoShop.nick_exist(taobao_nick): taobao_shop = TaobaoShop(taobao_nick).read() return render_to_response( "bind_taobao_shop.html", { "user_context" : request_user_context, "taobao_shop" : taobao_shop }, context_instance=RequestContext(request) ) elif request.method == "POST": if not request_user_context.get("taobao_nick"): messages.info(request, u"尚未绑定淘宝帐号") return HttpResponseRedirect(reverse('seller_bind_taobao_shop')) item_url = request.POST.get('item_url', None) if not item_url: message.info(request, u"请输入商品地址") return HttpResponseRedirect(reverse('seller_bind_taobao_shop')) if is_taobao_url(item_url): taobao_id = parse_taobao_id_from_url(item_url) taobao_item_info = TaobaoExtractor.fetch_item(taobao_id) nick = taobao_item_info['nick'].decode("utf-8") user_taobao_nick = request_user_context.get('taobao_nick') if user_taobao_nick == nick: user_inst.create_seller_info(nick) if not TaobaoShop.nick_exist(nick): shop_info = TaobaoExtractor.fetch_shop(taobao_item_info['shop_link']) TaobaoShop.create( shop_info['nick'], shop_info['shop_id'], shop_info['title'], shop_info['type'], shop_info['seller_id'], shop_info['pic'] ) return HttpResponseRedirect(reverse('seller_bind_taobao_shop')) else: messages.info(request, u"错误的商品地址,请输入淘宝商品地址") return HttpResponseRedirect(reverse('seller_bind_taobao_shop')) else: return HttpResponseRedirect(reverse('seller_bind_taobao_shop'))
def show_auth_user(user_id, is_staff=False): _user_context = User(user_id).read() return { 'user_context' : _user_context, 'is_staff' : is_staff }
def clean_nickname(self): nickname = self.cleaned_data['nickname'] if User.nickname_exist(nickname): raise forms.ValidationError( self.error_messages['nickname_exist'] ) return nickname
def login(request): if request.method == "POST": _email = request.POST.get('email', None) _password = request.POST.get('password', None) _api_key = request.POST.get('api_key', None) try: _user = User.login( email = _email, password = _password ) _session = Session_Key.objects.generate_session( user_id = _user.user_id, username = _user.get_username(), email = _email, api_key = _api_key ) _data = { 'user' : _user.read(), 'session' : _session.session_key } return SuccessJsonResponse(_data) except User.LoginEmailDoesNotExist, e: return ErrorJsonResponse( data = { 'type' : 'email', 'message' : str(e), }, status = 400 )
def clean_email(self): cleaned_data = self.cleaned_data data_email = cleaned_data['email'] is_exist = User.email_exist(data_email) if is_exist: raise forms.ValidationError(self.error_messages['email_exist'], ) return data_email
def register(request): if request.method == "POST": _email = request.POST.get('email', None) _password = request.POST.get('password', None) _nickname = request.POST.get('nickname', None) _api_key = request.POST.get('api_key', None) _username = request.POST.get('username', None) try: _user = User.create( email = _email, password = _password, username = _username ) except User.EmailExistAlready, e: return ErrorJsonResponse( data = { 'type' : 'email', 'message' : str(e), }, status = 409 ) except User.UsernameExistAlready, e: return ErrorJsonResponse( data = { 'type' : 'username', 'message' : str(e), }, status = 409 )
def user_tag_entity(request, user_id, tag_hash, template="tag/tag_detail.html"): # _start_at = datetime.datetime.now() # _request_user_id = request.user.id if request.user.is_authenticated() else None if request.user.is_authenticated(): _request_user_id = request.user.id _request_user_like_entity_set = Entity.like_set_of_user(_request_user_id) else: _request_user_id = None _request_user_like_entity_set = list() _user_context = User(user_id).read() _tag_text = Tag.get_tag_text_from_hash(tag_hash) _page_num = request.GET.get('p', 1) _entity_id_list = Tag.find_user_tag_entity(user_id, _tag_text) _paginator = Paginator(_page_num, 24, len(_entity_id_list)) _entities = list() for _entity_id in _entity_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _entity_context = Entity(_entity_id).read() _entity_context['is_user_already_like'] = True if _entity_id in _request_user_like_entity_set else False _entities.append(_entity_context) # _entities.append(Entity(_entity_id).read()) except Exception, e: log.error(e.message)
def popular(request, template='main/popular.html'): _start_at = datetime.now() if request.user.is_authenticated(): _request_user_id = request.user.id _request_user_context = User(request.user.id).read() _request_user_like_entity_set = Entity.like_set_of_user( request.user.id) else: _request_user_id = None _request_user_context = None _request_user_like_entity_set = [] _group = request.GET.get('group', 'daily') _popular_list = [] _entity_id_list = [] _popular_updated_time = datetime.now() _popular_entities = popularity.read_popular_entity_from_cache(scale=_group) # log.info(_popular_entities) if _popular_entities != None: _popular_updated_time = _popular_entities['updated_time'] for row in _popular_entities['data'][0:60]: try: _entity_id = row[0] _entity = Entity(_entity_id) _entity_context = _entity.read() _is_user_already_like = True if _entity_id in _request_user_like_entity_set else False _popular_list.append({ 'is_user_already_like': _is_user_already_like, 'entity_context': _entity_context, }) _entity_id_list.append(_entity_id) except Exception, e: pass
def register(request, template = 'reg.html'): if request.method == 'GET': _forms = SignUpAccountForm() return render_to_response( template, { 'forms' : _forms, }, context_instance = RequestContext(request) ) elif request.method == 'POST': _forms = SignUpAccountForm(request.POST) if _forms.is_valid(): _remember_me = request.POST.get('remember_me', None) _email = _forms.cleaned_data['email'] _password = _forms.cleaned_data['password'] _nickname = _forms.cleaned_data['nickname'] user = User.create(email = _email, password = _password, username = _nickname) user.set_profile(_nickname); _user = authenticate(username=user.get_id(), password=_password) if _remember_me: request.session.set_expiry(MAX_SESSION_EXPIRATION_TIME) return HttpResponseRedirect('../infor') else: return render_to_response( template, { 'forms' : _forms, }, context_instance = RequestContext(request) )
def clean_nickname(self): nickname = self.cleaned_data['nickname'] is_exist = User.nickname_exist(nickname) if is_exist: raise forms.ValidationError( self.error_messages['nickname_exist'], ) return nickname
def add_note(request, entity_id, template='entity/entity_note.html'): if request.method == 'POST': _note_text = request.POST.get('note_text', None) _ret = { 'status' : '0', 'msg' : '' } if _note_text is not None and len(_note_text) > 0: _entity = Entity(int(entity_id)) # TODO 连接有问题 正式需要替换以下两句 _note = _entity.add_note(request.user.id, _note_text) # _note = Note(312868) _note_context = _note.read() _user_context = User(request.user.id).read() _t = loader.get_template(template) _c = RequestContext(request, { 'note_context': _note_context, 'creator_context': _user_context, 'user_context': _user_context }) _data = _t.render(_c) _ret = { 'status' : '1', 'data' : _data } return HttpResponse(json.dumps(_ret))
def get_comments(request, note_id, template='note/note_comment_list.html'): # _user_context = User(request.user.id) if request.user.is_authenticated(): _user_context = User(request.user.id) else: _user_context = None _note = Note(note_id) _note_context = _note.read() _comment_id_list = _note_context['comment_id_list'] _comment_list = [] for _c_id in _comment_id_list: _comment_context = _note.read_comment(_c_id) _creator_id = _comment_context['creator_id'] _creator_context = User(_creator_id).read() _reply_to_user_id = _comment_context['reply_to_user_id'] if _reply_to_user_id is not None: _nickname = User(_reply_to_user_id).read()['nickname'] _comment_context['reply_to_user_nickname'] = _nickname _comment_list.append( { 'comment_context' : _comment_context, 'creator_context' : _creator_context, 'note_context' : _note_context, 'user_context' : _user_context } ) _t = loader.get_template(template) _c = RequestContext(request, { 'comment_list': _comment_list, 'note_context': _note_context, }) _data = _t.render(_c) _ret = { # 'status': '1', 'data': _data } if len( _note_context['comment_id_list'] ) < 1: # raise Http404 return JSONResponse(_ret, status=404) return JSONResponse(_ret)
def user_list(request, template='user/list.html'): _page_num = int(request.GET.get("p", "1")) _user_count = User.count() _paginator = Paginator(_page_num, 30, _user_count) _user_id_list = User.find( offset=_paginator.offset, count=_paginator.count_in_one_page, ) _context_list = [] for _user_id in _user_id_list: try: _user = User(_user_id) _user_context = _user.read() _context_list.append(_user_context) except Exception, e: pass
def signup(email, password, nickname, **kwargs): _new_user = User.create(email=email, password=password) _new_user.set_profile(nickname=nickname, location=kwargs.get("location"), city=kwargs.get("city"), gender=kwargs.get("gender"), bio=kwargs.get("bio"), website=kwargs.get("website")) return _new_user
def update_avatar(request): if request.method == 'POST': _avatar_img = request.FILES.get('avatar_img', None) if _avatar_img is None: return HttpResponseRedirect(reverse('web_setting') + '?msg=0') elif len(_avatar_img) / (1024**2) > 2: return HttpResponseRedirect(reverse('web_setting') + '?msg=1') else: if hasattr(_avatar_img, 'chunks'): _image_data = ''.join(chunk for chunk in _avatar_img.chunks()) else: _image_data = _avatar_img.read() _user = User(request.user.id) _user.upload_avatar(_image_data) return HttpResponseRedirect(reverse('web_setting'))
def download_ios(request, template="download_ios.html"): if request.user.is_authenticated(): _request_user_context = User(request.user.id).read() else: _request_user_context = None return render_to_response(template, { 'user_context': _request_user_context, }, context_instance=RequestContext(request))
def run(self, user_id, message=False, selection=False, social_feed=False, friend_feed=False): User(user_id).mark_footprint(message=message, selection=selection, social_feed=social_feed, friend_feed=friend_feed)
def clean_email(self): # log.info(self.cleaned_data ) data_email = self.cleaned_data['email'] user_id = User.get_user_id_by_email(data_email) if user_id is None: return data_email else: raise forms.ValidationError( self.error_messages['email_exist'] )
def clean_email(self): # log.info(self.cleaned_data ) cleaned_data = self.cleaned_data # log.info(cleaned_data) data_email = cleaned_data['email'] user_id = User.get_user_id_by_email(data_email) # is_exist = User.objects.filter(email=data_email).exists() if user_id is None: raise forms.ValidationError(self.error_messages['email_not_exist']) return user_id
def auth_register(): error = None # ############################################################# # TODO: Add form input validation and sanitize everything and # add bcrypt support if request.method == 'POST': uname = str(request.form['username']) pw = str(request.form['password']) pw2 = str(request.form['password2']) email = str(request.form['email']) unc_email = str(request.form['uncc_email']) fname = str(request.form['firstname']) lname = str(request.form['lastname']) nick = str(request.form['nickname']) degree_prog = int(request.form['degree_program']) if len(uname) < 5: flash('Username is too short: must be longer than five characters', 'Error') return render_template('register.html', error=error, degrees=app.config['DEGREE_PROGRAMS']) quser = User.query.filter_by(username = uname).first() qemail = User.query.filter_by(uncc_email = unc_email).first() if (quser is None) and (qemail is None): if pw == pw2: # basic password validation # generate password hash passwd = hashpw(pw, gensalt()) usr = User(uname, passwd, email) usr.set_fullname(fname,lname) usr.set_uncc_email(unc_email) usr.set_nickname(nick) usr.set_degree_program(degree_prog) db.session.add(usr) db.session.commit() flash('User created: You may now login.', 'Message') return default_view() else: flash('Passwords do not math', 'Error') else: flash('Username or Email already in use.', 'Error') return default_view('user/register.html')
def show_avater(value, size=64): _user_context = User(value).read() _avatar_url = _user_context['avatar_large'] if size <= 50: _avatar_url = _user_context['avatar_small'] return { 'avatar_url': _avatar_url, 'nickname': _user_context['nickname'], 'size': size, }
def _get_special_names(request_user_id): if request_user_id in [ 22045, 19, 10, 79761, 66400, 195580, 252913, 255444, 68310 ]: if request_user_id == 22045: _id_list = [ 22045, 149556, 14, 149308, 195580, 68310, 209071, 105, 173660, 95424, 215653, 218336, 216902, 79761, 66400, 252913 ] elif request_user_id == 68310: _id_list = [ 68310, 22045, 149556, 14, 149308, 195580, 209071, 105, 173660, 95424, 215653, 218336, 216902, 79761, 66400, 252913 ] elif request_user_id in [10, 19]: _id_list = [ 19, 10, 22045, 149556, 14, 149308, 195580, 68310, 209071, 105, 173660, 95424, 215653, 218336, 216902, 79761, 66400, 252913 ] elif request_user_id == 195580: _id_list = [195580, 215653, 209071, 79761, 66400] elif request_user_id == 255444: _id_list = [ 255444, 19, 10, 22045, 149556, 14, 149308, 195580, 68310, 209071, 105, 173660, 95424, 215653, 218336, 216902, 79761, 66400, 252913 ] elif request_user_id in [79761, 66400]: _id_list = [66400, 79761] _users = [] for _id in _id_list: _user_context = User(_id).read() _users.append({'id': _id, 'name': _user_context['nickname']}) else: _request_user_context = User(request_user_id).read() _users = [{ 'name': _request_user_context['nickname'], 'id': str(request_user_id) }] return _users
def display_feed_item(obj): _note_id = obj.note_id _note_context = Note(_note_id).read() _creator_context = User(_note_context['creator_id']).read() _entity_id = obj.entity_id _entity_context = Entity(_entity_id).read() return { 'note_context': _note_context, 'entity_context': _entity_context, 'creator_context': _creator_context, }
def clean_email(self): # log.info(self.cleaned_data ) cleaned_data = self.cleaned_data # log.info(cleaned_data) data_email = cleaned_data['email'] user_id = User.get_user_id_by_email(data_email) # is_exist = User.objects.filter(email=data_email).exists() if user_id is None: raise forms.ValidationError( self.error_messages['email_not_exist'] ) return user_id
def infor(request, template = 'info.html'): if request.user.is_authenticated(): user_id = request.user.id if request.method == 'GET': user = User.get_user_by_id(user_id) return render_to_response( template, { 'user' : user.read(), }, context_instance = RequestContext(request) ) return HttpResponseRedirect('../login')
def user_tags(request, user_id, template=TEMPLATE): _start_at = datetime.datetime.now() _query_user = User(user_id) _query_user_context = _query_user.read() if request.user.is_authenticated(): _request_user_id = request.user.id _request_user_context = User(_request_user_id).read() _relation = User.get_relation(_request_user_context['user_id'], _query_user_context['user_id']) else: _request_user_id = None _request_user_context = None _relation = None _page_num = int(request.GET.get('p', '1')) _tag_stat_list = Tag.user_tag_stat(user_id) _total_count = len(_tag_stat_list) _paginator = Paginator(_page_num, 20, len(_tag_stat_list)) _tag_list = [] _log_tags = [] for _tag_stat in _tag_stat_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _tag_id = _tag_stat['tag_id'] _tag_hash = _tag_stat['tag_hash'] _tag = _tag_stat['tag'] _entity_id_list = Tag.find_user_tag_entity(user_id, _tag) _entity_count = len(_entity_id_list) _entity_list = [Entity(x).read() for x in _entity_id_list[:4]] _tag_list.append({ 'tag' : _tag, 'tag_id' : _tag_id, 'tag_hash' : _tag_hash, 'entity_list' : _entity_list, 'entity_count' : _entity_count }) _log_tags.append(_tag) except Exception, e: pass
def v_check_nickname(nickname, must_not_exist = False): """ 返回错误信息,若没问题返回 None """ _ret = None if nickname is None or len(nickname) == 0: _ret = u'请填写昵称' elif len(nickname) > 15: _ret = u'昵称不能超过15个字' elif must_not_exist and User.nickname_exist(nickname): _ret = u'昵称已经被占用' return _ret
def follow(request, user_id, target_status): if request.method == 'POST': _followee_id = int(user_id) _user = User(request.user.id) if _user.is_following(_followee_id): _user.unfollow(_followee_id) return HttpResponse('0') else: _user.follow(_followee_id) return HttpResponse('1')
def v_check_email(email, must_not_exist = False): """ 返回错误信息,若没问题返回 None """ _ret = None if email is None or len(email) == 0: _ret = u'请填写邮箱' elif not v_validate_email(email): _ret = u'请输入正确的邮箱' elif must_not_exist and User.email_exist(email): _ret = u'邮箱已经被占用' return _ret
def edit_user(request, user_id, template='user/edit.html'): if request.method == 'POST': # _user = User(user_id) forms = UserForms(request.POST) if forms.is_valid(): forms.update(user_id) return HttpResponseRedirect(request.META['HTTP_REFERER']) else: return render_to_response( template, { 'forms': forms, 'user_context': User(user_id).read(with_censor=False), }, context_instance=RequestContext(request)) else: _user_context = User(user_id).read(with_censor=False) forms = UserForms(initial=_user_context) return render_to_response(template, { 'forms': forms, 'user_context': _user_context, }, context_instance=RequestContext(request))
def clean(self): cleaned_data = super(SignInAccountForm, self).clean() log.info(cleaned_data) uid = cleaned_data.get('email', None) if not uid: raise forms.ValidationError(self.error_messages['wrong_email'], ) password = cleaned_data.get('password', None) username = User(uid).get_username() _user = authenticate(username=username, password=password) if not _user: raise forms.ValidationError(self.error_messages['wrong_password']) cleaned_data['user'] = _user return cleaned_data
def user_tag_list(request): _page_num = int(request.GET.get("p", "1")) _type = request.GET.get("type", "all") _user_id = request.GET.get("user", None) if _user_id != None: _user_id = int(_user_id) _tag = request.GET.get("tag", None) _recommend_user_tag_list = Tag.get_recommend_user_tag_list(with_entity_count = False) if _type == 'recommend': _user_tag_list = [] for _user_tag in _recommend_user_tag_list: _user_tag_list.append({ 'user_id' : _user_tag[0], 'tag_text' : _user_tag[1], 'entity_count' : Tag.get_user_tag_entity_count(_user_tag[0], _user_tag[1]) }) else: _user_tag_list = Tag.find_user_tag(user_id = _user_id, tag = _tag) _paginator = Paginator(_page_num, 30, len(_user_tag_list), {"type" : _type}) _context_list = [] for _data in _user_tag_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _user = User(_data['user_id']) _user_context = _user.read() if [_user_context['user_id'], _data['tag_text']] in _recommend_user_tag_list: _status = 1 else: _status = 0 _context_list.append({ 'tag' : _data['tag_text'], 'user' : _user_context, 'entity_count' : _data['entity_count'], 'status' : _status }) except Exception, e: pass
def louzhonglou(self): data_text = 'ie=utf-8&kw=lol&fid=280050&tid=4479056728&floor_num=321"e_id=87577050793&rich_text=1&tbs=7ba37c30d3be01b31460620868&content=%E6%B5%8B%E6%B5%8B%E6%B5%8B%E6%B5%8B%E6%B5%8B%E6%B5%8B&lp_type=0&lp_sub_type=0&new_vcode=1&tag=11&repostid=87577050793&anonymous=0' data = str2dic(data_text) print(data) #私信 def fasixin(self): pass #点赞 def dianzan(self): pass #获取贴吧成员 def get_tieba_member(self): pass #大召唤术 def summon(self): pass #获取好友 if __name__ == '__main__': user = User('用户名','密码',) user.login() tiebalist=['lol','dnf','cf','python','unity3d','ue4','天涯明月刀OL','李毅','魔兽世界','美女','魔兽玩家','java','c++','动漫','冒险岛2','暗黑3','激战2'] for tiebaname in tiebalist: tieba = Tieba(tiebaname) tieba.guanzhu(user)
def onkeyqiandao_test(): user = User('用户名', '密码', ) user.login() tieba = Tieba('暗黑3') tieba.onekey_qiandao(user)
def fatie_test(): user = User('用户名', '密码', ) user.login() tieba = Tieba('寻找女王控') tieba.fatie(user)
def setUp(self): User.create('*****@*****.**', '123456', 'johnny');
def huitie_test(): user = User('用户名', '密码', ) user.login() tieba = Tieba('寻找女王控') tiezi_url='http://tieba.baidu.com/p/4479248232' tieba.huitie(user,tiezi_url)
rl = Role() rl.rolename = rol base_app.db.session.add(rl) base_app.db.session.commit() admin_uname = base_app.config['DEFAULT_ADMIN_USER'][0] admin_pwhash = base_app.config['DEFAULT_ADMIN_USER'][1] admin_email = base_app.config['DEFAULT_ADMIN_USER'][2] admin_umail = base_app.config['DEFAULT_ADMIN_USER'][3] admin_fname = base_app.config['DEFAULT_ADMIN_USER'][4] admin_lname = base_app.config['DEFAULT_ADMIN_USER'][5] admin_nickname = base_app.config['DEFAULT_ADMIN_USER'][6] usr = User( admin_uname, admin_pwhash, admin_email ) usr.set_fullname( admin_fname, admin_lname ) usr.set_nickname( admin_nickname ) usr.set_uncc_email( admin_umail ) usr.add_role('admin') base_app.db.session.add(usr) # ############################################################################# # Section: module specific configuration and initial population from base import register_content_container # #############################################################################
def test_base_user_login(self): UserTest.assert_exception((lambda : User.login('*****@*****.**', '23456')), User.LoginPasswordIncorrect) UserTest.assert_exception((lambda : User.login('*****@*****.**', '23456')), User.LoginEmailDoesNotExist) User.login('*****@*****.**', '123456')
def test_base_user_create(self): UserTest.assert_exception((lambda : User.create('*****@*****.**', '123456', 'johnny')), User.EmailExistAlready)