def get(self):
builder_id = self.get_argument('builder_id')
self.db.query(models.TrBuilder).filter_by(id=builder_id).delete()
self.db.query(models.TrAreaBuilder).filter_by(builder_id=builder_id).delete()
self.add_oplog(u'删除服务人员:%s' % builder_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrBuilder.__tablename__, dict(id=builder_id)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAreaBuilder.__tablename__, dict(builder_id=builder_id)), async=True)
self.redirect('/admin/builder', permanent=False)
def get(self):
area_id = self.get_argument('area_id')
node_id = self.db.query(models.TrArea.node_id).filter_by(id=area_id).scalar()
if self.db.query(models.TrCustomer.customer_id).filter_by(area_id=area_id).count() > 0:
return self.render_error(msg=u'该社区下有用户，不允许删除')
self.db.query(models.TrArea).filter_by(id=area_id).delete()
self.db.query(models.TrAreaBuilder).filter_by(area_id=area_id).delete()
self.add_oplog(u'删除社区信息:%s' % area_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrArea.__tablename__, dict(id=area_id)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAreaBuilder.__tablename__, dict(area_id=area_id)), async=True)
self.redirect('/admin/area?node_id=%s' % node_id, permanent=False)
def get(self):
issues_id = self.get_argument('issues_id')
self.db.query(models.TrIssues).filter_by(id=issues_id).delete()
self.db.query(models.TrIssuesFlow).filter_by(issues_id=issues_id)
self.add_oplog(u'删除工单%s' % issues_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrIssues.__tablename__,
dict(id=issues_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrIssuesFlow.__tablename__,
dict(issues_id=issues_id)),
async=True)
self.redirect('/admin/issues/list')
def get(self):
charge_code = self.get_argument('charge_code')
self.db.query(models.TrCharges).filter_by(charge_code=charge_code).delete()
self.add_oplog(u'删除收费项信息:%s' % charge_code)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrCharges.__tablename__, dict(charge_code=charge_code)), async=True)
self.redirect('/admin/charge', permanent=False)
def get(self):
tpl_id = self.get_argument('tpl_id')
self.db.query(models.TrContentTemplate).filter_by(id=tpl_id).delete()
self.add_oplog(u'删除模板信息:%s' % tpl_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrContentTemplate.__tablename__, dict(id=tpl_id)), async=True)
self.redirect('/admin/contenttpl', permanent=False)
def get(self):
operator_id = self.get_argument('operator_id')
opr = self.db.query(models.TrOperator).get(operator_id)
self.db.query(models.TrOperatorRule).filter_by(
operator_name=opr.operator_name).delete()
self.db.query(models.TrOperator).filter_by(id=operator_id).delete()
self.add_oplog(u'删除操作员%s信息' % utils.safeunicode(opr.operator_name))
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrOperatorRule.__tablename__,
dict(id=operator_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrOperator.__tablename__,
dict(id=operator_id)),
async=True)
self.redirect('/admin/operator', permanent=False)
def get(self):
customer_id = self.get_argument('customer_id')
if not customer_id:
return self.render_error(msg=u'无效的客户ID')
account = self.db.query(models.TrAccount).filter_by(customer_id=customer_id).first()
account_number = account.account_number
self.db.query(models.TrAcceptLog).filter_by(account_number=account_number).delete()
self.db.query(models.TrAccountAttr).filter_by(account_number=account_number).delete()
self.db.query(models.TrBilling).filter_by(account_number=account_number).delete()
self.db.query(models.TrTicket).filter_by(account_number=account_number).delete()
self.db.query(models.TrOnline).filter_by(account_number=account_number).delete()
self.db.query(models.TrAccount).filter_by(account_number=account_number).delete()
self.db.query(models.TrCustomerOrder).filter_by(account_number=account_number).delete()
self.add_oplog(u'删除用户账号%s' % account_number)
self.db.query(models.TrCustomer).filter_by(customer_id=customer_id).delete()
self.add_oplog(u'删除用户资料 %s' % customer_id)
self.db.commit()
dispatch.pub(evset.ACCOUNT_DELETE_EVENT, account_number, async=True)
dispatch.pub(evset.CACHE_DELETE_EVENT, account_cache_key(account_number), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAcceptLog.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccountAttr.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrBilling.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOnline.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccount.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrCustomerOrder.__tablename__, dict(account_number=account_number)), async=True)
dispatch.pub(evset.DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrCustomer.__tablename__, dict(customer_id=customer_id)), async=True)
return self.redirect('/admin/customer')
def get(self):
rule_id = self.get_argument('rule_id')
if self.db.query(models.TrNode).filter_by(rule_id=rule_id).count() > 0:
return self.render_error(msg=u'账号生成规则已经被区域关联，请先取消关联。')
self.db.query(models.TrAccountRule).filter_by(id=rule_id).delete()
self.add_oplog(u'删除账号生成规则信息:%s' % rule_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccountRule.__tablename__, dict(id=rule_id)), async=True)
self.redirect('/admin/account_rule', permanent=False)
def get(self):
attr_id = self.get_argument('attr_id')
attr = self.db.query(models.TrBasAttr).get(attr_id)
bas_id = attr.bas_id
self.db.query(models.TrBasAttr).filter_by(id=attr_id).delete()
self.add_oplog(u'删除BAS属性信息:%s' % attr.attr_name)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrBasAttr.__tablename__, dict(id=attr_id)), async=True)
self.redirect('/admin/bas/detail?bas_id=%s' % bas_id)
def delete(self, node_id, **kwargs):
try:
node = self.get_safe_node(node_id)
if self.db.query(models.TrCustomer.customer_id).filter_by(
node_id=node_id).count() > 0:
raise ValueError(u'该区域节点下有用户，不允许删除')
self.db.query(models.TrNode).filter_by(id=node_id).delete()
abuuilders = []
for area in self.db.query(
models.TrArea).filter_by(node_id=node_id):
abuuilders.append(area_id=area.id)
self.db.query(
models.TrAreaBuilder).filter_by(area_id=area.id).delete()
self.db.query(
models.TrNodeAttr).filter_by(node_id=node_id).delete()
self.db.query(models.TrArea).filter_by(node_id=node_id).delete()
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrNode.__tablename__,
dict(id=node_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrArea.__tablename__,
dict(node_id=node_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrNodeAttr.__tablename__,
dict(node_id=node_id)),
async=True)
for abid in abuuilders:
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(
models.TrAreaBuilder.__tablename__,
dict(area_id=abid)),
async=True)
self.add_oplog(u'删除区域信息:%s' % node_id)
self.db.commit()
return True
except Exception as err:
self.db.rollback()
logger.exception(err, tag='node_delete_error')
self.last_error = u'删除区域失败:%s' % utils.safeunicode(err)
return False
def delete(self, account_number, **kwargs):
"""用户账号删除
:param account_number: 用户账号
:type account_number: string
"""
try:
if not account_number:
raise ValueError(u'账号不能为空')
account = self.db.query(models.TrAccount).get(account_number)
self.db.query(models.TrAcceptLog).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrAccountAttr).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrBilling).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrTicket).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrOnline).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrAccount).filter_by(account_number=account.account_number).delete()
self.db.query(models.TrCustomerOrder).filter_by(account_number=account.account_number).delete()
self.add_oplog(u'删除用户账号%s' % account.account_number)
self.db.commit()
dispatch.pub(ACCOUNT_DELETE_EVENT, account.account_number, async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAcceptLog.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccountAttr.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrBilling.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOnline.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccount.__tablename__, dict(account_number=account.account_number)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrCustomerOrder.__tablename__, dict(account_number=account.account_number)), async=True)
return True
except Exception as err:
self.db.rollback()
self.last_error = u'用户删除失败:%s' % utils.safeunicode(err.message)
logger.error(self.last_error, tag='account_delete_error', username=account_number)
return False
def event_account_delete(self, account_number):
logger.info('account delete event:{}'.format(account_number),
trace='event')
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAcceptLog.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAccountAttr.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrBilling.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrOnline.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAccount.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrCustomerOrder.__tablename__,
dict(account_number=account_number)),
async=True)
dispatch.pub(db_cache.CACHE_DELETE_EVENT,
account_cache_key(account_number),
async=True)
def get(self):
pool_id = self.get_argument('pool_id')
pool_name = self.db.query(
models.TrAddrPool.pool_name).filter_by(id=pool_id).scalar()
self.db.query(models.TrAddrPool).filter_by(id=pool_id).delete()
self.add_oplog(u'删除地址池信息:%s' % pool_name)
self.db.commit()
dispatch.pub(ROSSYNC_DEL_POOL, pool_name, async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrAddrPool.__tablename__,
dict(id=pool_id)),
async=True)
self.redirect('/admin/addrpool', permanent=False)
def delete(self, agency_id, **kwargs):
try:
agency = self.db.query(models.TrAgency).get(agency_id)
if not agency:
raise ValueError(u'代理商不存在')
if self.db.query(models.TrCustomer).filter_by(agency_id=agency_id).count() > 0:
return ValueError(u'代理商下有用户，不允许删除')
opr = self.db.query(models.TrOperator).filter_by(operator_name=agency.operator_name).first()
if opr:
self.db.query(models.TrOperatorRule).filter_by(operator_name=opr.operator_name).delete()
self.db.query(models.TrOperator).filter_by(id=opr.id).delete()
self.db.query(models.TrAgency).filter_by(id=agency_id).delete()
self.add_oplog(u'删除代理商%s信息' % utils.safeunicode(agency.agency_name))
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOperatorRule.__tablename__, dict(operator_name=agency.operator_name)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOperator.__tablename__, dict(id=opr.id)), async=True)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAgency.__tablename__, dict(id=agency_id)), async=True)
return True
except Exception as err:
self.db.rollback()
logger.exception(err, tag='agency_delete_error')
self.last_error = u'代理商删除失败:%s' % utils.safeunicode(err)
return False
def delete(self, bas_id, **kwargs):
try:
self.db.query(models.TrBas).filter_by(id=bas_id).delete()
self.add_oplog(u'删除接入设备信息:%s' % bas_id)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrBas.__tablename__,
dict(id=bas_id)),
async=True)
return True
except Exception as err:
self.db.rollback()
logger.exception(err, tag='bas_delete_error')
self.last_error = u'删除接入设备失败:%s' % utils.safeunicode(err)
return False
def delete(self, product_id, **kwargs):
try:
if product_id.startswith('HOLD-000000-'):
raise Exception(u'该套餐是系统保留资费套餐，不允许删除')
if self.db.query(models.TrAccount).filter_by(
product_id=product_id).count() > 0:
raise Exception(u'该套餐有用户使用，不允许删除')
self.db.query(models.TrProduct).filter_by(id=product_id).delete()
self.db.query(models.TrProductCharges).filter_by(
product_id=product_id).delete()
self.db.query(models.TrProductAttr).filter_by(
product_id=product_id).delete()
opsdesc = u'删除资费信息:%s' % product_id
self.add_oplog(opsdesc)
self.db.commit()
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(models.TrProduct.__tablename__,
dict(id=product_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(
models.TrProductCharges.__tablename__,
dict(product_id=product_id)),
async=True)
dispatch.pub(DBSYNC_STATUS_ADD,
models.warp_sdel_obj(
models.TrProductAttr.__tablename__,
dict(product_id=product_id)),
async=True)
self.update_cache_event(product_id)
return True
except Exception as err:
self.db.rollback()
logger.exception(err, tag='product_delete_error')
self.last_error = u'操作失败:%s' % utils.safeunicode(err)
return False
def event_clear_online(self, account_number, nas_addr, acct_session_id):
try:
with make_db(self.db) as db:
logger.info('event clear expire online [username:{0}] {1} {2}'.format(account_number, nas_addr, acct_session_id), username=account_number)
nas = db.query(models.TrBas).filter_by(ip_addr=nas_addr).first()
if nas_addr and not nas:
db.query(models.TrOnline).filter_by(nas_addr=nas_addr, acct_session_id=acct_session_id).delete()
db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOnline.__tablename__, dict(nas_addr=nas_addr, acct_session_id=acct_session_id)), async=True)
return
online = db.query(models.TrOnline).filter_by(nas_addr=nas_addr, acct_session_id=acct_session_id).first()
clear_req = self.get_request(online)
radius_acct_stop.RadiusAcctStop(self.dbengine, self.mcache, self.aes, clear_req).acctounting()
logger.info(u'系统触发用户过期清理成功: [username:%s] OnlineInfo: %s ' % (str(account_number), json.dumps(clear_req)), trace='event', username=account_number)
except Exception as err:
logger.exception(err)
def event_unlock_online(self, account_number, nas_addr, acct_session_id):
with make_db(self.db) as db:
logger.info('event unlock online [username:{0}] {1} {2}'.format(account_number, nas_addr, acct_session_id), username=account_number)
nas = db.query(models.TrBas).filter_by(ip_addr=nas_addr).first()
if nas_addr and not nas:
db.query(models.TrOnline).filter_by(nas_addr=nas_addr, acct_session_id=acct_session_id).delete()
db.commit()
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrOnline.__tablename__, dict(nas_addr=nas_addr, acct_session_id=session_id)), async=True)
return
online = db.query(models.TrOnline).filter_by(nas_addr=nas_addr, acct_session_id=acct_session_id).first()
dm_params = dict(User_Name=account_number, Framed_IP_Address=online.framed_ipaddr, Acct_Session_Id=acct_session_id)
if int(self.get_param_value('radius_coa_send_nasaddr', 0)):
dm_params['NAS_IP_Address'] = nas.ip_addr
deferd = authorize.disconnect(int(nas.vendor_id or 0), self.dictionary, nas.bas_secret, nas.ip_addr, coa_port=int(nas.coa_port or 3799), debug=True, **dm_params).addCallback(self.onSendResp, self.get_request(online)).addErrback(self.onSendError, self.get_request(online))
logreq = u'nas_addr=%s;coa_port=%s; username=%s; session_id=%s' % (nas.ip_addr,
int(nas.coa_port or 3799),
account_number,
acct_session_id)
logger.info(u'%s - 系统触发用户强制下线请求: CoaRequest: %s ' % logreq, trace='event', username=account_number)
def update_user_expire(self, new_expire):
table = models.TrAccount.__table__
with self.dbengine.begin() as conn:
stmt = table.update().where(table.c.account_number == self.account.account_number).values(expire_date=new_expire, status=1, sync_ver=tools.gen_sync_ver())
conn.execute(stmt)
dispatch.pub(DBSYNC_STATUS_ADD, models.warp_sdel_obj(models.TrAccount.__tablename__, dict(account_number=self.account.account_number)), async=True)