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 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 product_update(db, render):
    form = product_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 = int(form.d.get("fee_months", 0))
    product.fee_times = utils.hour2sec(form.d.get("fee_times", 0))
    product.fee_flows = utils.mb2kb(form.d.get("fee_flows", 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 = utils.mbps2bps(form.d.input_max_limit)
    product.output_max_limit = utils.mbps2bps(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"), product.product_name)
    db.add(ops_log)

    db.commit()
    websock.update_cache("product", product_id=product.id)
    redirect(__prefix__)

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 account_resume(db,render):
    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, render):
    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_post(db, render):
    form = account_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
    account.account_desc = form.d.account_desc
    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()
    ops_log.operate_desc = u'操作员(%s)修改上网账号信息:%s' % (get_cookie("username"), account.account_number)
    db.add(ops_log)

    db.commit()
    websock.update_cache("account", account_number=account.account_number)
    redirect(member_detail_url_formatter(account.account_number))

def member_delete(db, render):
    member_id = request.params.get("member_id")
    if not member_id:
        raise abort(404, 'member_id is empty')
    db.query(models.SlcMember).filter_by(member_id=member_id).delete()
    for account in db.query(models.SlcRadAccount).filter_by(member_id=member_id):
        db.query(models.SlcRadAcceptLog).filter_by(account_number=account.account_number).delete()
        db.query(models.SlcRadAccountAttr).filter_by(account_number=account.account_number).delete()
        db.query(models.SlcRadBilling).filter_by(account_number=account.account_number).delete()
        db.query(models.SlcRadTicket).filter_by(account_number=account.account_number).delete()
        db.query(models.SlcRadOnline).filter_by(account_number=account.account_number).delete()
        db.query(models.SlcRechargeLog).filter_by(account_number=account.account_number).delete()
    db.query(models.SlcRadAccount).filter_by(member_id=member_id).delete()
    db.query(models.SlcMemberOrder).filter_by(member_id=member_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"), member_id)
    db.add(ops_log)

    db.commit()

    return redirect("/member")

def product_add_post(db, render):
    form = product_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 = int(form.d.get("fee_months", 0))
    product.fee_times = utils.hour2sec(form.d.get("fee_times", 0))
    product.fee_flows = utils.mb2kb(form.d.get("fee_flows", 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 = utils.mbps2bps(form.d.input_max_limit)
    product.output_max_limit = utils.mbps2bps(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"), product.product_name)
    db.add(ops_log)

    db.commit()
    redirect(__prefix__)

def member_update_post(db, render):
    nodes = [(n.id, n.node_name) for n in get_opr_nodes(db)]
    form = member_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.email = form.d.email
    member.idcard = form.d.idcard
    member.mobile = form.d.mobile
    member.address = form.d.address
    member.member_desc = form.d.member_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"), member.member_name)
    db.add(ops_log)

    db.commit()
    redirect(member_detail_url_formatter(form.d.account_number))

def member_login_post(db, render):
    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, path="/")
    set_cookie('customer', form.d.username,path="/")
    set_cookie('customer_login_time', utils.get_currtime(), path="/")
    set_cookie('customer_login_ip', request.remote_addr, path="/")
    redirect(next)

def param_update(db): 
    params = db.query(models.SlcParam)
    for param in params:
        if param.param_name in request.forms:
            _value = request.forms.get(param.param_name)
            if _value: 
                param.param_value = _value  
                
    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()
    
    websock.reconnect(
        request.forms.get('radiusd_address'),
        request.forms.get('radiusd_admin_port'),
    )
        
    is_debug = request.forms.get('is_debug')
    bottle.debug(is_debug == '1')
    
    websock.update_cache("is_debug",is_debug=is_debug)
    websock.update_cache("reject_delay",reject_delay=request.forms.get('reject_delay'))
    websock.update_cache("param")
    redirect("/param")

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 opr_add_update(db, render):
    nodes = [(n.node_name, n.node_desc) for n in db.query(models.SlcNode)]
    form = opr_forms.opr_update_form(nodes)
    if not form.validates(source=request.forms):
        rules = db.query(models.SlcOperatorRule.rule_path).filter_by(operator_name=opr.operator_name)
        rules = [r[0] for r in rules]
        return render("sys_opr_form", form=form, rules=rules)
    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

    db.query(models.SlcOperatorNodes).filter_by(operator_name=opr.operator_name).delete()
    for node in request.params.getall("operator_nodes"):
        onode = models.SlcOperatorNodes()
        onode.operator_name = form.d.operator_name
        onode.node_name = node
        db.add(onode)

    db.query(models.SlcOperatorProducts).filter_by(operator_name=opr.operator_name).delete()
    for product_id in request.params.getall("operator_products"):
        oproduct = models.SlcOperatorProducts()
        oproduct.operator_name = form.d.operator_name
        oproduct.product_id = product_id
        db.add(oproduct)

    # 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"), opr.operator_name)
    db.add(ops_log)

    db.commit()
    redirect("/opr")

def member_join_post(db, render):
    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()
    member.email_active = 0
    member.mobile_active = 0
    member.active_code = utils.get_uuid()
    db.add(member) 
    db.commit()
    
    topic = u'%s,请验证您在%s注册的电子邮件地址'%(member.realname,get_param_value(db,"customer_system_name"))
    ctx = dict(
        username = member.realname,
        customer_name = get_param_value(db,"customer_system_name"),
        customer_url = get_param_value(db,"customer_system_url"),
        active_code = member.active_code
    )
    reactor.callInThread(mail.sendmail,member.email,topic,render("mail",**ctx))
    return render('msg',msg=u"新用户注册成功,请注意查收您的注册邮箱，及时激活账户")

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_add_post(db, render):
    nodes = [(n.node_name, n.node_desc) for n in db.query(models.SlcNode)]
    products = [(p.id, p.product_name) for p in db.query(models.SlcRadProduct)]
    form = opr_forms.opr_add_form(nodes,products)
    if not form.validates(source=request.forms):
        return render("sys_opr_form", form=form, rules=[])
    if db.query(models.SlcOperator.id).filter_by(operator_name=form.d.operator_name).count() > 0:
        return render("sys_opr_form", form=form, rules=[], 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 node in request.params.getall("operator_nodes"):
        onode = models.SlcOperatorNodes()
        onode.operator_name = form.d.operator_name
        onode.node_name = node
        db.add(onode)

    for product_id in request.params.getall("operator_products"):
        oproduct = models.SlcOperatorProducts()
        oproduct.operator_name = form.d.operator_name
        oproduct.product_id = product_id
        db.add(oproduct)


    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"), opr.operator_name)
    db.add(ops_log)

    db.commit()
    redirect("/opr")

def issues_delete_post(db, render):
    issues_id = request.params.get("issues_id")
    db.query(models.SlcIssues).filter_by(id=issues_id).delete()
    db.query(models.SlcIssuesFlow).filter_by(issues_id=issues_id)

    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"), issues_id)
    db.add(ops_log)

    db.commit()

    redirect("/issues/list")

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")