def format_customer_managers_for_ajax(self, objs):
data = []
for obj in objs:
if not obj:
continue
user = UserBase().get_user_by_id(obj.user_id)
if user == "":
continue
user_count_info = UserCountBase().get_user_count_info(obj.user_id)
data.append(
dict(
user_id=user.id,
user_nick=self.get_cm_nick_show(obj.real_name, user.nick),
user_avatar=user.get_avatar_100(),
department_name=obj.department.get_short_name(),
company_short_name=obj.department.company.get_short_name(),
department_id=obj.department.id,
city_id=obj.city_id,
sort_num=obj.sort_num,
vip_info=obj.vip_info,
qq=obj.qq,
mobile=obj.mobile,
pay_type=obj.pay_type,
user_question_count=user_count_info['user_question_count'],
user_answer_count=user_count_info['user_answer_count'],
user_liked_count=user_count_info['user_liked_count'],
))
return data
def format_code(objs, num):
data = []
for x in objs:
num += 1
user = UserBase().get_user_by_id(x.user_id) if x.user_id else None
operater = UserBase().get_user_by_id(x.operate_user_id) if x.operate_user_id else None
data.append({
'num': num,
'code_id': x.id,
'user_id': x.user_id if user else '',
'user_nick': user.nick if user else '',
'car_wash_id': x.car_wash.id if x.car_wash else '',
'car_wash_name': x.car_wash.name if x.car_wash else '',
'trade_id': x.order.trade_id,
'code': x.code,
'code_type': x.code_type,
'state': x.state,
'use_time': str(x.use_time) if x.use_time else '',
'operater_id': x.operate_user_id if operater else '',
'operater_nick': operater.nick if operater else '',
})
return data
def main():
from www.question import interface
from www.account.interface import UserBase
user = UserBase().get_user_by_id(user_id)
lb = interface.LikeBase()
ab = interface.AnswerBase()
qb = interface.QuestionBase()
tb = interface.TopicBase()
# lb.like_it(7, from_user_id=user_id, ip='127.0.0.1')
# ab.remove_answer(41, user)
# print ab.get_answer_summary_by_id(1)
# print qb.set_important(8, user, title="2014年新规新股申购:9问9答！（号称市场最全面2014.6.1", summary="fasdfadsfadsfads", author_user_id='',
# img='http://img0.zhixuan.com/important_28.jpg', img_alt='这是一个神奇的精选', sort_num=4)
# print qb.cancel_important(8, user)
des = """12121"""
# print tb.create_topic(name=u"测试话题", domain="dpzs1", parent_topic_id=1, des=des, img="", state=1)
# print tb.modify_topic(topic_id=26, name=u"测试话题", domain="csht", parent_topic_id=2, des=u'测试话题', img="", state=1)
print UserBase().search_users(u"简单")
print qb.search_questions("a")
def format_invite(objs, num):
data = []
for x in objs:
num += 1
user = None
if x.qrcode.state == 0:
user = UserBase().get_user_by_id(x.from_user_id)
to_user = UserBase().get_user_by_id(x.to_user_id)
data.append({
'num': num,
'id': x.id,
'user_name': user.nick if user else x.qrcode.name,
'user_id': user.id if user else '',
'user_avatar': user.get_avatar_65() if user else '',
'to_user_name': to_user.nick if to_user else '',
'to_user_id': x.to_user_id,
'to_user_avatar': to_user.get_avatar_65() if to_user else '',
'to_user_des': to_user.des,
'create_time': str(x.create_time)
})
return data
def format_info(objs, num):
data = []
for x in objs:
num += 1
user = UserBase().get_user_by_id(x.user_id)
data.append({
'num': num,
'id': x.id,
'user_name': user.nick if user else '',
'user_id': x.user_id,
'user_avatar': user.get_avatar_65() if user else '',
'name': x.name,
'mobile': x.mobile,
'title': x.title,
'company_name': x.company_name,
'company_short_name': x.company_short_name,
'state': x.state,
'create_time': str(x.create_time),
'update_time': str(x.update_time)
})
return data
def get_user_by_id(request):
user_id = request.REQUEST.get('user_id')
data = ''
user = UserBase().get_user_by_id(user_id)
if user:
user = UserBase().format_user_full_info(user.id)
data = {
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_avatar_300': user.get_avatar_300(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'user_gender': user.gender,
'birthday': str(user.birthday),
'is_admin': user.is_admin,
'last_active': str(user.last_active),
'state': user.state,
'source': user.source_display,
'ip': user.ip,
'register_date': str(user.create_time)
}
return HttpResponse(json.dumps(data), mimetype='application/json')
def get_user_by_id(request):
user_id = request.REQUEST.get('user_id')
data = ''
user = UserBase().get_user_by_id(user_id)
if user:
user = UserBase().format_user_full_info(user.id)
data = {
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_avatar_300': user.get_avatar_300(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'user_gender': user.gender,
'birthday': str(user.birthday),
'question_count': user.user_count['user_question_count'],
'answer_count': user.user_count['user_answer_count'],
'liked_count': user.user_count['user_liked_count'],
'follower_count': user.user_count['follower_count'],
'following_count': user.user_count['following_count'],
'is_recommend': user.is_recommend,
'is_admin': user.is_admin,
'is_customer_manager': user.is_customer_manager,
'last_active': str(user.last_active),
'state': user.state,
'ip': user.ip,
'register_date': str(user.create_time)
}
return HttpResponse(json.dumps(data), mimetype='application/json')
def create_invite(self, from_user_id, to_user_id, question_id):
try:
from www.question.interface import QuestionBase
ub = UserBase()
try:
from_user = ub.get_user_by_id(from_user_id)
to_user = ub.get_user_by_id(to_user_id)
question = QuestionBase().get_question_by_id(question_id)
assert from_user and to_user and question
except:
transaction.rollback(using=DEFAULT_DB)
return 99800, dict_err.get(99800)
if from_user_id == to_user_id:
transaction.rollback(using=DEFAULT_DB)
return 40100, dict_err.get(40100)
# 同一个问题最多邀请6个人
if InviteAnswerIndex.objects.filter(from_user_id=from_user_id, question_id=question_id).count() >= 6:
transaction.rollback(using=DEFAULT_DB)
return 40101, dict_err.get(40101)
# 重复邀请给出提示
if InviteAnswerIndex.objects.filter(from_user_id=from_user_id, to_user_id=to_user_id, question_id=question_id):
transaction.rollback(using=DEFAULT_DB)
return 40102, dict_err.get(40102)
try:
ia = InviteAnswer.objects.create(from_user_ids=json.dumps([from_user_id, ]), to_user_id=to_user_id, question_id=question_id)
need_update_unread_count = True
except:
ia = InviteAnswer.objects.get(to_user_id=to_user_id, question_id=question_id)
from_user_ids = json.loads(ia.from_user_ids)
if from_user_id not in from_user_ids:
from_user_ids.append(from_user_id)
ia.from_user_ids = json.dumps(from_user_ids)
ia.save()
need_update_unread_count = True if ia.is_read else False
# 建立索引
InviteAnswerIndex.objects.create(from_user_id=from_user_id, to_user_id=to_user_id, question_id=question_id)
# 更新未读消息，新邀请或者邀请已读才更新未读数
if need_update_unread_count:
UnreadCountBase().update_unread_count(to_user_id, code='invite_answer')
# 发送提醒邮件
context = dict(user=from_user, question=question)
async_send_email(to_user.email, u'%s 在智选邀请你回答问题' % (from_user.nick, ), utils.render_email_template('email/invite.html', context), 'html')
transaction.commit(using=DEFAULT_DB)
return 0, dict_err.get(0)
except Exception, e:
debug.get_debug_detail(e)
transaction.rollback(using=DEFAULT_DB)
return 99900, dict_err.get(99900)
def oauth_weixin(request):
import logging
import urllib
from www.misc.oauth2.weixin import Consumer
from www.weixin.interface import dict_weixin_app, WeixinBase
from www.tasks import async_change_profile_from_weixin
app_key = WeixinBase().init_app_key()
client = Consumer(app_key)
def _get_next_url(weixin_state):
if weixin_state.startswith("cacheurl"):
_next_url = urllib.unquote(cache.Cache().get(weixin_state))
else:
dict_next = {
"index": "/",
"order": "/service/my_order",
"recommendation": "/account/recommendation",
"verify": "/account/verify",
"about": "/s/about",
"profile": "/account/profile",
"contact": "/s/contact_us_m",
"admin": "/admin/nav"
}
_next_url = dict_next.get(weixin_state, dict_next["index"])
return _next_url
code = request.REQUEST.get('code')
if not code:
return HttpResponseRedirect(client.authorize())
else:
weixin_state = request.GET.get("state")
# 获取access_token
dict_result = client.token(code)
access_token = dict_result.get('access_token')
# logging.error(dict_result)
# dict_result={u'errcode': 40029, u'errmsg': u'invalid code'}
if dict_result.get("errcode") == 40029: # 重新授权
return HttpResponseRedirect(client.authorize())
# 自动检测用户登陆
openid = dict_result.get("openid")
user, result = UserBase().regist_by_weixin(openid, app_key, ip=utils.get_clientip(request), expire_time=dict_result['expires_in'])
if user:
user.backend = 'www.middleware.user_backend.AuthBackend'
auth.login(request, user)
next_url = _get_next_url(weixin_state)
return HttpResponseRedirect(next_url)
else:
error_msg = result or u'微信登陆失败，请重试'
return HttpResponse(error_msg)
return HttpResponse(u'code is %s' % (code, ))
def authenticate(self, username=None, password=None):
ub = UserBase()
user = ub.get_user_by_email(username)
if not user:
user = ub.get_user_by_mobilenumber(username)
if user and ub.check_password(password, user.password):
# todo 更新最后登录时间
user.save = _save
return user
def format_user_received_invites(self, user_received_invites):
from www.question.interface import QuestionBase
ub = UserBase()
for uri in user_received_invites:
uri.question = QuestionBase().get_question_summary_by_id(uri.question_id)
uri.from_users = [ub.get_user_by_id(user_id) for user_id in json.loads(uri.from_user_ids)]
uri.from_users.reverse()
return user_received_invites
def format_followobjs(self, objs, following_or_follower):
for obj in objs:
if following_or_follower == 'following':
obj.user = UserBase().get_user_by_id(obj.to_user_id)
if following_or_follower == 'follower':
obj.user = UserBase().get_user_by_id(obj.from_user_id)
UserBase().format_user_with_count_info(obj.user)
return objs
def oauth_weixin(request):
import logging
from www.misc.oauth2.weixin import Consumer
from www.weixin.interface import dict_weixin_app, WexinBase
from www.tasks import async_change_profile_from_weixin
app_key = WexinBase().init_app_key()
client = Consumer(app_key)
code = request.REQUEST.get('code')
if not code:
return HttpResponseRedirect(client.authorize())
else:
weixin_state = request.GET.get("state")
# 获取access_token
dict_result = client.token(code)
access_token = dict_result.get('access_token')
# logging.error(dict_result)
# dict_result={u'errcode': 40029, u'errmsg': u'invalid code'}
if dict_result.get("errcode") == 40029: # 重新授权
return HttpResponseRedirect(client.authorize())
# 自动检测用户登陆
openid = dict_result.get("openid")
user_info = dict(nick=u"weixin_%s" % int(time.time() * 1000), url="", gender=0)
flag, result = UserBase().get_user_by_external_info(source='weixin', access_token=access_token, external_user_id=openid,
refresh_token=None, nick=user_info['nick'],
ip=utils.get_clientip(request), expire_time=dict_result['expires_in'],
user_url=user_info['url'], gender=user_info['gender'], app_id=dict_weixin_app[app_key]["app_id"])
if flag:
user = result
user.backend = 'www.middleware.user_backend.AuthBackend'
auth.login(request, user)
UserBase().update_user_last_login_time(user.id, ip=utils.get_clientip(request), last_active_source=2)
# 更新用户资料
if settings.LOCAL_FLAG:
async_change_profile_from_weixin(user, app_key, openid)
else:
async_change_profile_from_weixin.delay(user, app_key, openid)
dict_next = {"home": "/car_wash/", "order_code": "/car_wash/order_code", "recharge": "/cash/recharge",
"coupon": "/car_wash/coupon", "about": "/s/about", "help": "/s/help", "shop": "/shop/"}
next_url = dict_next.get(weixin_state, "/car_wash/")
return HttpResponseRedirect(next_url)
else:
error_msg = result or u'微信登陆失败，请重试'
return HttpResponse(error_msg)
return HttpResponse(u'code is %s' % (code, ))
def modify_user(request):
user_id = request.REQUEST.get('user_id')
nick = request.REQUEST.get('nick')
gender = request.REQUEST.get('gender')
birthday = request.REQUEST.get('birthday')
des = request.REQUEST.get('des')
state = int(request.REQUEST.get('state'))
user = UserBase().get_user_by_id(user_id)
return UserBase().change_profile(user, nick, gender, birthday, des, state)
def search(request):
user_nick = request.REQUEST.get('user_nick')
page_index = int(request.REQUEST.get('page_index', 1))
order = request.REQUEST.get('order', 'register_date')
email = request.REQUEST.get('email')
users = []
ub = UserBase()
users = ub.get_user_for_admin(user_nick,
order if order != "register_date" else "id",
email)
page_objs = page.Cpt(users, count=10, page=page_index).info
# 格式化
format_users = [
ub.format_user_full_info(
x.id if not isinstance(x.id, long) else x.user_id)
for x in page_objs[0]
]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'question_count': user.user_count['user_question_count'],
'answer_count': user.user_count['user_answer_count'],
'liked_count': user.user_count['user_liked_count'],
'follower_count': user.user_count['follower_count'],
'following_count': user.user_count['following_count'],
'is_recommend': user.is_recommend,
'is_admin': user.is_admin,
'is_customer_manager': user.is_customer_manager,
'last_active': str(user.last_active),
'state': user.state,
'ip': user.ip
})
return HttpResponse(json.dumps({
'data': data,
'page_count': page_objs[4],
'total_count': page_objs[5]
}),
mimetype='application/json')
def search(request):
user_nick = request.REQUEST.get('user_nick')
page_index = int(request.REQUEST.get('page_index', 1))
order = request.REQUEST.get('order', 'register_date')
data = []
users = []
ub = UserBase()
# 精确匹配
if user_nick:
users = ub.get_user_by_nick(user_nick)
users = [users] if users else []
else:
# 默认排序
if order == "register_date":
users = ub.get_all_users()
# 根据各种数量排序
else:
users = UserCountBase().get_all_users_by_order_count(order)
page_objs = page.Cpt(users, count=10, page=page_index).info
# 格式化
format_users = [ub.format_user_full_info(x.id if not isinstance(x.id, long) else x.user_id) for x in page_objs[0]]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'is_admin': user.is_admin,
'last_active': str(user.last_active),
'state': user.state,
'source': user.source_display,
'ip': user.ip
})
return HttpResponse(
json.dumps({'data': data, 'page_count': page_objs[4], 'total_count': page_objs[5]}),
mimetype='application/json'
)
def format_invite_user(self, show_invite_users, invited_users):
from www.custom_tags.templatetags.custom_filters import str_display
show_invite_users_json = []
invited_users_json = []
invited_user_ids = [iu.to_user_id for iu in invited_users]
for siu in show_invite_users:
user = UserBase().get_user_by_id(siu.user_id)
show_invite_users_json.append(dict(user_id=user.id, user_nick=user.nick, user_avatar=user.get_avatar_65(), gender=user.gender,
user_des=str_display((user.des or '').strip(), 17), is_invited=siu.user_id in invited_user_ids))
for iu in invited_users:
invited_users_json.append(dict(user_id=iu.to_user_id, user_nick=UserBase().get_user_by_id(iu.to_user_id).nick))
return show_invite_users_json, invited_users_json
def check_user_is_cm(self, company_id, user):
"""
@note: 判断用户是否是某个公司管理员
"""
try:
if isinstance(user, (str, unicode)):
user = UserBase().get_user_by_id(user)
cm = CompanyManager.objects.filter(company__id=company_id, user_id=user.id)
return True if (cm or user.is_staff()) else False
except Exception, e:
return False
def handle(self, *args, **options):
print u'==================初始化权限数据开始...'
cache = {}
for p in consts.PERMISSIONS:
obj, created = Permission.objects.get_or_create(name=p['name'],
code=p['code'])
cache[obj.code] = obj.id
# 设置父节点
if p['parent']:
obj.parent_id = cache[p['parent']]
obj.save()
print u'==================初始化权限数据完成'
print
email = options.get('user')
if email:
print u'==================设置[%s]为管理员...' % email
user = UserBase().get_user_by_email(email)
if not user:
print u'==================没有该用户，设置管理员失败...'
else:
permissions = [x.id for x in Permission.objects.all()]
code, msg = PermissionBase().save_user_permission(
user.id, permissions, user.id)
if code == 0:
print u'==================添加管理员成功'
else:
print u'==================%s, 设置管理员失败...' % msg
def search_auto_complete(request):
'''
@note: 搜索自动补全
'''
from www.custom_tags.templatetags.custom_filters import str_display
from www.account.interface import UserBase
key = request.REQUEST.get('key', '').strip()
data = []
if key:
users = UserBase().search_users(key)[:5]
questions = qb.search_questions(key)[:5]
i = 1
for user in users:
data.append(
dict(type="user",
value=str(i),
data=user.nick,
des=str_display((user.des or '').strip(), 30),
avatar=user.get_avatar_65(),
url=user.get_url()))
i += 1
for question in questions:
data.append(
dict(type="question",
value=str(i),
data=str_display(question.title, 25),
answer_count=question.answer_count,
url=question.get_url()))
i += 1
return HttpResponse(json.dumps(data), mimetype='application/json')
def main():
from www.tasks import async_send_email_worker
from common import utils
from www.kaihu.models import CustomerManager
from www.account.interface import UserBase
count = 0
for cm in CustomerManager.objects.filter(state=True):
user = UserBase().get_user_by_id(cm.user_id)
if "@a.com" in user.email:
continue
print user.email
print count
count += 1
if count < 43:
continue
context = dict(user=user)
try:
async_send_email_worker(
user.email, u'智选双十一活动，一场属于证券客户经理的狂欢',
utils.render_email_template('email/ad/11_email.html', context),
'html')
except Exception, e:
print e
def modify_important(request):
'''
修改精选
'''
qb = QuestionBase()
img_alt = request.REQUEST.get('imgAlt', '')
sort_num = request.REQUEST.get('sort', 0)
question_id = request.REQUEST.get('questionId')
question = qb.get_question_by_id(question_id)
img = request.FILES.get('importantImg')
iq = qb.get_important_question_by_question_id(question_id)
img_name = iq.img
# 如果有上传图片
if img:
flag, img_name = qiniu_client.upload_img(img, img_type='important')
img_name = '%s/%s' % (settings.IMG0_DOMAIN, img_name)
title = request.REQUEST.get('title')
summary = request.REQUEST.get('summary')
author = request.REQUEST.get('author')
author_id = None
# 作者
if author:
author = UserBase().get_user_by_nick(author)
if author:
author_id = author.id
code, msg = qb.set_important(question, request.user, title, summary, author_id, img_name, img_alt, sort_num)
url = '/admin/question/important_question#modify/%s' % iq.question.id
return HttpResponseRedirect(url)
def add_important(request):
'''
添加精选
'''
img = request.FILES.get('importantImg')
flag, img_name = qiniu_client.upload_img(img, img_type='important')
qb = QuestionBase()
question_id = request.REQUEST.get('questionId')
question = qb.get_question_by_id(question_id)
img_alt = request.REQUEST.get('imgAlt', '')
sort_num = request.REQUEST.get('sort', 0)
title = request.REQUEST.get('title')
summary = request.REQUEST.get('summary')
author = request.REQUEST.get('author')
author_id = None
# 作者
if author:
author = UserBase().get_user_by_nick(author)
if author:
author_id = author.id
code, msg = qb.set_important(question, request.user, title, summary, author_id, '%s/%s' % (settings.IMG0_DOMAIN, img_name), img_alt, sort_num)
url = ''
if code == 0:
iq = qb.get_important_question_by_question_id(question_id)
url = '/admin/question/important_question#modify/%s' % iq.question.id
else:
url = request.META['HTTP_REFERER']
return HttpResponseRedirect(url)
def get_important_question_by_question_id(request):
question_id = request.REQUEST.get('question_id')
data = ''
important_question = QuestionBase().get_important_question_by_question_id(question_id)
if important_question:
author = None
if important_question.author_user_id:
author = UserBase().get_user_by_id(important_question.author_user_id)
data = {
'question_id': important_question.question.id,
'user_id': important_question.question.user.id,
'user_nick': important_question.question.user.nick,
'title': important_question.title,
'summary': important_question.summary,
'author': author.nick if author else '',
'img': important_question.img,
'img_alt': important_question.img_alt,
'sort_num': important_question.sort_num,
'create_time': str(important_question.question.create_time),
'set_important_time': str(important_question.create_time)
}
return HttpResponse(json.dumps(data), mimetype='application/json')
def get_sensitive_operation_log(request):
nick = request.REQUEST.get('nick')
page_index = int(request.REQUEST.get('page_index', 1))
objs = SensitiveOperationLogBase().search_logs_for_admin(nick)
page_objs = page.Cpt(objs, count=10, page=page_index).info
data = []
num = 10 * (page_index - 1) + 0
for log in page_objs[0]:
num += 1
user = UserBase().get_user_by_id(log.user_id)
data.append({
'num': num,
'user_id': user.id,
'user_nick': user.nick,
'url': log.url,
'create_date': str(log.create_time),
'data': log.data
})
return HttpResponse(json.dumps({
'data': data,
'page_count': page_objs[4],
'total_count': page_objs[5]
}),
mimetype='application/json')
def regist(request, template_name='account/regist.html'):
email = request.POST.get('email', '').strip()
nick = request.POST.get('nick', '').strip()
password = request.POST.get('password', '').strip()
if request.POST:
ub = UserBase()
flag, result = ub.regist_user(email, nick, password, ip=utils.get_clientip(request))
if flag:
user = auth.authenticate(username=email, password=password)
auth.login(request, user=user)
next_url = request.session.get('next_url') or '/home'
request.session.update(dict(next_url=''))
return HttpResponseRedirect(next_url)
else:
error_msg = result
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def qiniu_img_return(request):
'''
@note: 七牛设置图片回调url
'''
from www.account.interface import UserBase
upload_ret = base64.b64decode(request.GET.get('upload_ret', ''))
try:
ur = json.loads(upload_ret)
except:
ur = {}
img_key = ur.get('key', '')
img_type = ur.get('img_type', '')
if img_key and img_type.startswith('avatar'):
user = request.user
user.avatar = '%s/%s' % (settings.IMG0_DOMAIN, img_key)
user.save()
# 更新缓存
UserBase().get_user_by_id(user.id, must_update_cache=True)
# 上传完头像之后 跳转到设置页面时带上 需要裁剪参数
return HttpResponseRedirect('/account/user_settings?crop_avatar=true')
return HttpResponse(
'上传图片出错，请重新上传 <a href="javascript:history.go(-1);">立即返回</a>')
def set_important(self,
journey,
user,
title,
summary,
author_user_id=None,
img='',
img_alt=None,
sort_num=0):
try:
if author_user_id and not UserBase().get_user_by_id(
author_user_id):
transaction.rollback(using=JOURNEY_DB)
return 99600, dict_err.get(99600)
try:
assert journey and user and title and summary
except:
transaction.rollback(using=JOURNEY_DB)
return 99800, dict_err.get(99800)
journey.is_important = True
journey.save()
transaction.commit(using=JOURNEY_DB)
return 0, dict_err.get(0)
except Exception, e:
debug.get_debug_detail(e)
transaction.rollback(using=JOURNEY_DB)
return 99900, dict_err.get(99900)
def oauth_sina(request):
from www.misc.oauth2.sina import Consumer
client = Consumer()
code = request.REQUEST.get('code')
if not code:
return HttpResponseRedirect(client.authorize())
else:
# 获取access_token
dict_result = client.token(code)
access_token = dict_result.get('access_token')
# 获取用户信息
openid = dict_result['uid']
user_info = client.request_api(access_token, '/2/users/show.json', data=dict(access_token=access_token, uid=openid))
# pprint(user_info)
user_info = format_external_user_info(user_info, 'sina')
flag, result = UserBase().get_user_by_external_info(source='sina', access_token=access_token, external_user_id=openid,
refresh_token=dict_result['refresh_token'], nick=user_info['nick'],
ip=utils.get_clientip(request), expire_time=dict_result['expires_in'],
user_url=user_info['url'], gender=user_info['gender'])
if flag:
user = result
user.backend = 'www.middleware.user_backend.AuthBackend'
auth.login(request, user)
next_url = request.session.get('next_url') or '/'
request.session.update(dict(next_url=''))
return HttpResponseRedirect(next_url)
else:
error_msg = result or u'新浪微博账号登陆失败，请重试'
return render_to_response('account/login.html', locals(), context_instance=RequestContext(request))
return HttpResponse(u'code is %s' % code)
def format_customer_managers(self, objs):
for obj in objs:
obj.user = UserBase().get_user_by_id(obj.user_id)
obj.user.user_count_info = UserCountBase().get_user_count_info(
obj.user_id)
obj.department = DepartmentBase().get_department_by_id(
obj.department.id) # 得到city信息
return objs
def get_user_permissions(request):
'''
获取用户对应权限
'''
user_id = request.REQUEST.get('user_id')
data = PermissionBase().get_user_permissions(user_id)
user = UserBase().get_user_by_id(user_id)
return HttpResponse(json.dumps({'permissions': data, 'user': {'user_id': user.id, 'user_nick': user.nick}}), mimetype='application/json')
def get_active_user(request):
page_index = int(request.REQUEST.get('page_index', 1))
now = datetime.datetime.now()
today = datetime.datetime(now.year, now.month, now.day)
ub = UserBase()
objs = ub.get_active_users(today)
page_objs = page.Cpt(objs, count=10, page=page_index).info
# 格式化
format_users = [ub.format_user_full_info(x.user_id) for x in page_objs[0]]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_nick': user.nick,
'user_des': str_display(user.des, 17),
'question_count': user.user_count['user_question_count'],
'answer_count': user.user_count['user_answer_count'],
'liked_count': user.user_count['user_liked_count'],
'follower_count': user.user_count['follower_count'],
'following_count': user.user_count['following_count'],
'is_recommend': user.is_recommend,
'is_admin': user.is_admin,
'is_customer_manager': user.is_customer_manager,
'last_active': str(user.last_active),
'state': user.state,
'ip': user.last_active_ip
})
return HttpResponse(json.dumps({
'data': data,
'page_count': page_objs[4],
'total_count': page_objs[5]
}),
mimetype='application/json')
def search(request):
user_nick = request.REQUEST.get('user_nick')
page_index = int(request.REQUEST.get('page_index', 1))
order = request.REQUEST.get('order', 'register_date')
email = request.REQUEST.get('email')
users = []
ub = UserBase()
users = ub.get_user_for_admin(user_nick, order if order!="register_date" else "id", email)
page_objs = page.Cpt(users, count=10, page=page_index).info
# 格式化
format_users = [ub.format_user_full_info(x.id if not isinstance(x.id, long) else x.user_id) for x in page_objs[0]]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'question_count': user.user_count['user_question_count'],
'answer_count': user.user_count['user_answer_count'],
'liked_count': user.user_count['user_liked_count'],
'follower_count': user.user_count['follower_count'],
'following_count': user.user_count['following_count'],
'is_recommend': user.is_recommend,
'is_admin': user.is_admin,
'is_customer_manager': user.is_customer_manager,
'last_active': str(user.last_active),
'state': user.state,
'ip': user.ip
})
return HttpResponse(
json.dumps({'data': data, 'page_count': page_objs[4], 'total_count': page_objs[5]}),
mimetype='application/json'
)
def search(request):
user_nick = request.REQUEST.get('user_nick')
page_index = int(request.REQUEST.get('page_index', 1))
email = request.REQUEST.get('email')
users = []
ub = UserBase()
users = ub.get_user_for_admin(user_nick, email)
page_objs = page.Cpt(users, count=10, page=page_index).info
# 格式化
format_users = [
ub.format_user_full_info(
x.id if not isinstance(x.id, long) else x.user_id)
for x in page_objs[0]
]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_65(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'is_admin': user.is_admin,
'last_active': str(user.last_active),
'register_date': str(user.create_time),
'state': user.state,
'source': user.source_display,
'ip': user.ip
})
return HttpResponse(json.dumps({
'data': data,
'page_count': page_objs[4],
'total_count': page_objs[5]
}),
mimetype='application/json')
def add_user(request):
email = request.POST.get('email', '').strip()
nick = request.POST.get('nick', '').strip()
password = request.POST.get('password', '').strip()
re_password = request.POST.get('re_password', '').strip()
ip = utils.get_clientip(request)
flag, msg = UserBase().regist_user(email, nick, password, re_password, ip)
return flag, msg.id if flag == 0 else msg
def get_active_user(request):
page_index = int(request.REQUEST.get('page_index', 1))
now = datetime.datetime.now()
today = datetime.datetime(now.year, now.month, now.day)
ub = UserBase()
objs = ub.get_active_users(today)
page_objs = page.Cpt(objs, count=10, page=page_index).info
# 格式化
format_users = [ub.format_user_full_info(x.user_id) for x in page_objs[0]]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_25(),
'user_nick': user.nick,
'user_des': str_display(user.des, 17),
'question_count': user.user_count['user_question_count'],
'answer_count': user.user_count['user_answer_count'],
'liked_count': user.user_count['user_liked_count'],
'follower_count': user.user_count['follower_count'],
'following_count': user.user_count['following_count'],
'is_recommend': user.is_recommend,
'is_admin': user.is_admin,
'is_customer_manager': user.is_customer_manager,
'last_active': str(user.last_active),
'state': user.state,
'ip': user.last_active_ip
})
return HttpResponse(
json.dumps({'data': data, 'page_count': page_objs[4], 'total_count': page_objs[5]}),
mimetype='application/json'
)
def search(request):
from www.account.interface import UserBase
search_type = request.REQUEST.get('type', 'question').strip()
if search_type not in ("question", "answer", "user"):
raise Http404
key_words = request.REQUEST.get('key_words', '').strip()
if not key_words:
info_msg = u"请输入搜索关键词"
page_num = int(request.REQUEST.get('page', 1))
page_num = 20 if page_num > 20 else page_num
page_objs = None
if search_type == "question":
questions = qb.search_questions(key_words)
page_objs = page.Cpt(questions, count=10, page=page_num).info
questions = page_objs[0]
questions = qb.format_quesitons(questions)
if search_type == "answer":
if len(key_words) < 4:
info_msg = u"搜索回答最少输入4个字"
else:
answers = ab.search_answers(key_words)
page_objs = page.Cpt(answers, count=10, page=page_num).info
answers = page_objs[0]
answers = ab.format_answers(answers)
if search_type == "user":
users = UserBase().search_users(key_words)
page_objs = page.Cpt(users, count=10, page=page_num).info
users = page_objs[0]
users = [
UserBase().format_user_with_count_info(user) for user in users
]
page_params = (page_objs[1], page_objs[4]) if page_objs else (1, 1)
return render_to_response('question/search_%s.html' % search_type,
locals(),
context_instance=RequestContext(request))
def search(request):
user_nick = request.REQUEST.get('user_nick')
page_index = int(request.REQUEST.get('page_index', 1))
des = request.REQUEST.get('des')
users = []
ub = UserBase()
users = ub.get_user_for_admin(user_nick, des)
page_objs = page.Cpt(users, count=10, page=page_index).info
# 格式化
format_users = [ub.format_user_full_info(x.id if not isinstance(x.id, long) else x.user_id) for x in page_objs[0]]
data = []
num = 10 * (page_index - 1) + 0
for user in format_users:
num += 1
data.append({
'num': num,
'user_id': user.id,
'user_avatar': user.get_avatar_65(),
'user_nick': user.nick,
'user_des': user.des,
'user_email': user.email,
'user_mobilenumber': user.mobilenumber,
'is_admin': user.is_admin,
'last_active': str(user.last_active),
'register_date': str(user.create_time),
'state': user.state,
'source': user.source_display,
'is_sub_weixin': user.is_sub_weixin,
'invite_user_id': user.invite_user_id or '',
'invite_user_nick': user.invite_user_nick or '',
'ip': user.ip
})
return HttpResponse(
json.dumps({'data': data, 'page_count': page_objs[4], 'total_count': page_objs[5]}),
mimetype='application/json'
)
def crop_img(request):
'''
裁剪图片
这里使用的是七牛的裁剪接口,具体参见 http://docs.qiniutek.com/v3/api/foimg/#imageMogr
将剪裁坐标传递给七牛，七牛会返回按此参数剪裁后的图片回来，然后再将此图片作为用户头像上传给七牛
'''
from www.account.interface import UserBase
def _verfiy_int(target, r):
'''
验证参数合法性
target: 要验证的值
r: 范围
'''
if target and target.isdigit():
if (r[0] <= int(target)) and (int(target) <= r[1]):
return True
return False
x = request.REQUEST.get('x', None)
y = request.REQUEST.get('y', None)
w = request.REQUEST.get('w', None)
h = request.REQUEST.get('h', None)
result = dict(flag='-1', result=u'参数错误')
if all((_verfiy_int(x, [0, 300]), _verfiy_int(y, [0, 300]),
_verfiy_int(w, [25, 300]), _verfiy_int(h, [25, 300]))):
img_name_original = request.user.avatar.rsplit('/', 1)[1]
# 剪切不支持缩略图，修改成重新获取一次图片
flag, img_name_450 = qiniu_client.upload_img(
urllib.urlopen(request.user.get_avatar_450()))
if flag:
# 拼接给七牛的参数
post_url = '%s/%s?imageMogr2/crop/!%sx%sa%sa%s' % (
settings.IMG0_DOMAIN, img_name_450, w, h, x, y)
# 上传图片
flag, img_name = qiniu_client.upload_img(urllib.urlopen(post_url),
img_type='newest_avatar')
if flag:
url = '%s/%s' % (settings.IMG0_DOMAIN, img_name)
# 将新的图片地址指向当前用户
user = request.user
user.avatar = url
user.save()
# 更新缓存
UserBase().get_user_by_id(user.id, must_update_cache=True)
result = dict(flag='0', result=u'ok')
# 删除多余的两张图片节省空间
qiniu_client.batch_delete([img_name_original, img_name_450])
else:
result = dict(flag='-1', result=u'剪裁失败, 请稍后重试')
return HttpResponse(json.dumps(result), mimetype='application/json')
def get_statistics_commission_data(request):
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
start_date, end_date = utils.get_date_range(start_date, end_date)
data = {}
for x in StatisticsBase().statistics_commission(start_date, end_date):
key = x.company.invite_by
user = UserBase().get_user_by_id(key)
if not data.has_key(key):
data[key] = {
'user_id': key,
'user_nick': user.nick,
'user_avatar': user.get_avatar_65(),
'total_price': 0,
'meals': []
}
# 订单金额 199以上的奖励100 其他奖励50
temp_price = 100 if x.price >= 199 else 50
data[key]['total_price'] += temp_price
data[key]['meals'].append({
'company_name': x.company.name,
'company_short_name': x.company.short_name,
'meal_name': x.name,
'meal_price': str(x.price),
'date': str(x.company.sale_date)[:10],
'user_nick': user.nick,
'price': str(temp_price)
})
for x in data.values():
x['total_price'] = str(x['total_price'])
return HttpResponse(
json.dumps(data.values()),
mimetype='application/json'
)
def select_city(request, city_id):
from www.account.interface import UserBase
city = cb.get_city_by_id(city_id)
if not city:
raise Http404
if request.user.is_authenticated():
UserBase().change_user_city(request.user.id, city_id)
request.session["city_id"] = city_id
return HttpResponseRedirect("/car_wash/")
def get_all_administrators(self):
'''
获取所有管理员
'''
user_ids = [
x['user_id']
for x in UserPermission.objects.values('user_id').annotate(
dcount=Count('user_id'))
]
return [UserBase().get_user_by_id(x) for x in user_ids]
def format_active(objs, num):
data = []
for x in objs:
num += 1
user = UserBase().get_user_by_id(x.user_id)
data.append({
'num': num,
'id': x.id,
'name': user.nick if user else '',
'avatar': user.get_avatar_65() if user else '',
'gender': user.get_gender_display() if user else '',
'des': user.des if user else '',
'ip': x.ip,
'last_active_time': str(x.last_active_time),
'last_active_source': x.get_last_active_source_display()
})
return data
def format_feeds_by_id(self, feed_ids):
from www.question.interface import QuestionBase, AnswerBase
from www.stock.interface import StockFeedBase
feeds = []
for feed_id in feed_ids:
feed = self.get_feed_by_id(feed_id)
dict_feed = dict(feed_id=feed.id, create_time=feed.create_time.strftime('%Y-%m-%d %H:%M:%S'), feed_type=feed.feed_type)
if feed.source == 0: # 用户产生的动态
user = UserBase().get_user_by_id(feed.user_id)
obj_info = dict(user_id=feed.user_id, user_avatar=user.get_avatar_65(), user_nick=user.nick)
if feed.feed_type in (1,):
obj_info.update(QuestionBase().get_question_summary_by_id(feed.obj_id))
elif feed.feed_type in (2, 3):
obj_info.update(AnswerBase().get_answer_summary_by_id(feed.obj_id))
if feed.source == 1: # 股票产生的动态
obj_info = StockFeedBase().get_stock_feed_summary_by_id(feed.obj_id)
dict_feed.update(obj_info)
feeds.append(dict_feed)
return feeds
def format_customer_managers_for_ajax(self, objs):
data = []
for obj in objs:
if not obj:
continue
user = UserBase().get_user_by_id(obj.user_id)
if user == "":
continue
user_count_info = UserCountBase().get_user_count_info(obj.user_id)
data.append(dict(user_id=user.id, user_nick=self.get_cm_nick_show(obj.real_name, user.nick), user_avatar=user.get_avatar_100(),
department_name=obj.department.get_short_name(), company_short_name=obj.department.company.get_short_name(),
department_id=obj.department.id, city_id=obj.city_id,
sort_num=obj.sort_num, vip_info=obj.vip_info, qq=obj.qq, mobile=obj.mobile, pay_type=obj.pay_type,
user_question_count=user_count_info['user_question_count'], user_answer_count=user_count_info['user_answer_count'],
user_liked_count=user_count_info['user_liked_count'],
))
return data
def authenticate(self, username=None, password=None):
ub = UserBase()
user = ub.get_user_by_email(username)
if not user:
user = ub.get_user_by_mobilenumber(username)
if user and ub.check_password(password, user.password):
# 更新最后登录时间
user_login = user.user_login
user_login.last_login = datetime.datetime.now()
user_login.save()
user.save = _save
# 更新缓存
ub.get_user_by_id(user.id, must_update_cache=True)
return user
def get_statistics_sale_top_data(request):
start_date = request.POST.get('start_date')
end_date = request.POST.get('end_date')
start_date, end_date = utils.get_date_range(start_date, end_date)
# 获取所有销售人员列表
sale_man_dict = {}
for x in SaleManBase().get_all_sale_man(True):
user = UserBase().get_user_by_id(x.user_id)
sale_man_dict[x.user_id] = {
'sale_by_id': x.user_id,
'sale_by_nick': user.nick,
'sale_by_avatar': user.get_avatar_65(),
'total': 0,
'meals': [],
'companys': []
}
# 获取符合条件的销售数据
data = {}
objs = StatisticsBase().statistics_sale(start_date, end_date)
for x in objs:
key = x.company.sale_by
if not data.has_key(key):
user = UserBase().get_user_by_id(key)
data[key] = {
'sale_by_id': key,
'sale_by_nick': user.nick,
'sale_by_avatar': user.get_avatar_65(),
'total': 0,
'meals': [],
'companys': []
}
data[key]['total'] += x.get_expect_price_per_month(start_date, end_date, x.company.sale_date)
data[key]['meals'].append({
'meal_name': x.name,
'company_name': x.company.name,
'sale_date': str(x.company.sale_date)[:10],
'cycle': x.cycle,
't_type': x.get_t_type_display(),
'price': str(x.price),
'expect_price': str(x.get_expect_price_per_month(start_date, end_date, x.company.sale_date))
})
data[key]['companys'].append(x.company.id)
# 合并数据
sale_man_dict.update(data)
data = sale_man_dict.values()
data.sort(key=lambda x: x['total'], reverse=True)
# 获取最大的销售额，用于计算比率
max_total = data[0]['total'] if data else 0
all_company = 0
all_total = 0
for x in data:
# 计算比率
x['rate'] = round(x['total'] / max_total * 100, 1) if max_total != 0 else 0
# 转json
all_total += x['total']
x['total'] = str(x['total']) if x['total'] > 0 else '0'
# 计算总公司
x['companys'] = len(set(x['companys']))
all_company += x['companys']
average_company = round(all_total / (all_company or 1 ), 1)
average_company = str(average_company)
all_total = str(all_total)
return HttpResponse(
json.dumps({'data': data, 'all_total': all_total, 'all_company': all_company, 'average_company': average_company}),
mimetype='application/json'
)
