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 admin_login_post(db):
uname = request.forms.get("username")
upass = request.forms.get("password")
if not uname:return dict(code=1,msg=u"请填写用户名")
if not upass:return dict(code=1,msg=u"请填写密码")
enpasswd = md5(upass.encode()).hexdigest()
opr = db.query(models.SlcOperator).filter_by(
operator_name=uname,
operator_pass=enpasswd
).first()
if not opr:return dict(code=1,msg=u"用户名密码不符")
if opr.operator_status == 1:return dict(code=1,msg=u"该操作员账号已被停用")
set_cookie('username',uname)
set_cookie('opr_type',opr.operator_type)
set_cookie('login_time', utils.get_currtime())
set_cookie('login_ip', request.remote_addr)
if opr.operator_type > 0:
permit.unbind_opr(uname)
for rule in db.query(models.SlcOperatorRule).filter_by(operator_name=uname):
permit.bind_opr(rule.operator_name,rule.rule_path)
ops_log = models.SlcRadOperateLog()
ops_log.operator_name = uname
ops_log.operate_ip = request.remote_addr
ops_log.operate_time = utils.get_currtime()
ops_log.operate_desc = u'操作员(%s)登陆'%(uname,)
db.add(ops_log)
db.commit()
return dict(code=0,msg="ok")
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 account_resume(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
if account.status != 2:
return dict(msg=u"用户当前状态不允许复机")
account.status = 1
_datetime = datetime.datetime.now()
_pause_time = datetime.datetime.strptime(account.last_pause,"%Y-%m-%d %H:%M:%S")
_expire_date = datetime.datetime.strptime(account.expire_date+' 23:59:59',"%Y-%m-%d %H:%M:%S")
days = (_expire_date - _pause_time).days
new_expire = (_datetime + datetime.timedelta(days=int(days))).strftime("%Y-%m-%d")
account.expire_date = new_expire
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'resume'
accept_log.accept_source = 'console'
accept_log.accept_desc = u"用户复机：上网账号:%s"%(account_number)
accept_log.account_number = account.account_number
accept_log.accept_time = utils.get_currtime()
accept_log.operator_name = get_cookie("username")
db.add(accept_log)
db.commit()
websock.update_cache("account",account_number=account.account_number)
return dict(msg=u"操作成功")
def account_pause(db):
account_number = request.params.get("account_number")
account = db.query(models.SlcRadAccount).get(account_number)
if account.status != 1:
return dict(msg=u"用户当前状态不允许停机")
_datetime = utils.get_currtime()
account.last_pause = _datetime
account.status = 2
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'pause'
accept_log.accept_source = 'console'
accept_log.accept_desc = u"用户停机：上网账号:%s"%(account_number)
accept_log.account_number = account.account_number
accept_log.accept_time = _datetime
accept_log.operator_name = get_cookie("username")
db.add(accept_log)
db.commit()
websock.update_cache("account",account_number=account.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')
return dict(msg=u"操作成功")
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 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 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 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 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_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_charge(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_charge_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 = 'charge'
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")
_new_fee = account.balance + utils.yuan2fen(form.d.fee_value)
accept_log.accept_desc = u"用户充值：上网账号:%s，充值前%s(分),充值后%s(分)"%(account_number,account.balance,_new_fee)
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.accept_id = accept_log.id
order.order_source = 'console'
order.create_time = utils.get_currtime()
order.order_desc = u"用户充值"
db.add(order)
account.balance += order.actual_fee
db.commit()
websock.update_cache("account",account_number=account_number)
redirect(member_detail_url_formatter(user.member_id))
def bas_delete(db):
bas_id = request.params.get("bas_id")
db.query(models.SlcRadBas).filter_by(id=bas_id).delete()
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"),bas_id)
db.add(ops_log)
db.commit()
redirect("/bas")
def opr_delete(db):
opr_id = request.params.get("opr_id")
db.query(models.SlcOperator).filter_by(id=opr_id).delete()
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"),opr_id)
db.add(ops_log)
db.commit()
redirect("/opr")
def node_delete(db):
node_id = request.params.get("node_id")
if db.query(models.SlcMember.member_id).filter_by(node_id=node_id).count()>0:
return render("error",msg=u"该节点下有用户，不允许删除")
db.query(models.SlcNode).filter_by(id=node_id).delete()
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"),node_id)
db.add(ops_log)
db.commit()
redirect("/node")
def roster_delete(db):
roster_id = request.params.get("roster_id")
mac_addr = db.query(models.SlcRadRoster).get(roster_id).mac_addr
db.query(models.SlcRadRoster).filter_by(id=roster_id).delete()
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"),roster_id)
db.add(ops_log)
db.commit()
websock.update_cache("roster",mac_addr=mac_addr)
redirect("/roster")
def admin_logout(db):
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()
if get_cookie('opt_type') > 0:
permit.unbind_opr(get_cookie("username"))
set_cookie('username',None)
set_cookie('login_time', None)
set_cookie('opr_type',None)
set_cookie('login_ip', None)
request.cookies.clear()
redirect('/login')
def product_attr_update(db):
attr_id = request.params.get("attr_id")
attr = db.query(models.SlcRadProductAttr).get(attr_id)
product_id = attr.product_id
db.query(models.SlcRadProductAttr).filter_by(id=attr_id).delete()
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(attr))
db.add(ops_log)
db.commit()
websock.update_cache("product",product_id=product_id)
redirect("/product/detail?product_id=%s"%product_id)
def card_recycle(db):
card_id = request.params.get("card_id")
if not card_id:
return dict(code=0,msg=u"非法的访问")
card = db.query(models.SlcRechargerCard).get(card_id)
if not card:
return dict(code=0,msg=u"充值卡不存在")
card.card_status = 3
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"),card.card_number)
db.add(ops_log)
db.commit()
return dict(code=0,msg=u"回收成功，充值卡已不可使用")
def product_delete(db):
product_id = request.params.get("product_id")
if db.query(models.SlcRadAccount).filter_by(product_id=product_id).count()>0:
return render("error",msg=u"该套餐有用户使用，不允许删除")
db.query(models.SlcRadProduct).filter_by(id=product_id).delete()
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"),product_id)
db.add(ops_log)
db.commit()
websock.update_cache("product",product_id=product_id)
redirect("/product")
def user_release(db):
account_number = request.params.get('account_number')
user = db.query(models.SlcRadAccount).filter_by(account_number=account_number).first()
user.mac_addr = ''
user.vlan_id = 0
user.vlan_id2 = 0
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）绑定信息'%(account_number,)
db.add(ops_log)
db.commit()
websock.update_cache("account",account_number=account_number)
return dict(code=0,msg=u"解绑成功")
def node_add_update(db):
form=forms.node_update_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
node = db.query(models.SlcNode).get(form.d.id)
node.node_name = form.d.node_name
node.node_desc = form.d.node_desc
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(node))
db.add(ops_log)
db.commit()
redirect("/node")
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")
def roster_add_update(db):
form=forms.roster_update_form()
if not form.validates(source=request.forms):
return render("sys_roster_form", form=form)
roster = db.query(models.SlcRadRoster).get(form.d.id)
roster.begin_time = form.d.begin_time
roster.end_time = form.d.end_time
roster.roster_type = form.d.roster_type
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 product_attr_update(db):
form = forms.product_attr_update_form()
if not form.validates(source=request.forms):
return render("pattr_form", form=form,pattrs=radius_attrs)
attr = db.query(models.SlcRadProductAttr).get(form.d.id)
attr.attr_name = form.d.attr_name
attr.attr_value = form.d.attr_value
attr.attr_desc = form.d.attr_desc
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(attr))
db.add(ops_log)
db.commit()
websock.update_cache("product",product_id=form.d.product_id)
redirect("/product/detail?product_id="+form.d.product_id)
def portal_auth(db):
user = request.params.get("user")
token = request.params.get("token")
secret = get_param_value(db,"8_portal_secret")
date = utils.get_currdate()
_token = md5("%s%s%s"%(user,secret,date)).hexdigest()
if _token == token:
account = get_account_by_number(db,user)
print account
if not account:
return render("error",msg=u"用户%s不存在!"%user)
member = db.query(models.SlcMember).get(account.member_id)
set_cookie('customer_id',member.member_id,path="/")
set_cookie('customer',member.member_name,path="/")
set_cookie('customer_login_time', utils.get_currtime(),path="/")
set_cookie('customer_login_ip', request.remote_addr,path="/")
redirect("/")
else:
return render("error",msg=u"无效的访问!")
def bas_add_update(db):
form=forms.bas_update_form()
if not form.validates(source=request.forms):
return render("base_form", form=form)
bas = db.query(models.SlcRadBas).get(form.d.id)
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
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()
websock.update_cache("bas",ip_addr=bas.ip_addr)
redirect("/bas")
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 member_update(db):
nodes = [ (n.id,n.node_name) for n in db.query(models.SlcNode)]
form=forms.member_update_form(nodes)
if not form.validates(source=request.forms):
return render("base_form", form=form)
member = db.query(models.SlcMember).get(form.d.member_id)
member.realname = form.d.realname
if form.d.new_password:
member.password = md5(form.d.new_password.encode()).hexdigest()
member.idcard = form.d.idcard
member.mobile = form.d.mobile
member.address = form.d.address
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"),member.member_name)
db.add(ops_log)
db.commit()
redirect(member_detail_url_formatter(member.member_id))
def opr_add_update(db):
form=forms.opr_update_form()
if not form.validates(source=request.forms):
return render("sys_opr_form", form=form)
opr = db.query(models.SlcOperator).get(form.d.id)
if form.d.operator_pass:
opr.operator_pass = md5(form.d.operator_pass).hexdigest()
opr.operator_desc = form.d.operator_desc
opr.operator_status = form.d.operator_status
# update rules
db.query(models.SlcOperatorRule).filter_by(operator_name=opr.operator_name).delete()
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)
permit.unbind_opr(opr.operator_name)
for rule in db.query(models.SlcOperatorRule).filter_by(operator_name=opr.operator_name):
permit.bind_opr(rule.operator_name,rule.rule_path)
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 account_open(db):
products = [ (n.id,n.product_name) for n in db.query(models.SlcRadProduct).filter_by(
product_status = 0
)]
groups = [ (n.id,n.group_name) for n in db.query(models.SlcRadGroup)]
groups.insert(0,('',''))
form = forms.account_open_form(products,groups)
if not form.validates(source=request.forms):
return render("bus_open_form", form=form)
if db.query(models.SlcRadAccount).filter_by(
account_number=form.d.account_number).count()>0:
return render("bus_open_form", form=form,msg=u"上网账号已经存在")
if form.d.ip_address and db.query(models.SlcRadAccount).filter_by(ip_address=form.d.ip_address).count()>0:
return render("bus_open_form", form=form,msg=u"ip%s已经被使用"%form.d.ip_address)
accept_log = models.SlcRadAcceptLog()
accept_log.accept_type = 'open'
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"%(form.d.account_number)
db.add(accept_log)
db.flush()
db.refresh(accept_log)
_datetime = utils.get_currtime()
order_fee = 0
balance = 0
expire_date = form.d.expire_date
product = db.query(models.SlcRadProduct).get(form.d.product_id)
if product.product_policy == 0:
order_fee = decimal.Decimal(product.fee_price) * decimal.Decimal(form.d.months)
order_fee = int(order_fee.to_integral_value())
elif product.product_policy == 1:
balance = utils.yuan2fen(form.d.fee_value)
expire_date = '3000-11-11'
order = models.SlcMemberOrder()
order.order_id = utils.gen_order_id()
order.member_id = form.d.member_id
order.product_id = 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 = _datetime
order.order_desc = u"用户增开账号"
db.add(order)
account = models.SlcRadAccount()
account.account_number = form.d.account_number
account.ip_address = form.d.ip_address
account.member_id = int(form.d.member_id)
account.product_id = order.product_id
account.install_address = form.d.address
account.mac_addr = ''
account.password = utils.encrypt(form.d.password)
account.status = form.d.status
account.balance = balance
account.time_length = 0
account.expire_date = expire_date
account.user_concur_number = product.concur_number
account.bind_mac = product.bind_mac
account.bind_vlan = product.bind_vlan
account.vlan_id = 0
account.vlan_id2 = 0
account.create_time = _datetime
account.update_time = _datetime
db.add(account)
db.commit()
redirect("/bus/member/detail?member_id={}".format(form.d.member_id))
