class TencentSMSService:
def __init__(self, appid, app_key, template_id):
self.sms_sender = SmsSingleSender(appid, app_key)
self.template_id = template_id
def send_sms(self, name, phone_number, timeout: int = 3):
code = random_string(string.digits, length=5)
params = [code, str(timeout)]
try:
self.sms_sender.send_with_param(
86, phone_number,
self.template_id, params, '', '', '')
except Exception as e:
# print(e)
return False
cache.set(f'sms:{phone_number}:{message_digest(name)}', code, timeout * 60 + 10)
return True
@staticmethod
def check_sms(name, phone_number, code):
cache_key = f'sms:{phone_number}:{message_digest(name)}'
real_code = cache.get(cache_key)
if code == real_code:
cache.delete(cache_key)
return True
return False
def send_phone_code(phone, code, minute):
global result_code
app_id = 1400082932
app_key = "4256aeadfa9394ff8728cf40d930e77f"
params = [str(code), str(minute)]
template_id = 107886
s_sender = SmsSingleSender(app_id, app_key)
err_msg = None
try:
result = s_sender.send_with_param(86, phone_number=phone, template_id=template_id, params=params)
print(result)
result_code = result.get('result', 0)
err_msg = result.get('errmsg', '')
if result_code != 0:
return result_code, err_msg
phone_record, created = PhoneVerifyRecord.objects.get_or_create(phone=phone)
phone_record.code = str(code)
phone_record.send_time = now()
phone_record.save()
except HTTPError as e:
print(e)
except Exception as e:
print(e)
finally:
return result_code, err_msg
def process_sms(message):
# 短信应用SDK AppID
appid = 1400064260 # SDK AppID是1400开头
# 短信应用SDK AppKey
appkey = "3777a2b8b44f77de3030460a7707d2ce"
# 需要发送短信的手机号码
phone_numbers = ["18616356197"]
# 短信模板ID，需要在短信应用中申请
template_id = 80067 # NOTE: 这里的模板ID`7839`只是一个示例，真实的模板ID需要在短信控制台中申请
# 签名
sms_sign = "DataBro" # NOTE: 这里的签名"腾讯云"只是一个示例，真实的签名需要在短信控制台中申请，另外签名参数使用的是`签名内容`，而不是`签名ID`
sms_type = 0 # Enum{0: 普通短信, 1: 营销短信}
ssender = SmsSingleSender(appid, appkey)
params = [datetime.datetime.now().strftime('%Y-%m-%d'),
message] # 当模板没有参数时，`params = []`
try:
result = ssender.send_with_param(86,
phone_numbers[0],
template_id,
params,
sign=sms_sign,
extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
print(e)
except Exception as e:
print(e)
def send_sms_single(tpl, mobile_phone):
"""使用腾讯云发送短信
tpl: 使用模板类型
mobile_phone : 电话号
"""
try:
# 短信应用ｉｄ
appid = SMS_APPID
# 短信应用 SDK AppKey
appkey = SMS_APPKEY
# 需要发送短信的手机号码
mobile_phone = mobile_phone
# 签名
sms_sign = "SaaSRenLei"
# 模板参数
if tpl == 'login':
params = ["".join(random.sample(string.digits, 4))]
else:
params = ["".join(random.sample(string.digits, 4)), 5]
# 短信模板ID，需要在短信控制台中申请
template_id = SMS_TEMPLATE[tpl]
except KeyError:
return HttpResponse("请求方式有误")
else:
ssender = SmsSingleSender(appid, appkey)
res = ssender.send_with_param(86,
mobile_phone,
template_id,
params,
sign=sms_sign)
if res == 0:
return HttpResponse(res)
else:
return HttpResponse(res['errmsg'])
def sendMsg(request):
# 短信应用 SDK AppID
appid = 1400 # ... # SDK AppID 以1400pip开头
appkey = "........."
template_id = 267071
ssender = SmsSingleSender(appid, appkey)
yzcode = random.randint(1000, 9999)
request.session["yzcode"] = yzcode
# request.session['yzcode'].setMaxInactiveInterval(60*1)
request.session.set_expiry(60)
params = ["{code}".format(code=yzcode)]
sms_type = 0 # Enum{0: 普通短信, 1: 营销短信}
phone_numbers = "{mobile}".format(mobile=request.GET['mobile'])
print("phone: ", phone_numbers)
sms_sign = "诗歌生成"
try:
# result = ssender.send_with_param(sms_type, 86, phone_numbers,template_id, params, sign=sms_sign, extend="", ext="" )
result = ssender.send_with_param(86,
phone_numbers,
template_id,
params,
sign=sms_sign,
extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
print("success 发送验证码: ", phone_numbers)
except HTTPError as e:
print(e)
except Exception as e:
print(e)
print(result)
return HttpResponse('发送成功')
def get_code(request):
import random
# appid=1400147763
# appkey='bbe0084c2a88e2f50a2364e83effbc5f'
tel = request.POST.get('tel')
code = random.randint(1000, 9999)
request.session['code'] = code #保存到字典 保存到后台session
request.session.set_expiry(600)
# 验证码有效时间10分钟
print(tel)
ssender = SmsSingleSender(1400147763, 'bbe0084c2a88e2f50a2364e83effbc5f')
phone_numbers = [tel]
# template_id = 205042
# sms_sign = "阿里优"
params = [
code, '10'
] # 当模板没有参数时，`params = []`，数组具体的元素个数和模板中变量个数必须一致，例如事例中templateId:5678对应一个变量，参数数组中元素个数也必须是一个
try:
result = ssender.send_with_param(86,
phone_numbers[0],
205042,
params,
sign="阿里优",
extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
print(result)
if result['result'] == 0:
return JsonResponse({'ok': 1})
else:
return JsonResponse({'ok': 0})
except HTTPError as e:
print(e)
except Exception as e:
print(e)
print(result)
def ssm(phone, g_name, g_type, menoy, time):
appid = 1400231462 # SDK AppID 以1400开头
# 短信应用 SDK AppKey
appkey = "e67d6231bce04f4e707a8d10673ac3cc"
# 需要发送短信的手机号码
template_id = 375220 # NOTE: 这里的模板 ID`7839`只是示例，真实的模板 ID 需要在短信控制台中申请
# 签名
sms_sign = '乐途网提醒' # NOTE: 签名参数使用的是`签名内容`，而不是`签名ID`。这里的签名"腾讯云"只是示例，真实的签名需要在短信控制台中申请
phone_numbers = [phone]
sms_type = 0 # Enum{0: 普通短信, 1: 营销短信}
params = [g_name, g_type, menoy, time]
ssender = SmsSingleSender(appid, appkey)
try:
result = ssender.send_with_param(86,
phone_numbers[0],
template_id,
params,
sign=sms_sign,
extend="",
ext="")
return result
except HTTPError as e:
print(e)
except Exception as e:
print(e)
def send_code(request):
"""Conf"""
#appid = "YOUR ID"
#appkey = "YOUR KEY"
template_id = 98106
expired_time = 5 #5 minutes
params = []
phone_numbers = []
# phone = request.POST.get('phone')
phone = '13886852429'
phone_numbers.append(phone)
smscode = getcode() # 随机生成5位验证码
params.insert(0, smscode)
params.append(expired_time)
request.session['smscode'] = smscode + phone # 把生成的验证码保存在session中
# print(request.session.get('smscode'))
# session_key = request.session.session_key
ssender = SmsSingleSender(appid, appkey)
try:
result = ssender.send_with_param(86, phone_numbers[0], template_id,
params)
return JsonResponse({'res': 1})
# send_smscode(phone=phone, code=smscode)
except:
return JsonResponse({'res': 0})
class SMSServer:
def __init__(self, app_id, app_key):
self.ssender = SmsSingleSender(app_id, app_key)
def _gen_code(self):
code = ''.join([choice(string.digits) for _ in range(4)])
return code
def _send(self, phone, template_id, sign=TENCENT_SMS_SIGN):
code = self._gen_code()
params = [code, 3]
try:
result = self.ssender.send_with_param(86, phone, template_id, params, sign=sign, extend="", ext="")
return code
except HTTPError as e:
print(e)
except Exception as e:
print(e)
print(result)
def send_enroll_or_password(self, phone):
return self._send(phone, TENCENT_SMS_TEMPLATE_ID)
def send_login(self, phone):
return self._send(phone, TENCENT_SMS_TEMPLATE_LOGIN_ID)
def mutate(self, info, *args, **kwargs):
mobileverifydata = kwargs.get('mobileverifydata')
phone_num = mobileverifydata.get('phoneNum')
if not re.match(r'1[345678]\d{9}', phone_num):
return MobileVerify(result=False, message="手机号码不是11位")
# 生成验证码
#smsCode = '%06d' % random.randint(0, 999999)
smsCode = '%04d' % random.randint(0, 9999)
if cache.get(phone_num):
LOG.debug(cache.get(phone_num))
return MobileVerify(result=True, message=f"验证码未过期{cache.get(phone_num)}")
# 腾讯云短信发送
ssender = SmsSingleSender(appid, appkey)
params = [smsCode, 2] # 当模板没有参数时，`params = []`
try:
result = ssender.send_with_param(86, phone_num,
template_id, params, sign=sms_sjgn, extend="", ext="")
except HTTPError as e:
LOG.info(e)
return MobileVerify(result=False, message=e)
except Exception as e:
LOG.error(e)
return MobileVerify(result=False, message=e)
# 判断发送
if result.get('errmsg') == 'OK':
cache.set(phone_num, smsCode, 60 * 2)
return MobileVerify(result=True, message="发送短信成功")
else:
cache.delete(phone_num)
return MobileVerify(result=False, message="发送短信失败")
def tencent_single_sms_sender(
receiver: str,
params: list,
template_content_code: str,
conf_params: dict,
sign_name: str,
**kwargs,
):
sms_appid = conf_params.get("sms_appid")
sms_appkey = conf_params.get("sms_appkey")
sms_sign = conf_params.get("sms_sign") or sign_name
if not (sms_appid and sms_appkey and sms_sign):
return False, "请检查appid,appkey,sms_sign配置"
ssender = SmsSingleSender(sms_appid, sms_appkey)
try:
result = ssender.send_with_param("86",
receiver,
int(template_content_code),
params,
sign=sms_sign)
logger.info("tx sms result %s" % result)
except HTTPError as e:
return False, str(e)
except Exception as e:
return False, str(e)
status = True if result.get("result") == 0 else False
return status, result["errmsg"]
def get(self):
parse=parser.add_argument()
phone=parse.get('phone')
appid=''
appkey=''
template_id=''
sms_sign=''
num=1
ssender = SmsSingleSender(appid, appkey)
random_str = random.randrange(1000, 10000)
params = [random_str, num]
cache.set(phone,random_str,60*1)
try:
result = ssender.send_with_param(86, phone,
template_id, params, sign=sms_sign, extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
return format_response(msg='短信发送成功', status=200)
except HTTPError as e:
print(e)
return format_response(msg='短信发送失败', status=400, err=e)
except Exception as e:
print(e)
return format_response(msg='短信发送失败', status=400, err=e)
def send_message(tel: str):
'''
发送短信验证码
:参数: 字符串类型的电话号码
:返回: 状态码
'''
if len(tel) != 11:
return None
if not tel.isdigit():
return None
appid = 1400134945
appkey = "ffeab1446affb984ea66751c8981cbef"
phone_numbers = [tel]
tpl_id = 184096
ssender = SmsSingleSender(appid, appkey)
params = [verification_code()]
try:
result = ssender.send_with_param(86, phone_numbers[0], tpl_id, params)
except HTTPError as error:
print(error)
print("腾讯云返回信息：", result)
return params[0]
def util_sendmsg(mobile, check_code):
#APPID = '1400391229'
#APPKEY = '24a1787bee0af73c550716ab46e5b352'
sender = SmsSingleSender(sms_app_id, sms_app_key)
TEMPLATE_ID = 667205
SMS_SIGN = "ditanshow网"
try:
params = [check_code]
response = sender.send_with_param(86,
mobile,
TEMPLATE_ID,
params,
sign=SMS_SIGN,
extend="",
ext="")
print("response=%s" % response)
except Exception as e:
print('sms error: %s' % e)
return False
if response and response['result'] == 0:
return True
def sendMsg(phone, code):
from qcloudsms_py import SmsSingleSender
from qcloudsms_py.httpclient import HTTPError
appid = 1400265177
appkey = '6c6189b044f0ed2edad70183037f4e19'
template_id = 443313
sms_sign = 'SCNU南苑'
ssender = SmsSingleSender(appid, appkey)
code = str(code)
params = [code]
try:
result = ssender.send_with_param(86,
str(phone),
template_id,
params,
sign=sms_sign,
extend="",
ext="")
except HTTPError as e:
print('【短信发送失败】（ %s | %s ）' % (phone, code))
print(e)
except Exception as e:
print('【短信发送失败】（ %s | %s ）' % (phone, code))
print(e)
def msm(phone, number):
from qcloudsms_py import SmsSingleSender
from qcloudsms_py.httpclient import HTTPError
# 短信应用SDK AppID
appid = 1400217900 # SDK AppID是1400开头
# 短信应用SDK AppKey
appkey = "fe04cc0b081ba3037ef32c8093feeaf5"
# 需要发送短信的手机号码
phone_numbers = [phone]
# 短信模板ID，需要在短信应用中申请
template_id = 349381 #
# 尊敬的用户，欢迎成为希希大队长社区用户！您的验证码是{1}，请于5分钟内填写。如非本人操作，请忽略本短信。
# 签名
sms_type = 0
sms_sign = "希希大队长社区"
ssender = SmsSingleSender(appid, appkey)
params = [number
] # 当模板没有参数时，`params = []`，数组具体的元素个数和模板中变量个数必须一致，例如事例中templateId:5678对应一个变量，参数数组中元素个数也必须是一个
try:
result = ssender.send_with_param(86, phone_numbers[0],
template_id, params, sign=sms_sign, extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except BaseException as e:
return False
return True
def send_sms(number, params):
ssender = SmsSingleSender(appid, appkey)
params = [
params['name'], params['date'], params['time'], params['location'],
params['type']
] # 当模板没有参数时，`params = []`，数组具体的元素个数和模板中变量个数必须一致，例如示例中 templateId:5678 对应一个变量，参数数组中元素个数也必须是一个
try:
result = ssender.send_with_param(86,
number,
template_id,
params,
sign=sms_sign,
extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
errmsg = 'send_sms HTTPError:' + str(e) + ', for %s' % number
print(errmsg)
logfp.write(errmsg + '\n')
result = {'result': None, 'errmsg': errmsg}
except Exception as e:
errmsg = 'send_sms Error:' + str(e) + ', for %s' % number
print(errmsg)
logfp.write(errmsg + '\n')
result = {'result': None, 'errmsg': errmsg}
return result
async def send_sms(phone, sms_num):
ssender = SmsSingleSender(SMSAPPID, SMSAPPKEY)
params = [str(sms_num), "30"]
try:
result = ssender.send_with_param(86, str(phone), TEMPLATE_ID, params)
except HTTPError as e:
return -1
except Exception as e:
return -1
return 0
def send(self):
ssender = SmsSingleSender(self.appid, self.appkey)
params = [self.content]
result = ssender.send_with_param(86,
self.number,
self.template_id,
params,
sign="两人随纪",
extend="",
ext="")
def send_msg(user_phone):
appid = 1400305377 #SDK AppID
appkey = "b29e1a269eea116af74cb351cc0eaafa" #App Key
template_id = 519567 #正文模板ID
sms_sign = "知书黑板报" #签名类容
ssender = SmsSingleSender(appid, appkey)
select = input("是否启用原有模板yes启用，no重新输入:")
while True:
try:
if select == "NO" or select == "no":
appid = int(input("请输入SDK AppID:")) # SDK AppID
appkey = input("请输入App Key:") # App Key
template_id = int(input("请输入正文模板ID:")) # 正文模板ID
sms_sign = input("请输入签名名称例如知书黑板报:") # 签名名称
ssender = SmsSingleSender(appid, appkey)
break
elif select == "YES" or select == "yes":
break
else:
print("输入错误，重新输入")
except Exception as e:
print("输入错误哦，重新输入" + str(e))
params = input("请输入你模板中的参数内容以空格隔开:")
params_list = params.split(" ")
num = 0
error_num = 0
for user_and_phone in user_phone:
phone = user_and_phone[1]
try:
result = ssender.send_with_param(86,
phone,
template_id,
params_list,
sign=sms_sign,
extend="",
ext="")
if result["errmsg"] == "OK":
num += 1
else:
error_num += 1
with open("error.text", "a+", newline="") as f:
f.write(str(user_and_phone) + "\n")
print("\r成功发送" + str(num) + "人,未成功发送" + str(error_num) + "人",
end=" ")
except HTTPError as e:
traceback.print_exc()
except Exception as e:
traceback.print_exc()
def send_sms_single(phone_num, template_id, template_param_list):
sender = SmsSingleSender(appid, appkey)
try:
response = sender.send_with_param(86,
phone_num,
template_id,
template_param_list,
sign=sms_sign)
except HTTPError as e:
response = {'result': 1000, 'errmsg': '网络异常，发送失败'}
return response
def sendSMS(phonenumber, send_content):
appid = 1111
appkey = "11111"
template_id = 111
ssender = SmsSingleSender(appid, appkey)
result = ssender.send_with_param(86, phonenumber, template_id,
send_content)['result']
if result == 0:
logger.debug("send sms result code:", result)
else:
logging.error("send sms Falied")
def send_sms(phone,params):
ssender = SmsSingleSender('1400259397', '2723ebb3a9c818dd9af6809de6ac1bd9')
params = [params] # 当模板没有参数时，`params = []`
try:
result = ssender.send_with_param(86, phone,
'422325', params, sign='以后再说吧公众号', extend="", ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
print(e)
except Exception as e:
print(e)
return result
def send_one_with_template(etc_price):
template_id = 188004
ssender = SmsSingleSender(appid, appkey)
params = [etc_price]
try:
result = ssender.send_with_param(86, phone_numbers[0], template_id, params, sign=sms_sign, extend="", ext="")
except HTTPError as e:
print(e)
except Exception as e:
print(e)
print(result)
def create(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
mobile = serializer.validated_data['mobile']
ttl = cache.ttl(mobile + '_timeout')
ssender = SmsSingleSender(sms_appid, sms_appkey)
if ttl > 0:
return Response({'errmsg': "请在1分钟后再试"},
status=status.HTTP_400_BAD_REQUEST)
else:
userId = request.query_params.get('userId', '')
op = request.query_params.get('op', 'created')
user_info_filter = models.UserInfo.objects.filter(id=userId)
if user_info_filter.exists():
user = authenticate(username=userId, password=mobile)
if not user_info_filter[
0].user or op == 'update' or op == 'recruit' or user is not None:
tts = cache.get(userId + '_send_nums', 0)
if tts == 0:
cache.set(userId + '_send_nums', 0, timeout=60 * 60)
if userId and tts <= 10:
try:
code = self.random_digits()
params = [code, sms_timeout]
result = ssender.send_with_param(
86, mobile, template_id, params)
cache.incr(userId + '_send_nums')
cache.set(mobile + '_timeout', code, 60)
cache.set(mobile + '_code', code, sms_timeout * 60)
return Response(result)
except HTTPError as e:
return Response(e,
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response(e,
status=status.HTTP_400_BAD_REQUEST)
elif tts > 10:
return Response({'errmsg': '您发送验证码的次数过多，请稍后再试'},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'errmsg': '请带参数访问'},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'errmsg': '你绑定的手机号错误，更改手机号请到个人中心设置'},
status=status.HTTP_400_BAD_REQUEST)
else:
return Response({'errmsg': '用户不存在'},
status=status.HTTP_400_BAD_REQUEST)
def yd_send_sms_param(template_id, params, mobile, sms_sign):
"""
指定模版发送
"""
app_id = config.QCLOUD_SMS_APPID
app_key = config.QCLOUD_SMS_APPKEY
ssender = SmsSingleSender(app_id, app_key)
try:
result = ssender.send_with_param(86, mobile, template_id, params, sign=sms_sign)
except HTTPError as e:
print(e)
except Exception as e:
print(e)
def send_sms(telephone):
nowTime = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S') # 现在
ssender = SmsSingleSender(appid, appkey)
params = [nowTime]
try:
result = ssender.send_with_param(86, telephone, template_id, params)
except HTTPError as e:
print(e)
except Exception as e:
print(e)
print(result)
def sendMsgTX(params, template_id):
sms_type = 0 # Enum{0: 普通短信, 1: 营销短信}
phone_numbers = ['15622813257']
ssender = SmsSingleSender('xx', 'xx')
#params = ['茅台', '14']
try:
result = ssender.send_with_param(86, phone_numbers[0],
template_id, params, sign='', extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
print(e)
except Exception as e:
print(e)
def FN_SMS_SEND(sms_appid,sms_appkey,phone,template_id,params,sms_sign,ext=''):
ssender = SmsSingleSender(sms_appid, sms_appkey)
result=''
try:
result = ssender.send_with_param(86, phone,template_id, params, sign=sms_sign, extend="", ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
return(str(e))
except Exception as e:
return(str(e))
if result['result']==0:
return True
else:
return(result)
def tencent_cloud_message(phone_number, verification_code):
"""腾讯云发送短信接口"""
appid = 1400131309
appkey = "7901df2b3113f98f1a9ad266ca07c9db"
phone_numbers = phone_number
template_id = 178579
sms_sign = "南开软小依"
ssender = SmsSingleSender(appid, appkey)
params = [verification_code, '5']
try:
ssender.send_with_param(86,
phone_numbers,
template_id,
params,
sign=sms_sign,
extend="",
ext="")
except HTTPError as error:
raise HTTPError from error
except Exception as error:
raise Exception from error
def post(self):
parse = parser.parse_args()
phone = parse.get('phone')
# 短信应用SDK AppID
appid = 1400112809 # SDK AppID是1400开头
# 短信应用SDK AppKey
appkey = "8d8b808cb9073023631d241951f49fb4"
# 需要发送短信的手机号码
phone_numbers = [phone]
# 短信模板ID，需要在短信应用中申请
template_id = 166915 # NOTE: 这里的模板ID`7839`只是一个示例，真实的模板ID需要在短信控制台中申请
# templateId 7839 对应的内容是"您的验证码是: {1}"
# 签名
sms_sign = "钟远智工作经验分享" # NOTE: 这里的签名"腾讯云"只是一个示例，真实的签名需要在短信控制台中申请，另外签名参数使用的是`签名内容`，而不是`签名ID`
ssender = SmsSingleSender(appid, appkey)
# 模板需要的参数
# 短信验证码: {1}，请于{2}分钟内填写。如非本人操作，请忽略本短信。
temp_random = random.randrange(10000, 100000)
# 缓存验证码(后续过期处理，以及验证处理)
cache.set(phone, temp_random, timeout=30)
print(phone, cache.get(phone), type(phone))
params = [
temp_random, 10
] # 当模板没有参数时，`params = []`，数组具体的元素个数和模板中变量个数必须一致，例如事例中templateId:5678对应一个变量，参数数组中元素个数也必须是一个
try:
result = ssender.send_with_param(
86,
phone_numbers[0],
template_id,
params,
sign=sms_sign,
extend="",
ext="") # 签名参数未提供或者为空时，会使用默认签名发送短信
except HTTPError as e:
print(e)
except Exception as e:
print(e)
responseData = {'msg': '发送短信成功'}
return responseData
