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 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 user_fans(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 = request.GET.get('p', 1) _fans_id_list = _query_user.read_fan_user_id_list() _paginator = Paginator(_page_num, 8, len(_fans_id_list)) _fans_list = [] for _u_id in _fans_id_list[_paginator.offset : _paginator.offset + _paginator.count_in_one_page]: try: _f_user = User(_u_id) _f_user_context = _f_user.read() if _request_user_context != None: _f_user_context['relation'] = User.get_relation(_request_user_context['user_id'], _u_id) _f_user_context['latest_like_entity_id_list'] = _f_user.read_latest_like_entity_list() _fans_list.append(_f_user_context) except Exception, e: pass
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 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 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 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 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 show_auth_user(user_id, is_staff=False): _user_context = User(user_id).read() return { 'user_context' : _user_context, 'is_staff' : is_staff }
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 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 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 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 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 _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(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_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 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 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 tencent_selection(request, template='tencent/selection.html'): _start_at = datetime.now() if request.user.is_authenticated(): _request_user_id = request.user.id else: _request_user_id = None _agent = 'iphone' if 'Android' in request.META['HTTP_USER_AGENT']: _agent = 'android' _page_num = int(request.GET.get('p', 1)) _hdl = NoteSelection.objects.filter(post_time__lt=datetime.now()) _paginator = Paginator(_page_num, 30, _hdl.count()) _hdl = _hdl.order_by('-post_time') _selection_list = [] _entity_id_list = [] for _note_selection in _hdl[_paginator.offset:_paginator.offset + _paginator.count_in_one_page]: _selection_note_id = _note_selection['note_id'] _entity_id = _note_selection['entity_id'] _entity_context = Entity(_entity_id).read() _note_context = Note(_selection_note_id).read() _creator_context = User(_note_context['creator_id']).read() _selection_list.append({ 'entity_context': _entity_context, 'note_context': _note_context, 'creator_context': _creator_context, }) _entity_id_list.append(_entity_id) _duration = datetime.now() - _start_at WebLogTask.delay( entry='tencent', duration=_duration.seconds * 1000000 + _duration.microseconds, page='SELECTION', request=request.REQUEST, ip=get_client_ip(request), log_time=datetime.now(), request_user_id=_request_user_id, appendix={ 'result_entities': _entity_id_list, }, ) return render_to_response(template, { 'agent': _agent, 'selection_list': _selection_list, 'next_page_num': _page_num + 1, }, context_instance=RequestContext(request))
def user_notes(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() _request_user_like_entity_set = Entity.like_set_of_user(request.user.id) _relation = User.get_relation(_request_user_context['user_id'], _query_user_context['user_id']) else: _request_user_id = None _request_user_context = None _request_user_like_entity_set = [] _relation = None _page_num = int(request.GET.get('p', 1)) _paginator = Paginator(_page_num, 24, Note.count(creator_set=[user_id])) _note_id_list = Note.find(creator_set=[user_id], offset=_paginator.offset, count=_paginator.count_in_one_page) _note_list = [] for _n_id in _note_id_list: try: _note_context = Note(_n_id).read() _entity_id = _note_context['entity_id'] _creator_context = User(user_id).read() _entity_context = Entity(_entity_id).read() _is_user_already_like = True if _entity_id in _request_user_like_entity_set else False _note_list.append( { 'entity_context' : _entity_context, 'note_context' : _note_context, 'creator_context' : _creator_context, 'is_user_already_like' : _is_user_already_like } ) except Exception, e: pass
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 update(self, user_id): _username = self.cleaned_data['username'] _nickname = self.cleaned_data['nickname'] _email = self.cleaned_data['email'] _gender = self.cleaned_data['gender'] _bio = self.cleaned_data['bio'] _website = self.cleaned_data['website'] _user = User(user_id) _user.reset_account(username=_username, email=_email) _user.set_profile(_nickname, gender=_gender, bio=_bio, website=_website) return _user
def user_likes(request, user_id, template=TEMPLATE): _start_at = datetime.datetime.now() _category_id = request.GET.get('c', None) _page_num = int(request.GET.get('p', '1')) _price = request.GET.get('price', None) _query_user = User(user_id) _query_user_context = _query_user.read() if request.user.is_authenticated(): _request_user_id = request.user.id _is_staff = request.user.is_staff _request_user_context = User(_request_user_id).read() _request_user_like_entity_set = Entity.like_set_of_user(request.user.id) _relation = User.get_relation(_request_user_context['user_id'], _query_user_context['user_id']) else: _request_user_id = None _is_staff = False _request_user_context = None _request_user_like_entity_set = [] _relation = None _old_category_list = Old_Category.find()[0:12] _param = {} if _category_id is not None: _category_id = int(_category_id) _param['c'] = _category_id _paginator = Paginator(_page_num, 24, _query_user.entity_like_count(category_id=_category_id), _param) _entity_id_list = _query_user.find_like_entity(_category_id, offset=_paginator.offset, count=_paginator.count_in_one_page) _entity_list = [] for _e_id in _entity_id_list: try: _entity_context = Entity(_e_id).read() _entity_context['is_user_already_like'] = True if _e_id in _request_user_like_entity_set else False _entity_list.append(_entity_context) except Exception, e: pass
def setting(request, template='account/setting.html'): _msg_code = request.GET.get('msg', None) _user_context = User(request.user.id).read() profile_form = SettingAccountForm(initial=_user_context) password_form = ChangePasswordForm(request.user) return render_to_response( template, { 'msg_code': _msg_code, 'user_context': _user_context, 'profile_form': profile_form, 'password_form': password_form, }, context_instance=RequestContext(request), )
def note_comment_list(request): _page_num = int(request.GET.get("p", "1")) _comment_count = Note.comment_count() _paginator = Paginator(_page_num, 30, _comment_count) _context_list = [] for _comment in Note.find_comment(offset=_paginator.offset, count=_paginator.count_in_one_page): try: _comment_context = Note(_comment[0]).read_comment(_comment[1]) _comment_context['creator'] = User( _comment_context['creator_id']).read() _context_list.append(_comment_context) except Exception, e: pass
def load_item_info(request): if request.method == 'POST': _cand_url = request.POST.get("cand_url", None) _hostname = urlparse(_cand_url).hostname if re.search(r"\b(jd|360buy)\.com$", _hostname) != None: return jd_info(request, _cand_url) if re.search(r"\b(tmall|taobao)\.com$", _hostname) is not None: _taobao_id = parse_taobao_id_from_url(_cand_url) _item = Item.get_item_by_taobao_id(_taobao_id) if _item is None: _taobao_item_info = load_taobao_item_info(_taobao_id) _chief_image_url = _taobao_item_info["thumb_images"][0] _selected_category_id = Category.get_category_by_taobao_cid(_taobao_item_info['cid']) _data = { 'user_context' : User(request.user.id).read(), 'cand_url' : _cand_url, 'taobao_id': _taobao_id, 'cid': _taobao_item_info['cid'], 'taobao_title': _taobao_item_info['title'], 'shop_nick': _taobao_item_info['shop_nick'], 'shop_link': _taobao_item_info['shop_link'], 'price': _taobao_item_info['price'], 'chief_image_url' : _chief_image_url, 'thumb_images': _taobao_item_info["thumb_images"], 'selected_category_id': _selected_category_id, } _rslt = { 'status' : 'SUCCESS', 'data' : _data } elif _item.get_entity_id() == -1: _rslt = { 'status' : 'OTHER' } else: _entity_id = _item.get_entity_id() _entity_context = Entity(_entity_id).read() _rslt = { 'status' : 'EXIST', 'data' : { 'entity_hash' : _entity_context['entity_hash'] } } return HttpResponse(json.dumps(_rslt))
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