def send_activation_mail(user_email, customer_user_id, customer_user_auth_id):
"""发送邮箱账号激活邮件
:param user_email: 用户邮箱地址
:param customer_user_id: 用户ID
:param customer_user_auth_id: 用户邮箱权限ID
:return:
"""
send_result = False
try:
mail_subject = "智量酷邮箱账号激活"
mail_content = "点击此链接完成激活，"
activation_link = "http://www.zhiliangku.com/customuser/activation?hash="
email_str = "|".join(
[user_email,
str(customer_user_id),
str(customer_user_auth_id)])
pycrypt_obj = PyCrypt(CryptKey)
crypt_email = pycrypt_obj.encrypt(email_str)
mail_content = "".join([mail_content, activation_link, crypt_email])
send_result = sendmail(user_email, mail_subject, mail_content)
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
finally:
return send_result
def post(self, request, *args, **kwargs):
result_dict = {"msg": "短信找回密码失败", "err": 1, "data": {}}
try:
param_dict = json.loads(request.body)
phone = param_dict.get("phone")
verify_code = param_dict.get("verify_code") # 验证码
new_password = param_dict.get("new_password")
# 校验验证码
valid_filter = {
"phone": phone,
"is_use": False,
"code": verify_code,
"expire_time__gt": timezone.now(),
}
is_valid = VerifyCode.objects.filter(**valid_filter)
if not is_valid.exists():
result_dict["err"] = 0
result_dict["msg"] = "无效的验证码"
else:
filter_dict = {
"identifier": phone,
"identity_type": "phone",
}
customuserauths_objs = CustomUserAuths.objects.filter(
**filter_dict)
if customuserauths_objs.exists():
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(new_password)
update_filter = {
"custom_user_id":
customuserauths_objs.first().custom_user_id,
"identity_type__in": ["phone", "email"],
}
update_result = CustomUserAuths.objects.filter(
**update_filter).update(credential=crypt_password)
if update_result:
result_dict["err"] = 0
result_dict["msg"] = "密码重置成功"
else:
result_dict["msg"] = "用户账户不存在"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = '短信找回密码异常, %s' % traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def get(self, request, *args, **kwargs):
result_dict = {"msg": "邮箱激活失败。", "err": 1, "data": {}}
try:
hash_str = request.GET.get("hash")
pycrypt_obj = PyCrypt(CryptKey)
crypt_str = pycrypt_obj.decrypt(hash_str)
user_info_list = crypt_str.split("|")
if len(user_info_list) == 3:
user_email = user_info_list[0]
customer_user_id = user_info_list[1]
customer_user_auth_id = user_info_list[2]
filter_dict = {
"id": customer_user_auth_id,
"custom_user_id": customer_user_id,
"identity_type": "email",
"identifier": user_email,
}
customuserauths_obj = CustomUserAuths.objects.filter(
**filter_dict)
if customuserauths_obj.exists():
update_result = customuserauths_obj.update(status=True)
if update_result:
result_dict["err"] = 0
result_dict["msg"] = "邮箱激活成功"
else:
result_dict["err"] = 2
result_dict["msg"] = "待激活邮箱账户不存在"
else:
result_dict["err"] = 5
result_dict["msg"] = "邮箱激活参数错误"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = '通过邮箱激活账户异常, %s' % traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {
"err": 1,
"msg": "修改失败",
}
try:
param_dict = json.loads(request.body)
custom_user_id = param_dict.get('custom_user_id', 0) # 用户ID
old_password = param_dict.get('old_password', "") # 旧密码
password = param_dict.get('password', "") # 新密码
filter_param = {
"custom_user_id__id": custom_user_id,
"identity_type__in": ["email", "phone"]
}
customuserauths = CustomUserAuths.objects.filter(**filter_param)
if customuserauths.exists():
# 比对旧密码
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(old_password)
if customuserauths.filter(credential=crypt_password).exists():
new_crypt_password = pycrypt_obj.encrypt(password)
customuserauths.update(credential=new_crypt_password)
result_dict["err"] = 0
result_dict["msg"] = "成功重置密码"
else:
result_dict["msg"] = "旧密码错误"
else:
result_dict["msg"] = "未绑定邮箱/手机账号"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["msg"] = traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {"msg": "找回密码邮箱验证信息发送失败", "err": 1, "data": {}}
try:
param_dict = json.loads(request.body)
email = param_dict.get("email")
filter_dict = {
"identifier": email,
"identity_type": "email",
}
customuserauths_objs = CustomUserAuths.objects.filter(
**filter_dict)
if customuserauths_objs.exists():
mail_subject = "智量酷邮箱密码找回"
mail_content = "点击此链接完成密码找回，"
activation_link = "http://www.zhiliangku.com/customuser/retrieve_password_by_email?hash="
pycrypt_obj = PyCrypt(CryptKey)
crypt_email = pycrypt_obj.encrypt(email)
mail_content = "".join(
[mail_content, activation_link, crypt_email])
send_result = sendmail(email, mail_subject, mail_content)
if not send_result:
result_dict["msg"] = "邮箱密码找回链接发送失败"
else:
result_dict["msg"] = "邮箱密码找回链接发送成功"
result_dict["err"] = 0
else:
result_dict["msg"] = "账户不存在"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = '找回密码邮箱验证信息发送异常, %s' % traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {
"msg": "短信找回密码失败",
"err": 1,
}
try:
param_dict = json.loads(request.body)
email_hash = param_dict.get("hash")
new_password = param_dict.get("password")
pycrypt_obj = PyCrypt(CryptKey)
email = pycrypt_obj.decrypt(email_hash)
filter_dict = {
"identifier": email,
"identity_type": "email",
}
customuserauths_objs = CustomUserAuths.objects.filter(
**filter_dict)
if customuserauths_objs.exists():
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(new_password)
update_filter = {
"custom_user_id":
customuserauths_objs.first().custom_user_id,
"identity_type__in": ["phone", "email"],
}
update_result = CustomUserAuths.objects.filter(
**update_filter).update(credential=crypt_password)
if update_result:
result_dict["err"] = 0
result_dict["msg"] = "密码重置成功"
else:
result_dict["msg"] = "用户账户不存在"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = '邮箱找回密码异常, %s' % traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {
"err": 0,
"msg": "success",
}
try:
param_dict = json.loads(request.body)
custom_user_id = param_dict.get('custom_user_id', 0) # 用户ID
phone = param_dict.get('phone', "") # 手机号
password = param_dict.get('password') # 密码
verify_code = param_dict.get("verify_code") # 验证码
# 校验验证码
valid_filter = {
"phone": phone,
"is_use": False,
"code": verify_code,
"expire_time__gt": timezone.now(),
}
verifycodes = VerifyCode.objects.filter(**valid_filter)
if not verifycodes.exists():
result_dict["err"] = 7
result_dict["msg"] = "无效的验证码"
return
else:
VerifyCode.objects.filter(phone=phone).delete()
filter_param = {
"custom_user_id__id": custom_user_id,
"identity_type": "email"
}
customuserauths = CustomUserAuths.objects.filter(**filter_param)
filter_param.update({"identity_type": "phone"})
customuserauths_phone = CustomUserAuths.objects.filter(
**filter_param)
# 有邮箱账号，没有手机账号
if customuserauths.exists() and not customuserauths_phone.exists():
credential = customuserauths.first().credential
user_auth_dict = {
"custom_user_id":
CustomUser.objects.get(id=custom_user_id),
"identity_type": "phone",
"identifier": phone,
"credential": credential, # 密码凭证
"status": False,
}
obj = CustomUserAuths.objects.create(**user_auth_dict)
elif customuserauths_phone.exists():
obj = customuserauths_phone.update(identifier=phone)
else:
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(password)
user_auth_dict = {
"custom_user_id":
CustomUser.objects.get(id=custom_user_id),
"identity_type": "phone",
"identifier": phone,
"credential": crypt_password, # 密码凭证
}
obj = CustomUserAuths.objects.create(**user_auth_dict)
if not obj:
result_dict["err"] = 1
result_dict["msg"] = "手机账号绑定失败"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {
"err": 0,
"msg": "success",
}
try:
param_dict = json.loads(request.body)
custom_user_id = param_dict.get('custom_user_id', 0) # 用户ID
email = param_dict.get('email', "") # 邮箱地址
password = param_dict.get('password') # 密码
filter_param = {
"custom_user_id__id": custom_user_id,
"identity_type": "phone"
}
customuserauths = CustomUserAuths.objects.filter(**filter_param)
filter_param.update({"identity_type": "email"})
customuserauths_email = CustomUserAuths.objects.filter(
**filter_param)
is_mail = False
auth_id = 0
# 有手机账号，没有邮箱账号
if customuserauths.exists() and not customuserauths_email.exists():
credential = customuserauths.first().credential
user_auth_dict = {
"custom_user_id":
CustomUser.objects.get(id=custom_user_id),
"identity_type": "email",
"identifier": email,
"credential": credential, # 密码凭证
"status": False,
}
obj = CustomUserAuths.objects.create(**user_auth_dict)
if obj:
auth_id = obj.id
is_mail = True
elif customuserauths_email.exists():
rows = customuserauths_email.update(identifier=email,
status=False)
if rows:
auth_id = customuserauths_email.first().id
is_mail = True
else:
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(password)
user_auth_dict = {
"custom_user_id":
CustomUser.objects.get(id=custom_user_id),
"identity_type": "email",
"identifier": email,
"credential": crypt_password, # 密码凭证
"status": False,
}
obj = CustomUserAuths.objects.create(**user_auth_dict)
if obj:
auth_id = obj.id
is_mail = True
if is_mail and auth_id:
send_result = send_activation_mail(email, custom_user_id,
auth_id)
if not send_result:
result_dict["err"] = 1
result_dict["msg"] = "激活邮件发送失败"
else:
result_dict["err"] = 1
result_dict["msg"] = "邮箱账号绑定失败"
except:
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
result_dict["err"] = 1
result_dict["msg"] = traceback.format_exc()
finally:
return HttpResponse(json.dumps(result_dict, ensure_ascii=False))
def post(self, request, *args, **kwargs):
result_dict = {"msg": "注册失败", "err": 1, "data": {}}
token = ""
try:
param_dict = json.loads(request.body)
username = param_dict.get("username")
password = param_dict.get("password")
verify_code = param_dict.get("verify_code") # 验证码
is_mail = IsMail().ismail(username)
is_cellphone = IsCellphone().iscellphone(username)
# 权限类型
identity_type = ""
if is_mail:
identity_type = "email"
if is_cellphone:
identity_type = "phone"
# 校验验证码
valid_filter = {
"phone": username,
"is_use": False,
"code": verify_code,
"expire_time__gt": timezone.now(),
}
verifycodes = VerifyCode.objects.filter(**valid_filter)
if not verifycodes.exists():
result_dict["err"] = 7
result_dict["msg"] = "无效的验证码"
return
else:
VerifyCode.objects.filter(phone=username).delete()
# 校验是否有权限信息
custom_user_auths = CustomUserAuths.objects.filter(
identity_type=identity_type, identifier=username)
# 已经注册
if custom_user_auths.exists():
result_dict["msg"] = "已经注册过账号，请直接登录"
result_dict["err"] = 4
elif identity_type:
create_user = CustomUser.objects.create(nickname=username,
role=0)
if create_user:
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(password)
user_auth_dict = {
"custom_user_id": create_user,
"identity_type": identity_type,
"identifier": username,
"credential": crypt_password, # 密码凭证
}
if is_mail:
user_auth_dict.update({"status":
False}) # 邮箱账户，默认未激活状态
create_auth = CustomUserAuths.objects.create(
**user_auth_dict)
if create_auth:
# 生成token
token = get_validate(username, create_user.id, 0,
CryptKey)
result_dict["err"] = 0
result_dict["msg"] = "success"
# result_dict["data"]["token"] = token
result_dict["data"]["user"] = {
"uid":
create_user.id,
"nickname":
create_user.nickname,
"role":
create_user.role,
"avatar":
create_user.avatar.url
if create_user.avatar else "",
"position":
create_user.position
if create_user.position else "",
}
# user_dict = {
# "nickname": create_user.nickname,
# "uid": create_user.id,
# "avatar": create_user.avatar.url if create_user.avatar else ""
# }
# request.session['token'] = token
# request.session['user'] = user_dict
# request.session['login'] = True
if is_mail:
send_result = send_activation_mail(
username, create_user.id, create_auth.id)
if not send_result:
result_dict["err"] = 1
result_dict["msg"] = "激活邮件发送失败"
else:
create_user.delete()
result_dict["msg"] = "用户权限添加失败"
except:
result_dict["msg"] = traceback.format_exc()
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
finally:
res = HttpResponse(json.dumps(result_dict, ensure_ascii=False))
res.set_cookie("token", token)
return res
def post(self, request, *args, **kwargs):
result_dict = {"msg": "", "err": 1, "data": {}}
token = ""
try:
param_dict = json.loads(request.body)
username = param_dict.get("username")
password = param_dict.get("password")
is_mail = IsMail().ismail(username)
is_cellphone = IsCellphone().iscellphone(username)
# 权限类型判断
identity_type = ""
if is_mail:
identity_type = "email"
if is_cellphone:
identity_type = "phone"
# 校验是否有权限信息
custom_user_auths = CustomUserAuths.objects.filter(
identity_type=identity_type, identifier=username)
if not custom_user_auths.exists():
result_dict["msg"] = "您还没有账号，请先注册"
result_dict["err"] = 2
else:
custom_user_auth = custom_user_auths[0]
if custom_user_auth.status:
pycrypt_obj = PyCrypt(CryptKey)
crypt_password = pycrypt_obj.encrypt(password)
custom_user_pwd = custom_user_auth.credential # 密码凭证
custom_user_id = custom_user_auth.custom_user_id.id # 用户ID
custom_user_role = custom_user_auth.custom_user_id.role # 用户角色
if custom_user_pwd != crypt_password:
result_dict["msg"] = "账号或密码错误"
result_dict["err"] = 3
else:
token = get_validate(username, custom_user_id,
custom_user_role, CryptKey)
result_dict["msg"] = "success"
result_dict["err"] = 0
# result_dict["data"]["token"] = token
result_dict["data"]["user"] = {
"uid":
custom_user_auth.custom_user_id.id,
"nickname":
custom_user_auth.custom_user_id.nickname,
"role":
custom_user_auth.custom_user_id.role,
"avatar":
custom_user_auth.custom_user_id.avatar.url
if custom_user_auth.custom_user_id.avatar else "",
"position":
custom_user_auth.custom_user_id.position if
custom_user_auth.custom_user_id.position else "",
}
# user_dict = {
# "nickname": custom_user_auth.custom_user_id.nickname,
# "uid": custom_user_auth.custom_user_id.id,
# "avatar": custom_user_auth.custom_user_id.avatar.url if custom_user_auth.custom_user_id.avatar else ""
# }
# request.session['token'] = token
# request.session['user'] = user_dict
# request.session['login'] = True
else:
result_dict["msg"] = "账号未激活"
result_dict["err"] = 6
except:
result_dict["msg"] = traceback.format_exc()
traceback.print_exc()
logging.getLogger().error(traceback.format_exc())
finally:
res = HttpResponse(json.dumps(result_dict, ensure_ascii=False))
res.set_cookie("token", token)
return res