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
