def wxrouter_menu_products(self, msg, gdata=None, wechat=None, **kwargs):
""" 套餐资费 """
yield
with make_db(gdata.db) as db:
try:
mp_domain_addr = self.db.query(
models.TrParam.param_value).filter_by(
param_name='mp_domain_addr').scalar()
products = db.query(models.TrProduct).filter_by(
product_status=0, ispub=1).limit(7)
articles = []
for p in products:
article1 = Storage()
article1.title = utils.safeunicode(p.product_name)
article1.description = ''
article1.url = '%s/mps/product/%s' % (mp_domain_addr, p.id)
article1.picurl = ''
articles.append(article1)
defer.returnValue(wechat.response_news(articles))
except Exception as err:
logger.exception(err, trace='wechat')
defer.returnValue(
wechat.response_text(u'服务器错误,请联系客服 %s' %
utils.safeunicode(err)))
def add(self, formdata, bas_ids=[], **kwargs):
try:
node = models.TrNode()
node.id = formdata.node_id if 'node_id' in formdata else utils.get_uuid(
)
node.node_name = formdata.node_name
node.node_type = utils.safeunicode(
formdata.get('node_type', 'other'))
node.rule_id = formdata.rule_id
node.node_desc = formdata.get('node_desc', '')
node.sync_ver = tools.gen_sync_ver()
self.db.add(node)
for bas_id in bas_ids:
basnode = models.TrBasNode()
basnode.bas_id = bas_id
basnode.node_id = node.id
basnode.sync_ver = tools.gen_sync_ver()
self.db.add(basnode)
self.add_oplog(u'新增区域信息:%s' %
utils.safeunicode(formdata.node_name))
self.db.commit()
return node
except Exception as err:
self.db.rollback()
logger.exception(err, tag='node_add_error')
self.last_error = u'区域创建失败:%s' % utils.safeunicode(err)
return False
def _decode_msg(self, err, msg):
_msg = msg and utils.safeunicode(msg) or ''
if issubclass(type(err), BaseException):
return u'{0}, {1}'.format(utils.safeunicode(_msg),
utils.safeunicode(err.message))
else:
return _msg
def recharge(self, formdata, **kwargs):
try:
rfee = utils.yuan2fen(formdata.fee_value)
if rfee <= 0:
raise ValueError(u'充值金额必须大于0')
agency = self.db.query(models.TrAgency).get(formdata.agency_id)
agency.amount += rfee
aorder = models.TrAgencyOrder()
aorder.id = utils.get_uuid()
aorder.agency_id = agency.id
aorder.fee_type = 'recharge'
aorder.fee_value = rfee
aorder.fee_total = agency.amount
aorder.fee_desc = u'代理商 (%s) 充值' % utils.safeunicode(agency.agency_name)
aorder.create_time = utils.get_currtime()
aorder.sync_ver = tools.gen_sync_ver()
self.db.add(aorder)
self.add_oplog(u'代理商(%s)充值' % utils.safeunicode(agency.agency_name))
self.db.commit()
return agency
except Exception as err:
self.db.rollback()
logger.exception(err, tag='agency_recharge_error')
self.last_error = u'代理商充值失败:%s' % utils.safeunicode(err)
return False
def update(self, formdata, bas_ids=[], **kwargs):
try:
node = self.get_safe_node(formdata.id)
node.node_type = utils.safeunicode(
formdata.get('node_type', 'other'))
node.node_name = formdata.node_name
node.node_desc = formdata.get('node_desc', '')
if 'rule_id' in formdata:
node.rule_id = formdata.rule_id
node.sync_ver = tools.gen_sync_ver()
self.db.query(models.TrBasNode).filter_by(node_id=node.id).delete()
for bas_id in bas_ids:
basnode = models.TrBasNode()
basnode.bas_id = bas_id
basnode.node_id = node.id
basnode.sync_ver = tools.gen_sync_ver()
self.db.add(basnode)
self.add_oplog(u'修改区域信息:%s' %
utils.safeunicode(formdata.node_name))
self.db.commit()
return node
except Exception as err:
self.db.rollback()
logger.exception(err, tag='node_update_error')
self.last_error = u'修改区域失败:%s' % utils.safeunicode(err)
return False
def event_mail_account_expire(self, account_number):
userinfo = self.get_customer_info(account_number)
content_tpl = self.get_content_template(ExpireNotify)
if not content_tpl:
return
content = content_tpl.replace('{customer_name}',
utils.safeunicode(userinfo.realname))
content = content.replace('{product_name}',
utils.safeunicode(userinfo.product_name))
content = content.replace('{username}', account_number)
content = content.replace('{expire_date}', userinfo.expire_date)
dispatch.pub(EVENT_SENDMAIL, userinfo.email, u'用户到期通知邮件',
utils.safeunicode(content))
def parse_form_request(self):
try:
return apiutils.parse_form_request(
self.settings.config.system.secret, self.get_params())
except Exception as err:
logger.error(u'api authorize parse error, %s' %
utils.safeunicode(traceback.format_exc()))
self.render_parse_err(err,
msg=u'ParseRequest Error: %s' %
utils.safeunicode(err.message))
return None
return None
def event_wechat_account_open(self, account_number):
"""客户账号开户微信通知
"""
userinfo = self.get_customer_info(account_number)
content_tpl = self.get_content_template(OpenNotify)
if not content_tpl:
return
content = content_tpl.replace('{customer_name}',
utils.safeunicode(userinfo.realname))
content = content.replace('{product_name}',
utils.safeunicode(userinfo.product_name))
content = content.replace('{username}', account_number)
content = content.replace('{expire_date}', userinfo.expire_date)
dispatch.pub(EVENT_SEND_WECHAT, userinfo.wechat_oid,
utils.safeunicode(content))
def password(self, formdata, **kwargs):
"""用户密码修改
:param formdata: 密码修改参数表
:type formdata: dict
formdata params:
:param account_number: 用户账号
:type account_number: string
:param password: 用户新密码
:type password: string
"""
try:
account_number = self.parse_arg(formdata, 'account_number', rule=rules.not_null)
password = self.parse_arg(formdata, 'password', rule=rules.not_null)
print password
account = self.db.query(models.TrAccount).get(account_number)
account.password = self.aes.encrypt(password)
account.sync_ver = tools.gen_sync_ver()
node_id = self.db.query(models.TrCustomer.node_id).filter(models.TrCustomer.customer_id == models.TrAccount.customer_id, models.TrAccount.account_number == account_number).scalar()
self.add_oplog(u'修改用户%s密码 ' % account_number)
self.db.commit()
dispatch.pub(CACHE_DELETE_EVENT, account_cache_key(account_number), async=True)
return True
except Exception as err:
self.db.rollback()
self.last_error = u'用户修改密码失败:%s' % utils.safeunicode(err.message)
logger.error(self.last_error, tag='account_uppwd_error', username=formdata.get('account_number'))
return False
def post(self):
self.set_header('Content-Type', 'text/xml;charset=utf-8')
self.set_header('Cache-Control', 'no-cache')
if '/interface/operategw?wsdl' == self.request.uri:
owsurl = '{0}://{1}'.format(self.request.protocol,
self.request.host)
self.finish(optwsdl.wsdlxml(wsurl=owsurl))
return
if '/interface/businessgw?wsdl' == self.request.uri:
bwsurl = '{0}://{1}'.format(self.request.protocol,
self.request.host)
self.finish(bgwsdl.wsdlxml(wsurl=bwsurl))
return
wsbody = self.request.body
logger.info('recv soap message %s' % utils.safeunicode(wsbody),
trace='api')
for _method in self.methods:
try:
if wsbody.find('<wsdd:%s' % _method) >= 0:
getattr(self, _method)(wsbody)
except NULLError:
self.send_wsresp(_method, code=103)
except:
self.send_wsresp(_method,
code=9999,
error=traceback.format_exc())
def render_result(self, **result):
resp = apiutils.make_message(self.settings.config.system.secret,
**result)
if self.settings.debug:
logger.debug('[api debug] :: %s response body: %s' %
(self.request.path, utils.safeunicode(resp)))
self.write(resp)
def delete(self, account_number, **kwargs):
"""用户账号删除
:param account_number: 用户账号
:type account_number: string
"""
try:
if not account_number:
raise ValueError(u'账号不能为空')
account = self.db.query(models.TrAccount).get(account_number)
self.db.query(models.TrAcceptLog).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrAccountAttr).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrBilling).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrTicket).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrOnline).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrAccount).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrCustomerOrder).filter_by(account_number=account.account_number).delete()
self.add_oplog(u'删除用户账号%s' % account.account_number)
self.db.commit()
dispatch.pub(ACCOUNT_DELETE_EVENT, account.account_number, async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAcceptLog.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccountAttr.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrBilling.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOnline.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccount.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrCustomerOrder.__tablename__, dict(account_number=account.account_number)), async=True)
return True
except Exception as err:
self.db.rollback()
self.last_error = u'用户删除失败:%s' % utils.safeunicode(err.message)
logger.error(self.last_error, tag='account_delete_error', username=account_number)
return False
def post(self):
try:
if os.environ.get('DEMO_VER'):
self.write(u'这是一个演示版本，不提供此功能')
return
file_path = os.path.join(os.path.dirname(taurusxradius.__file__),
'static/dnsv')
try:
if not os.path.exists(file_path):
os.makedirs(file_path)
except:
pass
f = self.request.files['Filedata'][0]
filename = os.path.basename(utils.safestr(f['filename']))
save_path = os.path.join(file_path, filename)
tf = open(save_path, 'wb')
filestr = f['body']
tf.write(filestr.strip())
tf.close()
logger.info('write {0}'.format(save_path))
self.write(u'上传完成')
except Exception as err:
logger.error(err)
self.write(u'上传失败 %s' % utils.safeunicode(err))
def post(self):
try:
pic_path = os.path.join(os.path.dirname(taurusxradius.__file__),
'static/pics')
try:
if not os.path.exists(pic_path):
os.makedirs(pic_path)
except:
pass
f = self.request.files['Filedata'][0]
filename = os.path.basename(utils.safestr(f['filename']))
savename = 'pic{0}_{1}'.format(tools.gen_num_id(13), filename)
save_path = os.path.join(pic_path, savename)
tf = open(save_path, 'wb')
tf.write(f['body'])
tf.close()
if not safefile.isimg(save_path):
os.remove(save_path)
logger.error('error upload file %s' % save_path)
self.write(u'上传的文件不是图片类型')
return
logger.info('write {0}'.format(save_path))
self.write(u'upload ok')
except Exception as err:
logger.error(err)
self.write(u'上传失败 %s' % utils.safeunicode(err))
def post(self):
order_id = self.get_argument('order_id')
tpl_id = self.get_argument('tpl_id')
tpl = self.db.query(models.TrPrintTemplate).get(tpl_id)
note = self.db.query(
models.TrCustomerNote).filter_by(order_id=order_id).first()
print_params = dict(title=u'宽带票据',
note_id=note.note_id,
pay_type=note.pay_type,
pay_date=note.pay_date,
expire_date=note.expire_date,
customer_name=note.customer_cname,
install_address=note.install_address,
product_name=note.product_name,
product_price=utils.fen2yuan(note.fee_price),
remark=note.remark,
account_number=note.account_number,
mobile=note.mobile,
product_num=note.order_num,
fee_total=utils.fen2yuan(note.fee_total),
charge_values=utils.safeunicode(
note.charge_values),
receiver=note.operator_name,
customer_sign='')
print_func = tpl.tpl_content.format(**print_params)
self.render_json(func=print_func)
def disconnect(self):
try:
is_chap = self.settings.config.portal.chap in (1, '1', 'chap')
userIp = self.current_user.ipaddr
nas = self.get_nas(self.current_user.nasaddr)
ac_addr = nas['ip_addr']
ac_port = int(nas['ac_port'])
secret = utils.safestr(nas['bas_secret'])
_vendor = utils.safestr(nas['portal_vendor'])
if _vendor not in ('cmccv1', 'cmccv2', 'huaweiv1', 'huaweiv2'):
defer.returnValue('not support vendor %s' % _vendor)
send_portal = functools.partial(client.send,
secret,
log=self.syslog,
debug=self.settings.config.debug,
vendor=_vendor)
vendor = client.PortalClient.vendors.get(_vendor)
logout_req = vendor.proto.newReqLogout(userIp,
secret,
chap=is_chap)
logout_resp = yield send_portal(data=logout_req,
host=ac_addr,
port=ac_port)
if logout_resp.errCode > 0:
_err_msg = u'{0},{1}'.format(
vendor.mod.AckLogoutErrs[logout_resp.errCode],
utils.safeunicode(logout_resp.get_text_info()[0] or ''))
logger.error(_err_msg)
defer.returnValue('disconnect done!')
except Exception as err:
defer.returnValue(err)
def update(self, formdata, **kwargs):
"""用户账号策略修改
:param formdata: 密码修改参数表
:type formdata: dict
formdata params:
:param account_number: 用户账号
:type account_number: string
:param ip_address: 用户IP地址
:type ip_address: string - x.x.x.x
:param install_address: 用户安装地址
:type install_address: string
:param domain: 用户域，对BRAS的特定扩展
:type domain: string
:param user_concur_number: 用户在线数限制
:type user_concur_number: int
:param bind_mac: 用户是否绑定mac
:type bind_mac: int - 0 不绑定 1 绑定
:param bind_vlan: 用户是否绑定vlan
:type bind_vlan: int 0 不绑定 1 绑定
:param account_desc: 用户描述
:type account_desc: string
"""
try:
account_number = self.parse_arg(formdata, 'account_number', rule=rules.not_null)
user_concur_number = self.parse_arg(formdata, 'user_concur_number', rule=rules.is_number)
bind_mac = self.parse_arg(formdata, 'bind_mac', rule=rules.is_number)
bind_vlan = self.parse_arg(formdata, 'bind_vlan', rule=rules.is_number)
ip_address = self.parse_arg(formdata, 'ip_address')
install_address = self.parse_arg(formdata, 'install_address')
domain = self.parse_arg(formdata, 'domain')
account_desc = self.parse_arg(formdata, 'account_desc')
account = self.db.query(models.TrAccount).get(account_number)
node_id = self.db.query(models.TrCustomer.node_id).filter(models.TrCustomer.customer_id == models.TrAccount.customer_id, models.TrAccount.account_number == account_number).scalar()
if ip_address is not None:
account.ip_address = ip_address
if install_address is not None:
account.install_address = install_address
account.user_concur_number = user_concur_number
account.bind_mac = bind_mac
account.bind_vlan = bind_vlan
if domain is not None:
account.domain = domain
if account_desc is not None:
account.account_desc = account_desc
account.sync_ver = tools.gen_sync_ver()
self.add_oplog(u'修改上网账号信息:%s' % account.account_number)
self.db.commit()
dispatch.pub(CACHE_DELETE_EVENT, account_cache_key(account.account_number), async=True)
return True
except Exception as err:
self.db.rollback()
self.last_error = u'用户修改失败:%s' % utils.safeunicode(err.message)
logger.error(self.last_error, tag='account_update_error', username=formdata.get('account_number'))
return False
return
def post(self):
nodes = [(n.id, n.node_desc) for n in self.db.query(models.TrNode)]
products = [(p.id, p.product_name)
for p in self.db.query(models.TrProduct)]
form = operator_form.operator_add_form(nodes, products)
if not form.validates(source=self.get_params()):
return self.render('opr_form.html',
form=form,
rules=self.get_arguments('rule_item'))
if self.db.query(models.TrOperator.id).filter_by(
operator_name=form.d.operator_name).count() > 0:
return self.render('opr_form.html',
form=form,
msg=u'操作员已经存在',
rules=self.get_arguments('rule_item'))
operator = models.TrOperator()
operator.id = utils.get_uuid()
operator.operator_name = form.d.operator_name
operator.operator_pass = md5(form.d.operator_pass.encode()).hexdigest()
operator.operator_type = 1
operator.operator_desc = form.d.operator_desc
operator.operator_status = form.d.operator_status
operator.sync_ver = tools.gen_sync_ver()
self.db.add(operator)
self.add_oplog(u'新增操作员信息:%s' %
utils.safeunicode(operator.operator_name))
for node_id in self.get_arguments('operator_nodes'):
onode = models.TrOperatorNodes()
onode.operator_name = form.d.operator_name
onode.node_id = node_id
onode.sync_ver = tools.gen_sync_ver()
self.db.add(onode)
for product_id in self.get_arguments('operator_products'):
oproduct = models.TrOperatorProducts()
oproduct.operator_name = form.d.operator_name
oproduct.product_id = product_id
oproduct.sync_ver = tools.gen_sync_ver()
self.db.add(oproduct)
for path in self.get_arguments('rule_item'):
item = permit.get_route(path)
if not item:
continue
rule = models.TrOperatorRule()
rule.id = utils.get_uuid()
rule.operator_name = operator.operator_name
rule.rule_name = item['name']
rule.rule_path = item['path']
rule.rule_category = item['category']
rule.sync_ver = tools.gen_sync_ver()
self.db.add(rule)
self.db.commit()
for rule in self.db.query(models.TrOperatorRule).filter_by(
operator_name=operator.operator_name):
permit.bind_opr(rule.operator_name, rule.rule_path)
self.redirect('/admin/operator', permanent=False)
def get(self, *args, **kwargs):
logger.info(utils.safeunicode(self.request.query))
wlan_params = {
'wlanuserip': self.get_argument('userip', self.request.remote_ip),
'wlanusername': self.get_argument('username', 'test'),
'wlanacip': self.get_argument('wlanacip', '127.0.0.1'),
'ssid': self.get_argument('ssid', 'default'),
'wlanusermac': self.get_argument('wlanusermac', '00-00-00-00-00'),
'wlanapmac': self.get_argument('wlanapmac', '00-00-00-00-00'),
'wlanuserfirsturl': self.get_argument('wlanuserfirsturl', '/'),
'callback': self.get_argument('callback', ''),
'vendortype': self.get_argument('vendortype', '')
}
logger.info(utils.safeunicode(wlan_params))
url = '/login?' + urlencode(wlan_params)
logger.info('portal forward to : %s' % url)
self.redirect(url, permanent=False)
def wxrouter_text(self, msg, gdata = None, wechat = None, **kwargs):
logger.info(u'process wechat text %s' % utils.safeunicode(msg.content))
resp = ''
keychar = msg.content.strip()
if keychar in wechat_funcs:
logger.info('execute func %s' % wechat_funcs[keychar])
resp = yield wxrouter.dispatch(msg, gdata=gdata, wechat=wechat, func=wechat_funcs[keychar], **kwargs)
defer.returnValue(resp)
def list_userlog(self, username):
""" 查询用户诊断日志
:param username: 用户账号
:type username: string
"""
key = self.userlog_key(username)
return [utils.safeunicode(v) for v in self.redis.lrange(key, 0, 512)]
def list_trace(self, name):
""" 查询系统日志
:param name: 日志名称 (info,debug,error,exception,event,api)
:type name: string
"""
key = self.trace_key(name)
return [utils.safeunicode(v) for v in self.redis.lrange(key, 0, 512)]
def log_trace(self, host, port, req, reply = None):
""" 跟踪日志,需要开启全局开关
"""
if not self.is_trace_on():
return
elif not self.user_exists(req.get_user_name()):
return
else:
try:
if reply is None:
msg = message.format_packet_log(req)
logger.info(u'Radius请求来自 Nas(%s:%s) %s' % (host, port, utils.safeunicode(msg)), trace='radius', username=req.get_user_name())
else:
msg = message.format_packet_log(reply)
logger.info(u'Radius响应至 Nas(%s:%s) %s' % (host, port, utils.safeunicode(msg)), trace='radius', username=req.get_user_name())
except Exception as err:
logger.exception(err)
return
def process(self, *args, **kwargs):
try:
self.statdata.run_stat(delay=5.0)
self.cache.update(radius_statcache_key, self.statdata)
if self.flow_stat:
self.cache.set(flow_statcache_key, self.flow_stat)
except Exception as err:
logger.error('radius stat process error %s' % utils.safeunicode(err.message))
return 5.0
def make_message(self, param):
param_keys = list(param.keys())
param_keys.sort()
param_str = ''
for key in param_keys:
param_str += key + u'=' + utils.safeunicode(param[key]) + u'&'
param_str = param_str[:-1]
sign_str = self.apikey + u'&' + param_str + u'&' + self.apikey
param['signature'] = md5(utils.safestr(sign_str)).hexdigest()
return param
def wxrouter_event_subscribe(self, msg, gdata=None, wechat=None, **kwargs):
yield
with make_db(gdata.db) as db:
try:
welcome_text = db.query(models.TrParam.param_value).filter(
models.TrParam.param_name ==
'mps_welcome_text').scalar() or ''
defer.returnValue(
wechat.response_text(utils.safeunicode(welcome_text)))
except Exception as err:
logger.exception(err, trace='wechat')
def post(self):
form = print_tpl_forms.print_tpl_update_form()
if not form.validates(source=self.get_params()):
return self.render('base_form.html', form=form)
tpl = self.db.query(models.TrPrintTemplate).get(form.d.id)
tpl.tpl_name = form.d.tpl_name
tpl.tpl_content = utils.safeunicode(form.d.tpl_content)
tpl.sync_ver = tools.gen_sync_ver()
self.db.query(
models.TrPrintTemplateTypes).filter_by(tpl_id=tpl.id).delete()
for tpl_type in self.get_arguments('tpl_types'):
tpltype = models.TrPrintTemplateTypes()
tpltype.tpl_id = tpl.id
tpltype.tpl_type = tpl_type
tpltype.sync_ver = tools.gen_sync_ver()
self.db.add(tpltype)
self.add_oplog(u'修改票据模板信息:%s' % utils.safeunicode(form.d.tpl_name))
self.db.commit()
self.redirect('/admin/printtpl', permanent=False)
def do_fail(self, sync_id, msg='', **kwargs):
try:
with self.db_engine.begin() as db:
table = models.TrRepliSyncStatus.__table__
stmt = table.update().where(table.c.id == sync_id).values(
last_sync=utils.get_currtime(),
sync_times=table.c.sync_times + 1,
sync_status=2,
error=utils.safeunicode(msg)[:2000])
db.execute(stmt)
except Exception as err:
logger.error(traceback.format_exc())
def post(self):
form = charges_forms.charge_update_form()
if not form.validates(source=self.get_params()):
return self.render('base_form.html', form=form)
charge = self.db.query(models.TrCharges).get(form.d.charge_code)
charge.charge_name = form.d.charge_name
charge.charge_value = utils.yuan2fen(form.d.charge_value)
charge.charge_desc = form.d.charge_desc
charge.sync_ver = tools.gen_sync_ver()
self.add_oplog(u'修改收费项信息:%s' % utils.safeunicode(form.d.charge_name))
self.db.commit()
self.redirect('/admin/charge', permanent=False)
def post(self):
form = account_rule_forms.account_rule_update_form()
if not form.validates(source=self.get_params()):
return self.render('base_form.html', form=form)
rule = self.db.query(models.TrAccountRule).get(form.d.id)
rule.rule_name = form.d.rule_name
rule.user_prefix = form.d.user_prefix
rule.user_suffix_len = int(form.d.user_suffix_len)
rule.sync_ver = tools.gen_sync_ver()
self.add_oplog(u'修改账号生成规则信息:%s' % utils.safeunicode(form.d.rule_name))
self.db.commit()
self.redirect('/admin/account_rule', permanent=False)
