def bas_add_post(db):
form = forms.bas_add_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
if db.query(
models.SlcRadBas.id).filter_by(ip_addr=form.d.ip_addr).count() > 0:
return render("base_form", form=form, msg=u"Bas地址已经存在")
bas = models.SlcRadBas()
bas.ip_addr = form.d.ip_addr
bas.bas_name = form.d.bas_name
bas.time_type = form.d.time_type
bas.vendor_id = form.d.vendor_id
bas.bas_secret = form.d.bas_secret
bas.coa_port = form.d.coa_port
db.add(bas)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)新增BAS信息:%s' % (get_cookie("username"),
serial_json(bas))
db.add(ops_log)
db.commit()
redirect("/bas")
def member_join_post(db):
nodes = [ (n.id,n.node_name) for n in db.query(models.SlcNode)]
form = forms.member_join_form(nodes)
if not form.validates(source=request.params):
return render("join", form=form)
if db.query(exists().where(models.SlcMember.member_name == form.d.username)).scalar():
return render("join",form=form,msg=u"用户{0}已被使用".format(form.d.username))
if db.query(exists().where(models.SlcMember.email == form.d.email)).scalar():
return render("join",form=form,msg=u"用户邮箱{0}已被使用".format(form.d.email))
member = models.SlcMember()
member.node_id = form.d.node_id
member.realname = form.d.realname
member.member_name = form.d.username
member.password = md5(form.d.password.encode()).hexdigest()
member.idcard = form.d.idcard
member.sex = form.d.sex
member.age = int(form.d.age)
member.email = form.d.email
member.mobile = form.d.mobile
member.address = form.d.address
member.create_time = utils.get_currtime()
member.update_time = utils.get_currtime()
db.add(member)
db.commit()
logger.info(u"新用户注册成功,member_name=%s"%member.member_name)
redirect('/login')
def member_login_post(db):
next = request.params.get("next", "/")
form = forms.member_login_form()
if not form.validates(source=request.params):
return render("login", form=form)
if vcache.is_over(form.d.username,'0'):
return render("error",msg=u"用户一小时内登录错误超过5次，请一小时后再试")
member = db.query(models.SlcMember).filter_by(
member_name=form.d.username
).first()
if not member:
return render("login", form=form,msg=u"用户不存在")
if member.password != md5(form.d.password.encode()).hexdigest():
vcache.incr(form.d.username,'0')
print vcache.validates
return render("login", form=form,msg=u"用户名密码错误第%s次"%vcache.errs(form.d.username,'0'))
vcache.clear(form.d.username,'0')
set_cookie('customer_id',member.member_id)
set_cookie('customer',form.d.username)
set_cookie('customer_login_time', utils.get_currtime())
set_cookie('customer_login_ip', request.remote_addr)
redirect(next)
def product_attr_add(db):
product_id = request.params.get("product_id")
if db.query(models.SlcRadProduct).filter_by(id=product_id).count()<=0:
return render("error",msg=u"资费不存在")
form = forms.product_attr_add_form()
form.product_id.set_value(product_id)
return render("sys_pattr_form",form=form,pattrs=radius_attrs)
def product_detail(db):
product_id = request.params.get("product_id")
product = db.query(models.SlcRadProduct).get(product_id)
if not product:
return render("error",msg=u"资费不存在")
product_attrs = db.query(models.SlcRadProductAttr).filter_by(product_id=product_id)
return render("sys_product_detail",product=product,product_attrs=product_attrs)
def opr_add_post(db):
form=forms.opr_add_form()
if not form.validates(source=request.forms):
return render("sys_opr_form", form=form)
if db.query(models.SlcOperator.id).filter_by(operator_name=form.d.operator_name).count()>0:
return render("sys_opr_form", form=form,msg=u"操作员已经存在")
opr = models.SlcOperator()
opr.operator_name = form.d.operator_name
opr.operator_type = 1
opr.operator_pass = md5(form.d.operator_pass).hexdigest()
opr.operator_desc = form.d.operator_desc
opr.operator_status = form.d.operator_status
db.add(opr)
for path in request.params.getall("rule_item"):
item = permit.get_route(path)
if not item:continue
rule = models.SlcOperatorRule()
rule.operator_name = opr.operator_name
rule.rule_name = item['name']
rule.rule_path = item['path']
rule.rule_category = item['category']
db.add(rule)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)新增操作员信息:%s'%(get_cookie("username"),serial_json(opr))
db.add(ops_log)
db.commit()
redirect("/opr")
def user_detail(db):
account_number = request.params.get('account_number')
user = db.query(
models.SlcMember.realname,
models.SlcRadAccount.member_id,
models.SlcRadAccount.account_number,
models.SlcRadAccount.expire_date,
models.SlcRadAccount.balance,
models.SlcRadAccount.time_length,
models.SlcRadAccount.user_concur_number,
models.SlcRadAccount.status,
models.SlcRadAccount.mac_addr,
models.SlcRadAccount.vlan_id,
models.SlcRadAccount.vlan_id2,
models.SlcRadAccount.ip_address,
models.SlcRadAccount.bind_mac,
models.SlcRadAccount.bind_vlan,
models.SlcRadAccount.ip_address,
models.SlcRadAccount.install_address,
models.SlcRadAccount.create_time,
models.SlcRadProduct.product_name
).filter(
models.SlcRadProduct.id == models.SlcRadAccount.product_id,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
models.SlcRadAccount.account_number == account_number
).first()
if not user:
return render("error",msg=u"用户不存在")
user_attrs = db.query(models.SlcRadAccountAttr).filter_by(account_number=account_number)
return render("ops_user_detail",user=user,user_attrs=user_attrs)
def issues_add_post(db, render):
oprs = [(o.operator_name, o.operator_name)
for o in db.query(models.SlcOperator)]
form = issues_forms.issues_add_form(oprs)
if not form.validates(source=request.forms):
return render("base_form", form=form)
if db.query(models.SlcRadAccount).filter_by(
account_number=form.d.account_number).count() == 0:
return render("base_form", form=form, msg=u"用户账号不存在")
issues = models.SlcIssues()
issues.account_number = form.d.account_number
issues.issues_type = form.d.issues_type
issues.content = form.d.content
issues.assign_operator = form.d.assign_operator
issues.status = 0
issues.date_time = utils.get_currtime()
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)创建新工单' % (get_cookie("username"))
db.add(ops_log)
db.add(issues)
db.commit()
redirect("/issues/list")
def roster_add_post(db):
form = forms.roster_add_form()
if not form.validates(source=request.forms):
return render("sys_roster_form", form=form)
if db.query(models.SlcRadRoster.id).filter_by(
mac_addr=form.d.mac_addr).count() > 0:
return render("sys_roster_form", form=form, msg=u"MAC地址已经存在")
roster = models.SlcRadRoster()
roster.mac_addr = form.d.mac_addr.replace("-", ":").upper()
roster.begin_time = form.d.begin_time
roster.end_time = form.d.end_time
roster.roster_type = form.d.roster_type
db.add(roster)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)新增黑白名单信息:%s' % (get_cookie("username"),
serial_json(roster))
db.add(ops_log)
db.commit()
websock.update_cache("roster", mac_addr=roster.mac_addr)
redirect("/roster")
def cmanager_add_post(db):
form=cmanager_forms.cmanage_add_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
if db.query(models.SlcCustomerManager).filter(
models.SlcCustomerManager.manager_code==form.d.manager_code).count()>0:
return render("base_form",form=form,msg=u"工号重复")
if db.query(models.SlcCustomerManager).filter(
models.SlcCustomerManager.active_code==form.d.active_code).count()>0:
return render("base_form",form=form,msg=u"激活码重复")
cmanager = models.SlcCustomerManager()
cmanager.manager_code = form.d.manager_code
cmanager.manager_name = form.d.manager_name
cmanager.manager_mobile = form.d.manager_mobile
cmanager.manager_email = form.d.manager_email
cmanager.active_code = form.d.active_code
cmanager.active_status = 0
cmanager.create_time = utils.get_currtime()
db.add(cmanager)
db.commit()
redirect("/cmanager/list")
def product_attr_add(db):
product_id = request.params.get("product_id")
if db.query(models.SlcRadProduct).filter_by(id=product_id).count() <= 0:
return render("error", msg=u"资费不存在")
form = forms.product_attr_add_form()
form.product_id.set_value(product_id)
return render("sys_pattr_form", form=form, pattrs=radius_attrs)
def member_login_post(db):
next = request.params.get("next", "/")
form = forms.member_login_form()
if not form.validates(source=request.params):
return render("login", form=form)
if vcache.is_over(form.d.username, '0'):
return render("error", msg=u"用户一小时内登录错误超过5次，请一小时后再试")
member = db.query(
models.SlcMember).filter_by(member_name=form.d.username).first()
if not member:
return render("login", form=form, msg=u"用户不存在")
if member.password != md5(form.d.password.encode()).hexdigest():
vcache.incr(form.d.username, '0')
print vcache.validates
return render("login",
form=form,
msg=u"用户名密码错误第%s次" % vcache.errs(form.d.username, '0'))
vcache.clear(form.d.username, '0')
set_cookie('customer_id', member.member_id)
set_cookie('customer', form.d.username)
set_cookie('customer_login_time', utils.get_currtime())
set_cookie('customer_login_ip', request.remote_addr)
redirect(next)
def issues_add_post(db, render):
oprs = [(o.operator_name, o.operator_name) for o in db.query(models.SlcOperator)]
form = issues_forms.issues_add_form(oprs)
if not form.validates(source=request.forms):
return render("base_form", form=form)
if db.query(models.SlcRadAccount).filter_by(account_number=form.d.account_number).count() == 0:
return render("base_form", form=form,msg=u"用户账号不存在")
issues = models.SlcIssues()
issues.account_number = form.d.account_number
issues.issues_type = form.d.issues_type
issues.content = form.d.content
issues.assign_operator = form.d.assign_operator
issues.status = 0
issues.date_time = utils.get_currtime()
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)创建新工单' % (get_cookie("username") )
db.add(ops_log)
db.add(issues)
db.commit()
redirect("/issues/list")
def show_buildopt(opt):
'''
Show information about a specific build option
'''
opts = data.Options()
if not opt in opts:
return render('error.html', code=200, message='That build option could not be found.')
return render('buildopt.html', optname=opt, opt=opts[opt])
def show_build(build_id):
'''
Show information about a build id and information about the last time it built
'''
try:
build = data.Build(id=build_id)
return render('build.html', build=build)
except data.UnknownBuildError:
return render('error.html', code=200, message='That build could not be found.')
def list_builds():
'''
Show all existing builds
'''
builds = data.Builds()
if None != builds:
return render('builds.html', builds=builds)
else:
return render('error.html', code=200, message='No builds are currently defined.')
def product_detail(db):
product_id = request.params.get("product_id")
product = db.query(models.SlcRadProduct).get(product_id)
if not product:
return render("error", msg=u"资费不存在")
product_attrs = db.query(
models.SlcRadProductAttr).filter_by(product_id=product_id)
return render("sys_product_detail",
product=product,
product_attrs=product_attrs)
def password_update_get(db):
form = forms.password_update_form()
account_number = request.params.get('account_number')
account = db.query(models.SlcRadAccount).get(account_number)
if not account:
return render("base_form", form=form, msg=u'没有这个账号')
if account.member_id != get_cookie("customer_id"):
return render("base_form", form=form, msg=u'该账号用用户不匹配')
form.account_number.set_value(account_number)
return render("base_form", form=form)
def account_next(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
user = query_account(db, account_number)
form = forms.account_next_form()
form.product_id.set_value(user.product_id)
if account.status not in (1, 4):
return render("bus_account_next_form",
user=user,
form=form,
msg=u"无效用户状态")
if not form.validates(source=request.forms):
return render("bus_account_next_form", user=user, form=form)
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'next'
accept_log.accept_source = 'console'
accept_log.accept_desc = u"用户续费：上网账号:%s，续费%s元" % (account_number,
form.d.fee_value)
accept_log.account_number = form.d.account_number
accept_log.accept_time = utils.get_currtime()
accept_log.operator_name = get_cookie("username")
db.add(accept_log)
db.flush()
db.refresh(accept_log)
order_fee = 0
product = db.query(models.SlcRadProduct).get(user.product_id)
order_fee = decimal.Decimal(product.fee_price) * decimal.Decimal(
form.d.months)
order_fee = int(order_fee.to_integral_value())
order = models.SlcMemberOrder()
order.order_id = utils.gen_order_id()
order.member_id = user.member_id
order.product_id = user.product_id
order.account_number = form.d.account_number
order.order_fee = order_fee
order.actual_fee = utils.yuan2fen(form.d.fee_value)
order.pay_status = 1
order.accept_id = accept_log.id
order.order_source = 'console'
order.create_time = utils.get_currtime()
order.order_desc = u"用户续费"
db.add(order)
account.status = 1
account.expire_date = form.d.expire_date
db.commit()
websock.update_cache("account", account_number=account_number)
redirect("/bus/member/detail?member_id={}".format(user.member_id))
def account_next(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
user = query_account(db, account_number)
form = forms.account_cancel_form()
if account.status != 1:
return render("bus_account_form", user=user, form=form, msg=u"无效用户状态")
if not form.validates(source=request.forms):
return render("bus_account_form", user=user, form=form)
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'cancel'
accept_log.accept_source = 'console'
accept_log.account_number = form.d.account_number
accept_log.accept_time = utils.get_currtime()
accept_log.operator_name = get_cookie("username")
accept_log.accept_desc = u"用户销户：上网账号:%s，退费%s(元)" % (account_number,
form.d.fee_value)
db.add(accept_log)
db.flush()
db.refresh(accept_log)
order = models.SlcMemberOrder()
order.order_id = utils.gen_order_id()
order.member_id = user.member_id
order.product_id = user.product_id
order.account_number = form.d.account_number
order.order_fee = 0
order.actual_fee = -utils.yuan2fen(form.d.fee_value)
order.pay_status = 1
order.order_source = 'console'
order.accept_id = accept_log.id
order.create_time = utils.get_currtime()
order.order_desc = u'用户销户'
db.add(order)
account.status = 3
db.commit()
websock.update_cache("account", account_number=account_number)
onlines = db.query(
models.SlcRadOnline).filter_by(account_number=account_number)
for _online in onlines:
websock.invoke_admin("coa_request",
nas_addr=_online.nas_addr,
acct_session_id=_online.acct_session_id,
message_type='disconnect')
redirect("/bus/member/detail?member_id={}".format(user.member_id))
def ticket_query(db):
account_number = request.params.get('account_number')
query_begin_time = request.params.get('query_begin_time')
query_end_time = request.params.get('query_end_time')
_query = db.query(
models.SlcRadTicket.id,
models.SlcRadTicket.account_number,
models.SlcRadTicket.nas_addr,
models.SlcRadTicket.acct_session_id,
models.SlcRadTicket.acct_start_time,
models.SlcRadTicket.acct_input_octets,
models.SlcRadTicket.acct_output_octets,
models.SlcRadTicket.acct_stop_time,
models.SlcRadTicket.framed_ipaddr,
models.SlcRadTicket.mac_addr,
models.SlcRadTicket.nas_port_id,
models.SlcMember.node_id,
models.SlcMember.realname
).filter(
models.SlcRadTicket.account_number == models.SlcRadAccount.account_number,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
models.SlcMember.member_id == get_cookie("customer_id")
)
if account_number:
_query = _query.filter(models.SlcRadTicket.account_number == account_number)
if query_begin_time:
_query = _query.filter(models.SlcRadTicket.acct_start_time >= query_begin_time)
if query_end_time:
_query = _query.filter(models.SlcRadTicket.acct_stop_time <= query_end_time)
_query = _query.order_by(models.SlcRadTicket.acct_start_time.desc())
return render("ticket_list",
accounts=db.query(models.SlcRadAccount).filter_by(member_id=get_cookie("customer_id")),
page_data = get_page_data(_query),
**request.params)
def product_update(db):
form=forms.product_update_form()
if not form.validates(source=request.forms):
return render("sys_product_form", form=form)
product = db.query(models.SlcRadProduct).get(form.d.id)
product.product_name = form.d.product_name
product.product_status = form.d.product_status
product.fee_months = form.d.get("fee_months",0)
product.bind_mac = form.d.bind_mac
product.bind_vlan = form.d.bind_vlan
product.concur_number = form.d.concur_number
product.fee_period = form.d.fee_period
product.fee_price = utils.yuan2fen(form.d.fee_price)
product.input_max_limit = form.d.input_max_limit
product.output_max_limit = form.d.output_max_limit
product.update_time = utils.get_currtime()
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)修改资费信息:%s'%(get_cookie("username"),serial_json(product))
db.add(ops_log)
db.commit()
websock.update_cache("product",product_id=product.id)
redirect("/product")
def account_recharge(db):
account_number = request.params.get('account_number')
form = forms.recharge_form()
form.recharge_card.set_value('')
form.recharge_pwd.set_value('')
form.account_number.set_value(account_number)
return render('base_form',form=form)
def product_add_post(db):
form=forms.product_add_form()
if not form.validates(source=request.forms):
return render("sys_product_form", form=form)
product = models.SlcRadProduct()
product.product_name = form.d.product_name
product.product_policy = form.d.product_policy
product.product_status = form.d.product_status
product.fee_months = form.d.get("fee_months",0)
product.bind_mac = form.d.bind_mac
product.bind_vlan = form.d.bind_vlan
product.concur_number = form.d.concur_number
product.fee_period = form.d.fee_period
product.fee_price = utils.yuan2fen(form.d.fee_price)
product.input_max_limit = form.d.input_max_limit
product.output_max_limit = form.d.output_max_limit
_datetime = datetime.datetime.now().strftime( "%Y-%m-%d %H:%M:%S")
product.create_time = _datetime
product.update_time = _datetime
db.add(product)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)新增资费信息:%s'%(get_cookie("username"),serial_json(product))
db.add(ops_log)
db.commit()
redirect("/product")
def account_update(db):
form = forms.account_update_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
account = db.query(models.SlcRadAccount).get(form.d.account_number)
account.ip_address = form.d.ip_address
account.install_address = form.d.install_address
account.user_concur_number = form.d.user_concur_number
account.bind_mac = form.d.bind_mac
account.bind_vlan = form.d.bind_vlan
if form.d.new_password:
account.password = utils.encrypt(form.d.new_password)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
_d = form.d.copy()
del _d['new_password']
ops_log.operate_desc = u'操作员(%s)修改上网账号信息:%s' % (get_cookie("username"),
json.dumps(_d))
db.add(ops_log)
db.commit()
websock.update_cache("account", account_number=account.account_number)
redirect("/bus/member/detail?member_id={}".format(account.member_id))
def opslog_query(db, render):
operator_name = request.params.get('operator_name')
query_begin_time = request.params.get('query_begin_time')
query_end_time = request.params.get('query_end_time')
keyword = request.params.get('keyword')
opr_nodes = get_opr_nodes(db)
_query = db.query(models.SlcRadOperateLog).filter(
models.SlcRadOperateLog.operator_name ==
models.SlcOperator.operator_name, )
if operator_name:
_query = _query.filter(
models.SlcRadOperateLog.operator_name == operator_name)
if keyword:
_query = _query.filter(
models.SlcRadOperateLog.operate_desc.like("%" + keyword + "%"))
if query_begin_time:
_query = _query.filter(
models.SlcRadOperateLog.operate_time >= query_begin_time +
' 00:00:00')
if query_end_time:
_query = _query.filter(
models.SlcRadOperateLog.operate_time <= query_end_time +
' 23:59:59')
_query = _query.order_by(models.SlcRadOperateLog.operate_time.desc())
return render("ops_log_list",
node_list=opr_nodes,
page_data=get_page_data(_query),
**request.params)
def cmanager_update(db, render):
manager_id = request.params.get("manager_id")
cmanager = db.query(models.SlcCustomerManager).get(manager_id)
form = cmanager_forms.cmanage_update_form(
oprs=get_oprs(db, copr_name=cmanager.operator_name))
form.fill(cmanager)
return render("base_form", form=form)
def member_detail(db):
member_id = request.params.get('member_id')
member = db.query(models.SlcMember).get(member_id)
accounts = db.query(
models.SlcMember.realname, models.SlcRadAccount.member_id,
models.SlcRadAccount.account_number, models.SlcRadAccount.expire_date,
models.SlcRadAccount.balance, models.SlcRadAccount.time_length,
models.SlcRadAccount.status, models.SlcRadAccount.last_pause,
models.SlcRadAccount.create_time, models.SlcRadProduct.product_name,
models.SlcRadProduct.product_policy).filter(
models.SlcRadProduct.id == models.SlcRadAccount.product_id,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
models.SlcRadAccount.member_id == member_id)
orders = db.query(
models.SlcMemberOrder.order_id, models.SlcMemberOrder.order_id,
models.SlcMemberOrder.product_id, models.SlcMemberOrder.account_number,
models.SlcMemberOrder.order_fee, models.SlcMemberOrder.actual_fee,
models.SlcMemberOrder.pay_status, models.SlcMemberOrder.create_time,
models.SlcMemberOrder.order_desc,
models.SlcRadProduct.product_name).filter(
models.SlcRadProduct.id == models.SlcMemberOrder.product_id,
models.SlcMemberOrder.member_id == member_id)
return render("bus_member_detail",
member=member,
accounts=accounts,
orders=orders)
def account_update(db):
form = forms.account_update_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
account = db.query(models.SlcRadAccount).get(form.d.account_number)
account.ip_address = form.d.ip_address
account.install_address = form.d.install_address
account.user_concur_number = form.d.user_concur_number
account.bind_mac = form.d.bind_mac
account.bind_vlan = form.d.bind_vlan
if form.d.new_password:
account.password = utils.encrypt(form.d.new_password)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
_d = form.d.copy()
del _d['new_password']
ops_log.operate_desc = u'操作员(%s)修改上网账号信息:%s'%(get_cookie("username"),json.dumps(_d))
db.add(ops_log)
db.commit()
websock.update_cache("account",account_number=account.account_number)
redirect(member_detail_url_formatter(account.member_id))
def index():
"""Main page with random kanji"""
lock = request.get_cookie("lock", secret="secret")
session = request.environ.get("beaker.session")
if lock:
kanji = Peon(db).get(lock)
else:
kanji = Peon(db).random()
favorites = request.get_cookie("favorites", secret="secret")
fav = False
if favorites:
favorites = json.loads(favorites)
if kanji.value in favorites:
fav = True
radicals = store.get_radicals(kanji.value)
return render(
"home",
kanji=kanji,
radicals=radicals,
rad_info=store.get_info_for_all(radicals),
lock=session.get("toggled", False),
rolled=lock,
fav=fav,
single_item=False,
)
def member_open(db):
nodes = [ (n.id,n.node_name) for n in db.query(models.SlcNode)]
products = [ (n.id,n.product_name) for n in db.query(models.SlcRadProduct).filter_by(
product_status = 0
)]
form = forms.user_open_form(nodes,products)
return render("bus_open_form",form=form)
def member_update(db):
member_id = request.params.get("member_id")
member = db.query(models.SlcMember).get(member_id)
nodes = [ (n.id,n.node_name) for n in db.query(models.SlcNode)]
form = forms.member_update_form(nodes)
form.fill(member)
return render("base_form",form=form)
def flow_stat_query(db, render):
return render(
"stat_flow",
node_list=get_opr_nodes(db),
node_id=None,
day_code=utils.get_currdate()
)
def menus(db):
menus_data = db.query(models.SlcParam).filter_by(param_name='mps_menus').first()
if menus_data:
menus_obj = json.loads(menus_data.param_value)
else:
menus_obj = {}
menus_obj['button'] = []
menu_names = {u'精彩推荐': 'menu1', u'产品订购': 'menu2', u'微营业厅': 'menu3'}
menu_buttons_array = menus_obj['button']
menudata = {}
for mbs in menu_buttons_array:
midx = menu_names[mbs['name']]
sub_buttons = mbs['sub_button']
_idx = 1
for sbmenu in sub_buttons:
menudata['%s_sub%s_type' % (midx, _idx)] = sbmenu['type']
menudata['%s_sub%s_name' % (midx, _idx)] = sbmenu['name']
menudata['%s_sub%s_key' % (midx, _idx)] = sbmenu.get('key', '')
menudata['%s_sub%s_url' % (midx, _idx)] = sbmenu.get('url', '')
_idx += 1
menu_str = json.dumps(menudata, ensure_ascii=False)#.replace('"', '\\"')
return render("mps_menus", menudata=menu_str)
def account_recharge(db):
account_number = request.params.get('account_number')
form = forms.recharge_form()
form.recharge_card.set_value('')
form.recharge_pwd.set_value('')
form.account_number.set_value(account_number)
return render('base_form', form=form)
def member_query(db):
node_id = request.params.get('node_id')
realname = request.params.get('realname')
idcard = request.params.get('idcard')
mobile = request.params.get('mobile')
_query = db.query(models.SlcMember, models.SlcNode.node_name).filter(
models.SlcNode.id == models.SlcMember.node_id)
if idcard:
_query = _query.filter(models.SlcMember.idcard == idcard)
if mobile:
_query = _query.filter(models.SlcMember.mobile == mobile)
if node_id:
_query = _query.filter(models.SlcMember.node_id == node_id)
if realname:
_query = _query.filter(
models.SlcMember.realname.like('%' + realname + '%'))
if request.path == '/member':
return render("bus_member_list",
page_data=get_page_data(_query),
node_list=db.query(models.SlcNode),
**request.params)
elif request.path == "/member/export":
data = Dataset()
data.append(
(u'区域', u'姓名', u'用户名', u'证件号', u'邮箱', u'联系电话', u'地址', u'创建时间'))
for i, _node_name in _query:
data.append((_node_name, i.realname, i.member_name, i.idcard,
i.email, i.mobile, i.address, i.create_time))
name = u"RADIUS-MEMBER-" + datetime.datetime.now().strftime(
"%Y%m%d-%H%M%S") + ".xls"
with open(u'./static/xls/%s' % name, 'wb') as f:
f.write(data.xls)
return static_file(name, root='./static/xls', download=True)
def user_query(db, render):
node_id = request.params.get("node_id")
product_id = request.params.get("product_id")
user_name = request.params.get("user_name")
status = request.params.get("status")
opr_nodes = get_opr_nodes(db)
_query = db.query(models.SlcRadAccount, models.SlcMember.realname, models.SlcRadProduct.product_name).filter(
models.SlcRadProduct.id == models.SlcRadAccount.product_id,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
)
if node_id:
_query = _query.filter(models.SlcMember.node_id == node_id)
else:
_query = _query.filter(models.SlcMember.node_id.in_([i.id for i in opr_nodes]))
if product_id:
_query = _query.filter(models.SlcRadAccount.product_id == product_id)
if user_name:
_query = _query.filter(models.SlcRadAccount.account_number.like("%" + user_name + "%"))
if status:
_query = _query.filter(models.SlcRadAccount.status == status)
if request.path == "/user":
return render(
"ops_user_list",
page_data=get_page_data(_query),
node_list=opr_nodes,
product_list=db.query(models.SlcRadProduct),
**request.params
)
def member_update(db):
member_id = request.params.get("member_id")
member = db.query(models.SlcMember).get(member_id)
nodes = [(n.id, n.node_name) for n in db.query(models.SlcNode)]
form = forms.member_update_form(nodes)
form.fill(member)
return render("base_form", form=form)
def issues_process_post(db, render):
form = issues_forms.issues_process_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
iflow = models.SlcIssuesFlow()
iflow.issues_id = form.d.issues_id
iflow.accept_time = utils.get_currtime()
iflow.accept_status = form.d.accept_status
iflow.accept_result = form.d.accept_result
iflow.operator_name = get_cookie("username")
db.add(iflow)
issues = db.query(models.SlcIssues).get(iflow.issues_id)
issues.status = iflow.accept_status
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)处理工单%s' % (get_cookie("username"),iflow.issues_id)
db.add(ops_log)
db.commit()
redirect("/issues/detail?issues_id=%s"%iflow.issues_id)
def online_stat_query(db):
return render(
"ops_online_stat",
node_list=db.query(models.SlcNode),
node_id=None,
day_code=utils.get_currdate()
)
def user_query(db, render):
node_id = request.params.get('node_id')
product_id = request.params.get('product_id')
user_name = request.params.get('user_name')
status = request.params.get('status')
opr_nodes = get_opr_nodes(db)
_query = db.query(
models.SlcRadAccount, models.SlcMember.realname,
models.SlcRadProduct.product_name).filter(
models.SlcRadProduct.id == models.SlcRadAccount.product_id,
models.SlcMember.member_id == models.SlcRadAccount.member_id)
if node_id:
_query = _query.filter(models.SlcMember.node_id == node_id)
else:
_query = _query.filter(
models.SlcMember.node_id.in_([i.id for i in opr_nodes]))
if product_id:
_query = _query.filter(models.SlcRadAccount.product_id == product_id)
if user_name:
_query = _query.filter(
models.SlcRadAccount.account_number.like('%' + user_name + '%'))
if status:
_query = _query.filter(models.SlcRadAccount.status == status)
if request.path == '/user':
return render("ops_user_list",
page_data=get_page_data(_query),
node_list=opr_nodes,
product_list=db.query(models.SlcRadProduct),
**request.params)
def member_query(db):
node_id = request.params.get('node_id')
realname = request.params.get('realname')
idcard = request.params.get('idcard')
mobile = request.params.get('mobile')
_query = db.query(
models.SlcMember,
models.SlcNode.node_name
).filter(
models.SlcNode.id == models.SlcMember.node_id
)
if idcard:
_query = _query.filter(models.SlcMember.idcard==idcard)
if mobile:
_query = _query.filter(models.SlcMember.mobile==mobile)
if node_id:
_query = _query.filter(models.SlcMember.node_id == node_id)
if realname:
_query = _query.filter(models.SlcMember.realname.like('%'+realname+'%'))
if request.path == '/member':
return render("bus_member_list", page_data = get_page_data(_query),
node_list=db.query(models.SlcNode),**request.params)
elif request.path == "/member/export":
data = Dataset()
data.append((u'区域',u'姓名',u'用户名',u'证件号',u'邮箱', u'联系电话', u'地址', u'创建时间'))
for i,_node_name in _query:
data.append((
_node_name, i.realname, i.member_name,i.idcard,
i.email,i.mobile, i.address,i.create_time
))
name = u"RADIUS-MEMBER-" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S") + ".xls"
with open(u'./static/xls/%s' % name, 'wb') as f:
f.write(data.xls)
return static_file(name, root='./static/xls',download=True)
def cmanager_list(db, render):
manager_code = request.params.get("manager_code")
_query = db.query(models.SlcCustomerManager)
if manager_code:
_query = _query.filter_by(manager_code=manager_code)
return render("sys_cmanager_list", page_data=get_page_data(_query), **request.params)
def ticket_query(db):
account_number = request.params.get('account_number')
query_begin_time = request.params.get('query_begin_time')
query_end_time = request.params.get('query_end_time')
_query = db.query(
models.SlcRadTicket.id, models.SlcRadTicket.account_number,
models.SlcRadTicket.nas_addr, models.SlcRadTicket.acct_session_id,
models.SlcRadTicket.acct_start_time,
models.SlcRadTicket.acct_input_octets,
models.SlcRadTicket.acct_output_octets,
models.SlcRadTicket.acct_stop_time, models.SlcRadTicket.framed_ipaddr,
models.SlcRadTicket.mac_addr, models.SlcRadTicket.nas_port_id,
models.SlcMember.node_id, models.SlcMember.realname).filter(
models.SlcRadTicket.account_number ==
models.SlcRadAccount.account_number,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
models.SlcMember.member_id == get_cookie("customer_id"))
if account_number:
_query = _query.filter(
models.SlcRadTicket.account_number == account_number)
if query_begin_time:
_query = _query.filter(
models.SlcRadTicket.acct_start_time >= query_begin_time)
if query_end_time:
_query = _query.filter(
models.SlcRadTicket.acct_stop_time <= query_end_time)
_query = _query.order_by(models.SlcRadTicket.acct_start_time.desc())
return render("ticket_list",
accounts=db.query(models.SlcRadAccount).filter_by(
member_id=get_cookie("customer_id")),
page_data=get_page_data(_query),
**request.params)
def issues_process_post(db, render):
form = issues_forms.issues_process_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
iflow = models.SlcIssuesFlow()
iflow.issues_id = form.d.issues_id
iflow.accept_time = utils.get_currtime()
iflow.accept_status = form.d.accept_status
iflow.accept_result = form.d.accept_result
iflow.operator_name = get_cookie("username")
db.add(iflow)
issues = db.query(models.SlcIssues).get(iflow.issues_id)
issues.status = iflow.accept_status
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)处理工单%s' % (get_cookie("username"),
iflow.issues_id)
db.add(ops_log)
db.commit()
redirect("/issues/detail?issues_id=%s" % iflow.issues_id)
def opslog_query(db):
node_id = request.params.get('node_id')
operator_name = request.params.get('operator_name')
query_begin_time = request.params.get('query_begin_time')
query_end_time = request.params.get('query_end_time')
_query = db.query(
models.SlcRadOperateLog,
models.SlcOperator.node_id,
).filter(
models.SlcRadOperateLog.operator_name ==
models.SlcOperator.operator_name, )
if node_id:
_query = _query.filter(models.SlcOperator.node_id == node_id)
if operator_name:
_query = _query.filter(
models.SlcRadOperateLog.operator_name == operator_name)
if query_begin_time:
_query = _query.filter(
models.SlcRadOperateLog.operate_time >= query_begin_time)
if query_end_time:
_query = _query.filter(
models.SlcRadOperateLog.operate_time <= query_end_time)
_query = _query.order_by(models.SlcRadOperateLog.operate_time.desc())
return render("ops_log_list",
node_list=db.query(models.SlcNode),
page_data=get_page_data(_query),
**request.params)
def billing_query(db):
account_number = request.params.get('account_number')
query_begin_time = request.params.get('query_begin_time')
query_end_time = request.params.get('query_end_time')
_query = db.query(
models.SlcRadBilling,
models.SlcMember.node_id,
).filter(
models.SlcRadBilling.account_number ==
models.SlcRadAccount.account_number,
models.SlcMember.member_id == models.SlcRadAccount.member_id,
models.SlcMember.member_id == get_cookie("customer_id"))
if account_number:
_query = _query.filter(
models.SlcRadBilling.account_number.like('%' + account_number +
'%'))
if query_begin_time:
_query = _query.filter(
models.SlcRadBilling.create_time >= query_begin_time)
if query_end_time:
_query = _query.filter(
models.SlcRadBilling.create_time <= query_end_time)
_query = _query.order_by(models.SlcRadBilling.create_time.desc())
return render("billing_list",
accounts=db.query(models.SlcRadAccount).filter_by(
member_id=get_cookie("customer_id")),
page_data=get_page_data(_query),
**request.params)
def product_add_post(db):
form = forms.product_add_form()
if not form.validates(source=request.forms):
return render("sys_product_form", form=form)
product = models.SlcRadProduct()
product.product_name = form.d.product_name
product.product_policy = form.d.product_policy
product.product_status = form.d.product_status
product.fee_months = form.d.get("fee_months", 0)
product.bind_mac = form.d.bind_mac
product.bind_vlan = form.d.bind_vlan
product.concur_number = form.d.concur_number
product.fee_period = form.d.fee_period
product.fee_price = utils.yuan2fen(form.d.fee_price)
product.input_max_limit = form.d.input_max_limit
product.output_max_limit = form.d.output_max_limit
_datetime = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
product.create_time = _datetime
product.update_time = _datetime
db.add(product)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)新增资费信息:%s' % (get_cookie("username"),
serial_json(product))
db.add(ops_log)
db.commit()
redirect("/product")
def product_update(db):
form = forms.product_update_form()
if not form.validates(source=request.forms):
return render("sys_product_form", form=form)
product = db.query(models.SlcRadProduct).get(form.d.id)
product.product_name = form.d.product_name
product.product_status = form.d.product_status
product.fee_months = form.d.get("fee_months", 0)
product.bind_mac = form.d.bind_mac
product.bind_vlan = form.d.bind_vlan
product.concur_number = form.d.concur_number
product.fee_period = form.d.fee_period
product.fee_price = utils.yuan2fen(form.d.fee_price)
product.input_max_limit = form.d.input_max_limit
product.output_max_limit = form.d.output_max_limit
product.update_time = utils.get_currtime()
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)修改资费信息:%s' % (get_cookie("username"),
serial_json(product))
db.add(ops_log)
db.commit()
websock.update_cache("product", product_id=product.id)
redirect("/product")
def account_next(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
user = query_account(db,account_number)
form = forms.account_next_form()
form.product_id.set_value(user.product_id)
if account.status not in (1,4):
return render("bus_account_next_form", user=user,form=form,msg=u"无效用户状态")
if not form.validates(source=request.forms):
return render("bus_account_next_form", user=user,form=form)
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'next'
accept_log.accept_source = 'console'
accept_log.accept_desc = u"用户续费：上网账号:%s，续费%s元"%(account_number,form.d.fee_value)
accept_log.account_number = form.d.account_number
accept_log.accept_time = utils.get_currtime()
accept_log.operator_name = get_cookie("username")
db.add(accept_log)
db.flush()
db.refresh(accept_log)
order_fee = 0
product = db.query(models.SlcRadProduct).get(user.product_id)
order_fee = decimal.Decimal(product.fee_price) * decimal.Decimal(form.d.months)
order_fee = int(order_fee.to_integral_value())
order = models.SlcMemberOrder()
order.order_id = utils.gen_order_id()
order.member_id = user.member_id
order.product_id = user.product_id
order.account_number = form.d.account_number
order.order_fee = order_fee
order.actual_fee = utils.yuan2fen(form.d.fee_value)
order.pay_status = 1
order.accept_id = accept_log.id
order.order_source = 'console'
order.create_time = utils.get_currtime()
order.order_desc = u"用户续费"
db.add(order)
account.status = 1
account.expire_date = form.d.expire_date
db.commit()
websock.update_cache("account",account_number=account_number)
redirect(member_detail_url_formatter(user.member_id))
def account_next(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
user = query_account(db,account_number)
form = forms.account_cancel_form()
if account.status !=1 :
return render("bus_account_form", user=user,form=form,msg=u"无效用户状态")
if not form.validates(source=request.forms):
return render("bus_account_form", user=user,form=form)
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'cancel'
accept_log.accept_source = 'console'
accept_log.account_number = form.d.account_number
accept_log.accept_time = utils.get_currtime()
accept_log.operator_name = get_cookie("username")
accept_log.accept_desc = u"用户销户：上网账号:%s，退费%s(元)"%(account_number,form.d.fee_value)
db.add(accept_log)
db.flush()
db.refresh(accept_log)
order = models.SlcMemberOrder()
order.order_id = utils.gen_order_id()
order.member_id = user.member_id
order.product_id = user.product_id
order.account_number = form.d.account_number
order.order_fee = 0
order.actual_fee = -utils.yuan2fen(form.d.fee_value)
order.pay_status = 1
order.order_source = 'console'
order.accept_id = accept_log.id
order.create_time = utils.get_currtime()
order.order_desc = u'用户销户'
db.add(order)
account.status = 3
db.commit()
websock.update_cache("account",account_number=account_number)
onlines = db.query(models.SlcRadOnline).filter_by(account_number=account_number)
for _online in onlines:
websock.invoke_admin("coa_request",
nas_addr=_online.nas_addr,
acct_session_id=_online.acct_session_id,
message_type='disconnect')
redirect(member_detail_url_formatter(user.member_id))
def account_update(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
groups = [ (n.id,n.group_name) for n in db.query(models.SlcRadGroup)]
groups.insert(0,('',''))
form = forms.account_update_form(groups)
form.fill(account)
return render("base_form",form=form)
def account_next(db):
account_number = request.params.get("account_number")
user = query_account(db,account_number)
form = forms.account_next_form()
form.account_number.set_value(account_number)
form.old_expire.set_value(user.expire_date)
form.product_id.set_value(user.product_id)
return render("bus_account_next_form",user=user,form=form)
def product_update(db):
product_id = request.params.get("product_id")
form=forms.product_update_form()
product = db.query(models.SlcRadProduct).get(product_id)
form.fill(product)
form.product_policy_name.set_value(forms.product_policy[product.product_policy])
form.fee_price.set_value(utils.fen2yuan(product.fee_price))
return render("sys_product_form",form=form)
def account_next(db):
account_number = request.params.get("account_number")
user = query_account(db, account_number)
form = forms.account_next_form()
form.account_number.set_value(account_number)
form.old_expire.set_value(user.expire_date)
form.product_id.set_value(user.product_id)
return render("bus_account_next_form", user=user, form=form)
def member_login_post(db):
next = request.params.get("next", "/")
form = forms.member_login_form()
if not form.validates(source=request.params):
return render("login", form=form)
member = db.query(models.SlcMember).filter_by(
member_name=form.d.username,
password=md5(form.d.password.encode()).hexdigest()).first()
if not member:
return render("login", form=form, msg=u"用户名密码不符合")
set_cookie('customer_id', member.member_id)
set_cookie('customer', form.d.username)
set_cookie('customer_login_time', utils.get_currtime())
set_cookie('customer_login_ip', request.remote_addr)
redirect(next)
def product_update(db):
product_id = request.params.get("product_id")
form = forms.product_update_form()
product = db.query(models.SlcRadProduct).get(product_id)
form.fill(product)
form.product_policy_name.set_value(
forms.product_policy[product.product_policy])
form.fee_price.set_value(utils.fen2yuan(product.fee_price))
return render("sys_product_form", form=form)
def passwd_update(db):
form = forms.passwd_update_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
if form.d.operator_pass != form.d.operator_pass_chk:
return render("base_form", form=form, msg=u"确认密码不一致")
opr = db.query(models.SlcOperator).first()
opr.operator_pass = md5(form.d.operator_pass).hexdigest()
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = get_cookie("username")
ops_log.operate_ip = get_cookie("login_ip")
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)修改密码' % (get_cookie("username"), )
db.add(ops_log)
db.commit()
redirect("/passwd")
