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)
